+++ /dev/null
-[Buildset]
-BuildItems=@Variant(\x00\x00\x00\t\x00\x00\x00\x00\x01\x00\x00\x00\x0b\x00\x00\x00\x00\x01\x00\x00\x00\x12\x00m\x00a\x00t\x00h\x00g\x00l\x00-\x002\x00x)
-
-[CMake]
-BuildDirs=/home/balakin/progr/sfnet/mathgl/mathgl-2x/build
-CMakeDir=/usr/share/cmake-2.8/Modules
-Current CMake Binary=file:///usr/bin/cmake
-CurrentBuildDir=file:///home/balakin/progr/sfnet/mathgl/mathgl-2x/build
-CurrentBuildType=Debug
-CurrentInstallDir=
-Extra Arguments=
-ProjectRootRelative=./
-
-[Launch]
-Launch Configurations=Launch Configuration 0,Launch Configuration 1
-
-[Launch][Launch Configuration 0]
-Configured Launch Modes=execute
-Configured Launchers=nativeAppLauncher
-Name=fltk_example
-Type=Native Application
-
-[Launch][Launch Configuration 0][Data]
-Arguments=-test
-Dependencies=@Variant(\x00\x00\x00\t\x00\x00\x00\x00\x01\x00\x00\x00\x0b\x00\x00\x00\x00\x03\x00\x00\x00\x12\x00m\x00a\x00t\x00h\x00g\x00l\x00-\x002\x00x\x00\x00\x00\n\x00u\x00t\x00i\x00l\x00s\x00\x00\x00\x0e\x00m\x00g\x00l\x00c\x00o\x00n\x00v)
-Dependency Action=Build
-EnvironmentGroup=default
-Executable=file:///home/balakin/progr/sfnet/mathgl/mathgl-2x/build/examples/mgl_fltk_example
-External Terminal=konsole --noclose --workdir %workdir -e %exe
-Project Target=mathgl-2x,utils,mglconv
-Use External Terminal=false
-Working Directory=
-isExecutable=true
-
-[Launch][Launch Configuration 1]
-Configured Launch Modes=execute
-Configured Launchers=nativeAppLauncher
-Name=udav
-Type=Native Application
-
-[Launch][Launch Configuration 1][Data]
-Arguments=
-Debugger Shell=
-Dependencies=@Variant(\x00\x00\x00\t\x00\x00\x00\x00\x00)
-Dependency Action=Nothing
-Display Demangle Names=true
-Display Static Members=false
-EnvironmentGroup=default
-Executable=file:///home/balakin/progr/sfnet/mathgl/mathgl-2x/build/udav/udav
-External Terminal=konsole --noclose --workdir %workdir -e %exe
-GDB Path=
-Project Target=
-Remote GDB Config Script=
-Remote GDB Run Script=
-Remote GDB Shell Script=
-Use External Terminal=false
-Working Directory=
-isExecutable=true
-
-[Project]
-VersionControlSupport=kdevsubversion
-cmake_minimum_required(VERSION 2.6)
+cmake_minimum_required(VERSION 2.8)
project( MathGL )
set(CMAKE_VERBOSE_MAKEFILE ON)
set(MathGL_VERSION_MAJOR 2)
set(MathGL_VERSION_MINOR 0)
-option(enable-double "Enable double precision in MathGL library")
+option(enable-double "Enable double precision in MathGL library" ON)
+option(enable-simple "Slightly increase drawing speed but disable mglDataA class")
+option(enable-mpi "Enable mpi")
option(enable-all "Enable all features")
option(enable-langall "Enable all language interfaces")
option(enable-lgpl "Enable only LGPL part of MathGL" OFF)
-option(enable-ltdl "Enable loading modules support")
+# option(enable-ltdl "Enable loading modules support")
option(enable-pthread "Enable POSIX threads support")
option(enable-gsl "Enable gsl support")
option(enable-jpeg "Enable jpeg support")
+option(enable-png "Enable png support" ON)
+option(enable-zlib "Enable zlib support" ON)
#option(enable-u3d "Enable u3d support")
option(enable-pdf "Enable pdf support")
option(enable-gif "Enable gif support")
include_directories( ${MathGL_SOURCE_DIR}/include ${MathGL_BINARY_DIR}/include)
+if(NOT MSVC)
+ find_library(M_LIB m)
+ if(NOT M_LIB)
+ message(SEND_ERROR "${M_LIB}")
+ endif(NOT M_LIB)
+else(NOT MSVC)
+ set(M_LIB)
+endif(NOT MSVC)
+
if(enable-double)
set(MGL_USE_DOUBLE 1)
else(enable-double)
set(MGL_USE_DOUBLE 0)
endif(enable-double)
-include(FindZLIB)
-if(NOT ZLIB_FOUND)
- message(SEND_ERROR "Couldn't find ZLIB library.")
-endif(NOT ZLIB_FOUND)
+if(enable-simple)
+ set(MGL_NO_DATA_A 1)
+message(STATUS "Class mglDataA is switched off.")
+else(enable-simple)
+ set(MGL_NO_DATA_A 0)
+endif(enable-simple)
-include(FindPNG)
-if(NOT PNG_FOUND)
- message(SEND_ERROR "Couldn't find PNG libraries.")
-endif(NOT PNG_FOUND)
+if(enable-mpi)
+ set(MGL_HAVE_MPI 1)
+ find_package(MPI REQUIRED)
+ set(CMAKE_CXX_COMPILE_FLAGS ${CMAKE_CXX_COMPILE_FLAGS} ${MPI_COMPILE_FLAGS})
+ set(CMAKE_CXX_LINK_FLAGS ${CMAKE_CXX_LINK_FLAGS} ${MPI_LINK_FLAGS})
+ include_directories(MPI_INCLUDE_PATH)
+else(enable-mpi)
+ set(MGL_HAVE_MPI 0)
+endif(enable-mpi)
if((enable-all OR enable-gsl) AND (NOT enable-lgpl) )
set(MGL_HAVE_GSL 1)
set(MGL_HAVE_GSL 0)
endif((enable-all OR enable-gsl) AND (NOT enable-lgpl) )
-if(enable-all OR enable-ltdl)
- set(MGL_HAVE_LTDL 1)
- find_library(LTDL_LIB ltdl)
- find_path(LTDL_INCLUDE_DIR ltdl.h)
- if(NOT LTDL_LIB OR NOT LTDL_INCLUDE_DIR)
- message(SEND_ERROR "${LTDL_LIB}")
- message(SEND_ERROR "${LTDL_INCLUDE_DIR}")
- message(SEND_ERROR "Couldn't find LTDL library.")
- endif(NOT LTDL_LIB OR NOT LTDL_INCLUDE_DIR)
-else(enable-all OR enable-ltdl)
- set(MGL_HAVE_LTDL 0)
-endif(enable-all OR enable-ltdl)
+# if(enable-all OR enable-ltdl)
+# set(MGL_HAVE_LTDL 1)
+# find_library(LTDL_LIB ltdl)
+# find_path(LTDL_INCLUDE_DIR ltdl.h)
+# if(NOT LTDL_LIB OR NOT LTDL_INCLUDE_DIR)
+# message(SEND_ERROR "${LTDL_LIB}")
+# message(SEND_ERROR "${LTDL_INCLUDE_DIR}")
+# message(SEND_ERROR "Couldn't find LTDL library.")
+# endif(NOT LTDL_LIB OR NOT LTDL_INCLUDE_DIR)
+# else(enable-all OR enable-ltdl)
+# set(MGL_HAVE_LTDL 0)
+# endif(enable-all OR enable-ltdl)
if(enable-all OR enable-pthread)
set(MGL_HAVE_PTHREAD 1)
set(MGL_HAVE_JPEG 0)
endif(enable-all OR enable-jpeg)
+
+if(enable-all OR enable-zlib)
+ set(MGL_HAVE_ZLIB 1)
+ include(FindZLIB)
+ if(NOT ZLIB_FOUND)
+ message(SEND_ERROR "Couldn't find ZLib library.")
+ endif(NOT ZLIB_FOUND)
+else(enable-all OR enable-zlib)
+ set(MGL_HAVE_ZLIB 0)
+endif(enable-all OR enable-zlib)
+
+if(enable-all OR enable-png)
+ set(MGL_HAVE_PNG 1)
+ if(NOT MGL_HAVE_ZLIB)
+ message(SEND_ERROR "You have to enable ZLib if you plan to use PNG export.")
+ endif(NOT MGL_HAVE_ZLIB)
+ include(FindPNG)
+ if(NOT PNG_FOUND)
+ message(SEND_ERROR "Couldn't find PNG library.")
+ endif(NOT PNG_FOUND)
+else(enable-all OR enable-png)
+ set(MGL_HAVE_PNG 0)
+endif(enable-all OR enable-png)
+
+
# if(enable-u3d AND (NOT enable-lgpl) )
# set(MGL_HAVE_U3D 1)
# find_library(U3D_LIB IDTF)
if((enable-all OR enable-pdf) AND (NOT enable-lgpl) )
set(MGL_HAVE_PDF 1)
+ if(NOT MGL_HAVE_PNG)
+ message(SEND_ERROR "You have to enable PNG if you plan to use PDF export.")
+ endif(NOT MGL_HAVE_PNG)
find_library(HPDF_LIB hpdf)
if(NOT HPDF_LIB)
message(SEND_ERROR "Couldn't find libHaru.")
endif(NOT HPDF_LIB)
find_path(HPDF_INCLUDE_DIR hpdf_u3d.h)
if(NOT HPDF_INCLUDE_DIR)
- message(SEND_ERROR "Couldn't find headers of 3d-enabled version of libHaru.")
+ message(SEND_ERROR "Couldn't find headers of 3d-enabled version of libhpdf.")
endif(NOT HPDF_INCLUDE_DIR)
# message(STATUS "Found libHaru library at: ${HPDF_LIB}")
# message(STATUS "Found libHaru headers: ${HPDF_INCLUDE_DIR}")
if(NOT oct_prog)
message(SEND_ERROR "Couldn't find octave-config needed for octave interfaces compiling.")
endif(NOT oct_prog)
+ find_program(oct_exec octave)
+ if(NOT oct_exec)
+ message(SEND_ERROR "Couldn't find octave needed for octave interfaces compiling.")
+ endif(NOT oct_exec)
find_program(oct_mk mkoctfile)
if(NOT oct_mk)
message(SEND_ERROR "Couldn't find mkoctfile needed for octave interfaces compiling.")
set(MGL_HAVE_OCTAVE 0)
endif((enable-langall OR enable-octave) AND (NOT enable-lgpl) )
-if(enable-all OR enable-doc)
+if(enable-doc)
set(MGL_HAVE_DOC 1)
find_program(findmi makeinfo)
if(NOT findmi)
if(NOT findtp)
message(SEND_ERROR "Couldn't find texi2pdf needed for documentation building.")
endif(NOT findtp)
-else(enable-all OR enable-doc)
+else(enable-doc)
set(MGL_HAVE_DOC 0)
-endif(enable-all OR enable-doc)
+endif(enable-doc)
if(MGL_HAVE_PYTHON OR MGL_HAVE_OCTAVE)
FIND_PACKAGE(SWIG)
endif(UNIX)
if(WIN32)
-# add_definitions(-DWIN32 -D_MSC_VER)
add_definitions(-DWIN32)
endif(WIN32)
set(MGL_DATA_PATH "${CMAKE_INSTALL_PREFIX}/share/mathgl")
set(MGL_DOC_PATH "${CMAKE_INSTALL_PREFIX}/share/doc/mathgl")
set(MGL_MAN_PATH "${CMAKE_INSTALL_PREFIX}/share/man")
+set(MGL_INFO_PATH "${CMAKE_INSTALL_PREFIX}/share/info")
set(MGL_FONT_PATH "${MGL_DATA_PATH}/fonts")
install(DIRECTORY fonts/ DESTINATION ${MGL_FONT_PATH}
PATTERN ".svn" EXCLUDE
add_subdirectory( src )
add_subdirectory( widgets )
-add_subdirectory( utils )
add_subdirectory( include )
add_subdirectory( udav )
#add_subdirectory( mgllab )
add_subdirectory( lang )
+if(NOT MSVC)
+add_subdirectory( utils )
add_subdirectory( examples )
add_subdirectory( texinfo )
+endif(NOT MSVC)
--- /dev/null
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+ This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+ 0. Additional Definitions.
+
+ As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+ "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+ An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+ A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+ The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+ The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+ 1. Exception to Section 3 of the GNU GPL.
+
+ You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+ 2. Conveying Modified Versions.
+
+ If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+ a) under this License, provided that you make a good faith effort to
+ ensure that, in the event an Application does not supply the
+ function or data, the facility still operates, and performs
+ whatever part of its purpose remains meaningful, or
+
+ b) under the GNU GPL, with none of the additional permissions of
+ this License applicable to that copy.
+
+ 3. Object Code Incorporating Material from Library Header Files.
+
+ The object code form of an Application may incorporate material from
+a header file that is part of the Library. You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+ a) Give prominent notice with each copy of the object code that the
+ Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the object code with a copy of the GNU GPL and this license
+ document.
+
+ 4. Combined Works.
+
+ You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+ a) Give prominent notice with each copy of the Combined Work that
+ the Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the Combined Work with a copy of the GNU GPL and this license
+ document.
+
+ c) For a Combined Work that displays copyright notices during
+ execution, include the copyright notice for the Library among
+ these notices, as well as a reference directing the user to the
+ copies of the GNU GPL and this license document.
+
+ d) Do one of the following:
+
+ 0) Convey the Minimal Corresponding Source under the terms of this
+ License, and the Corresponding Application Code in a form
+ suitable for, and under terms that permit, the user to
+ recombine or relink the Application with a modified version of
+ the Linked Version to produce a modified Combined Work, in the
+ manner specified by section 6 of the GNU GPL for conveying
+ Corresponding Source.
+
+ 1) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (a) uses at run time
+ a copy of the Library already present on the user's computer
+ system, and (b) will operate properly with a modified version
+ of the Library that is interface-compatible with the Linked
+ Version.
+
+ e) Provide Installation Information, but only if you would otherwise
+ be required to provide such information under section 6 of the
+ GNU GPL, and only to the extent that such information is
+ necessary to install and execute a modified version of the
+ Combined Work produced by recombining or relinking the
+ Application with a modified version of the Linked Version. (If
+ you use option 4d0, the Installation Information must accompany
+ the Minimal Corresponding Source and Corresponding Application
+ Code. If you use option 4d1, you must provide the Installation
+ Information in the manner specified by section 6 of the GNU GPL
+ for conveying Corresponding Source.)
+
+ 5. Combined Libraries.
+
+ You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+ a) Accompany the combined library with a copy of the same work based
+ on the Library, uncombined with any other library facilities,
+ conveyed under the terms of this License.
+
+ b) Give prominent notice with the combined library that part of it
+ is a work based on the Library, and explaining where to find the
+ accompanying uncombined form of the same work.
+
+ 6. Revised Versions of the GNU Lesser General Public License.
+
+ The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+ If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+2.0.3 Released 27 July 2012
+
+* Make code compilable by compilers GNU/MinGW GCC, Clang, MS VisualStudio
+* Add mglTriangulation() using s_hull_pro algorithm
+* Add mglData::Grid() and mglGraph::DataGrid() for filling regular data by values of triangulated surface
+* Add cmake options 'enable-png' and 'enable-zlib'
+* Add SetTimeUTC() for using UTC time instead of local one
+* Add SetTickShift() for additional shift of tick labels
+* Add mglGraph::MPI_Send() and mglGraph::MPI_Recv()
+* Vector plots now draw vector at edges, which are directed out of bounding box
+* Add gap between 1d plots for avoiding possible undetermined overlapping.
+* Add parallel build for documentation
+* Bugfixes for memory leaks and uninitialized variables
+* Bugfix for setting text size
+* Bugfix for handling NAN color value
+* Bugfix for missing lines in export to EPS/SVG
+
+2.0.2 Released 24 May 2012
+
+* Add 'U' style for Axis() which disable ticks rotation.
+* Bugfix for enable-opengl option.
+* Bugfix for lighting.
+
+2.0.1 Released 23 May 2012
+
+* Improve speed of drawing
+* Add reading 3d data files using mglData::ReadMat()
+* Exclude unnecessary dependencies/inclusions
+* Improve build system
+ - Add multithreading
+ - Add install for Octave
+ - Separate enable-doc option from enable-all
+* Minor bugfixes
+
2.0 Released 12 April 2012
--- /dev/null
+setsize 1000 500
+text 0.95 0.8 'MathGL' ':RiA' -4
+text 0.05 0.15 'library\n for scientific graphics' ':LiA' -2.5
+#rect 0.05 0.9 2 1.5 1.34 2 'w'
+xtick -3:ytick -3:ztick -3
+subplot 1 1 0 '^_'
+
+stickplot 3 0 60 20:box
+new y 50: fill y '-cos(pi*x-pi/4)'
+new x 50: fill x '-sin(pi*x-pi/4)'
+new z 50: fill z '2*x^2-1'
+
+area x y z 'lG'
+plot x y z 'B2s'
+
+stickplot 3 1 60 20:box
+
+new aa 50 40
+modify aa '0.6*sin(2*pi*x)*sin(3*pi*y) + 0.4*cos(3*pi*(x*y))'
+mirror aa 'y'
+light on :alpha on
+surf aa 'BbcyrR';alpha 0.8
+cont aa 'y'
+
+stickplot 3 2 60 20:box
+rotate 0 20
+
+new a 61 51 40
+modify a '-2*((2*x-1)^2 + (2*y-1)^2 + (2*z-1)^4 - (2*z-1)^2 - 0.1)'
+
+alpha on:light off
+cloud a 'wyrRk'
+
+stop
+cut 0 -1 -1 1 0 1.1
+surf3 a -1 'BbcyrR'
+contf3 a 'x' -1
+contf3 a 'y' -1
+contf3 a 'z' 0
+contf3 a 'z' 39
add_executable(mgl_example wnd_samples.cpp full_test.cpp)
target_link_libraries(mgl_example mgl)
-install(
- TARGETS mgl_example
- RUNTIME DESTINATION bin
-)
+# install(
+# TARGETS mgl_example
+# RUNTIME DESTINATION bin
+# )
if(MGL_HAVE_FLTK)
add_executable(mgl_fltk_example wnd_samples.cpp fltk_example.cpp)
target_link_libraries(mgl_fltk_example mgl-wnd)
- install(
- TARGETS mgl_fltk_example
- RUNTIME DESTINATION bin
- )
+# install(
+# TARGETS mgl_fltk_example
+# RUNTIME DESTINATION bin
+# )
endif(MGL_HAVE_FLTK)
if(MGL_HAVE_GLUT)
add_executable(mgl_glut_example wnd_samples.cpp glut_example.cpp)
target_link_libraries(mgl_glut_example mgl-glut)
- install(
- TARGETS mgl_glut_example
- RUNTIME DESTINATION bin
- )
+# install(
+# TARGETS mgl_glut_example
+# RUNTIME DESTINATION bin
+# )
endif(MGL_HAVE_GLUT)
if(MGL_HAVE_WX)
include(${wxWidgets_USE_FILE})
add_executable(mgl_wx_example wnd_samples.cpp wx_example.cpp)
target_link_libraries(mgl_wx_example ${wxWidgets_LIBRARIES} mgl-wnd)
- install(
- TARGETS mgl_wx_example
- RUNTIME DESTINATION bin
- )
+# install(
+# TARGETS mgl_wx_example
+# RUNTIME DESTINATION bin
+# )
endif(MGL_HAVE_WX)
if(MGL_HAVE_QT)
qt_wrap_cpp(mgl_qt_example MGL_MOC_EX_FILES ../include/mgl2/qt.h)
add_executable(mgl_qt_example wnd_samples.cpp qt_example.cpp ${MGL_MOC_EX_FILES})
target_link_libraries(mgl_qt_example mgl-wnd ${QT_LIBRARIES})
- install(
- TARGETS mgl_qt_example
- RUNTIME DESTINATION bin
- )
+# install(
+# TARGETS mgl_qt_example
+# RUNTIME DESTINATION bin
+# )
endif(MGL_HAVE_QT)
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdio.h>\r
-#include "mgl2/mgl.h"\r
-#include "mgl2/fltk.h"\r
+#include "mgl2/window.h"\r
+#if defined(WIN32) || defined(_MSC_VER) || defined(__BORLANDC__)\r
+#include <windows.h>\r
+#endif\r
//-----------------------------------------------------------------------------\r
int test_wnd(mglGraph *gr);\r
int sample(mglGraph *gr);\r
int sample_3(mglGraph *gr);\r
int sample_d(mglGraph *gr);\r
//-----------------------------------------------------------------------------\r
-#include <unistd.h>\r
+//#include <unistd.h>\r
mglPoint pnt; // some global variable for changable data\r
void *mgl_fltk_tmp(void *) { mgl_fltk_run(); return 0; }\r
//#define PTHREAD_SAMPLE\r
gr.RunThr();\r
for(int i=0;i<10;i++) // do calculation\r
{\r
-#ifdef WIN32\r
+#if defined(WIN32) || defined(_MSC_VER) || defined(__BORLANDC__)\r
Sleep(1000);\r
#else\r
sleep(1); // which can be very long\r
#else\r
mglWindow *gr;\r
char key = 0;\r
- if(argc>1 && argv[1][0]!='-') key = argv[1][0];\r
+ if(argc>1) key = argv[1][0]!='-' ? argv[1][0]:argv[1][1];\r
else printf("You may specify argument '1', '2', '3' or 'd' for viewing examples of 1d, 2d, 3d or dual plotting\n");\r
switch(key)\r
{\r
case '1': gr = new mglWindow(sample_1,"1D plots",0); break;\r
case '2': gr = new mglWindow(sample_2,"2D plots",0); break;\r
case '3': gr = new mglWindow(sample_3,"3D plots",0); break;\r
- case 'd': gr = new mglWindow(sample_d,"Dual plots",0);break;\r
+ case 'd': gr = new mglWindow(sample_d,"Dual plots",0); break;\r
case 't': gr = new mglWindow(test_wnd,"Testing",0); break;\r
default: gr = new mglWindow(sample,"Drop and waves",0); break;\r
}\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <wchar.h>\r
#include <time.h>\r
#include <locale.h>\r
-#include <string.h>\r
-#include <stdio.h>\r
-#include <stdlib.h>\r
+#if !defined(_MSC_VER) && !defined(__BORLANDC__)\r
#include <getopt.h>\r
+#endif\r
#include <vector>\r
#include "mgl2/mgl.h"\r
#include "mgl2/eval.h"\r
void save(mglGraph *gr,const char *name,const char *suf);\r
void test(mglGraph *gr)\r
{\r
- mglData y; mgls_prepare1d(&y); gr->SetOrigin(0,0,0);\r
- if(!mini) { gr->SubPlot(2,2,0,""); gr->Title("Area plot (default)"); }\r
- gr->Box(); gr->Area(y);\r
- if(mini) return;\r
- gr->SubPlot(2,2,1,""); gr->Title("2 colors"); gr->Box(); gr->Area(y,"cbgGyr");\r
- gr->SubPlot(2,2,2,""); gr->Title("'!' style"); gr->Box(); gr->Area(y,"!");\r
- gr->SubPlot(2,2,3); gr->Title("3d variant"); gr->Rotate(50,60); gr->Box();\r
- mglData yc(30), xc(30), z(30); z.Modify("2*x-1");\r
- yc.Modify("sin(pi*(2*x-1))"); xc.Modify("cos(pi*2*x-pi)");\r
- gr->Area(xc,yc,z,"r");\r
+ float itime =0, ltime=100;\r
+ \r
+ gr->MultiPlot(10,1,2, 8,1);\r
+ gr->SetTickLen(-.02);\r
+ gr->SetTickShift(mglPoint(0.2,0.2));\r
+ gr->SetRanges((float) itime,(float) ltime,-3.,3);\r
+ gr->SetOrigin(NAN,NAN);\r
+ gr->SetTimeUTC(true);\r
+ \r
+ gr->SetTicksTime('x');\r
+ gr->Axis("y", "b");\r
+ gr->Axis("x");\r
+ gr->SetOrigin(itime,3);gr->Axis("x_");\r
+ gr->Label('y',"y_1",0);\r
+ gr->FPlot("2.5","k");\r
+ gr->SetRanges((float) itime,(float) ltime,-10,10);\r
+ gr->SetOrigin(ltime,-10); // second axis\r
+ gr->Axis("y","r"); gr->Label('y',"#r{y_r}",0.2);\r
+ gr->FPlot("5.5","r");\r
+ gr->SetRanges((float) itime,(float) ltime,-1,1);\r
+ gr->SetOrigin(itime-(ltime-itime)/7.,-1); // second axis\r
+ gr->Axis("y","b"); gr->Label('y',"#r{y_2}",0.2);\r
+ gr->FPlot("0.5","r");\r
+ gr->SetRanges((float) itime,(float) ltime,-2,1);\r
+ gr->SetOrigin(itime-2*(ltime-itime)/7.,-2); // second axis\r
+ gr->Axis("y","b"); gr->Label('y',"#r{y_2}",0.2);\r
+ gr->FPlot("0.5","r");\r
+ gr->SetRanges((float) itime,(float) ltime,-2,2);\r
+ gr->SetOrigin(itime-3*(ltime-itime)/7.,-2); // second axis\r
+ gr->Axis("y","r"); gr->Label('y',"#r{y_3}",0.2);\r
+ gr->FPlot("-1.5","r");\r
+ gr->SetRanges((float) itime,(float) ltime,-20,20);\r
+ gr->SetOrigin(itime-4*(ltime-itime)/7.,-20); // second axis\r
+ gr->Axis("y","r"); gr->Label('y',"#r{y_3}",0.2);\r
+ gr->FPlot("-15","r");\r
+ \r
+ gr->WriteJPEG("1.jpg");\r
+ gr->WriteEPS("1.eps");\r
return;\r
+ \r
+ mglData ys(10), y;\r
+ ys.Modify("0.8*sin(pi*2*x)+0.2*rnd");\r
+ mgls_prepare1d(&y);\r
+\r
+ gr->SubPlot(2,2,0);\r
+ gr->SetOrigin(mglPoint(-1,-1,-1)); gr->Axis();\r
+ gr->SetOrigin(mglPoint(1,1,1)); gr->Axis();\r
+ gr->Box(); gr->Plot(ys," *"); gr->Label(ys,"y=%y");\r
+ gr->Label('x',"x_y label"); gr->Label('y',"y_y label"); gr->Label('z',"z_y label");\r
+\r
+ gr->SubPlot(2,2,1); gr->Rotate(40,60);\r
+ gr->SetOrigin(mglPoint(-1,-1,-1)); gr->Axis();\r
+ gr->SetOrigin(mglPoint(1,1,1)); gr->Axis();\r
+ gr->SetOrigin(mglPoint(NAN,NAN,NAN)); gr->Axis();\r
+ gr->Label('x',"x_y label"); gr->Label('y',"y_y label"); gr->Label('z',"z_y label");\r
\r
- mglParse par;\r
+ gr->SubPlot(2,2,2);\r
+ gr->Box(); gr->Plot(y.SubData(-1,0));\r
+ gr->Text(y,"This is very very long string drawn along a curve",":k");\r
+ gr->Text(y,"Another string drawn above a curve","T:r");\r
+\r
+ gr->SubPlot(2,2,3);\r
+ mglPoint p;\r
+ gr->Mark(p,".r");\r
+ gr->Puts(p,"A","@:C",-1);\r
+ gr->Puts(p,"A","@:C",-2);\r
+ \r
+ gr->SetRange('x',1341610306,1341612408);\r
+ gr->SetTicksTime('x');\r
+ gr->Axis();\r
+ return;\r
+\r
+ /* mglParse par;\r
par.AllowSetSize(true);\r
setlocale(LC_CTYPE, "");\r
FILE *fp=fopen("/home/balakin/progr/sfnet/mathgl/mathgl-2x/examples/test.mgl","r");\r
par.Execute(gr,fp,true);\r
- fclose(fp);\r
+ fclose(fp);*/\r
}\r
//-----------------------------------------------------------------------------\r
void fexport(mglGraph *gr)\r
//-----------------------------------------------------------------------------\r
// Sample functions (v.2.*0)\r
//-----------------------------------------------------------------------------\r
+const char *mmgl_triangulation="new x 100 '2*rnd-1':new y 100 '2*rnd-1':copy z x^2-y^2\n"\r
+"new g 30 30:triangulate d x y\n"\r
+"title 'Triangulation'\nrotate 50 60:box:light on\n"\r
+"triplot d x y z:triplot d x y z '#k'\ndatagrid g x y z:mesh g 'm'\n";\r
+void smgl_triangulation(mglGraph *gr) // alpha and lighting\r
+{\r
+ mglData x(100), y(100), z(100);\r
+ gr->Fill(x,"2*rnd-1"); gr->Fill(y,"2*rnd-1"); gr->Fill(z,"v^2-w^2",x,y);\r
+ mglData d = mglTriangulation(x,y), g(30,30);\r
+ \r
+ if(!mini) gr->Title("Triangulation");\r
+ gr->Rotate(40,60); gr->Box(); gr->Light(true);\r
+ gr->TriPlot(d,x,y,z); gr->TriPlot(d,x,y,z,"#k");\r
+\r
+ gr->DataGrid(g,x,y,z); gr->Mesh(g,"m");\r
+}\r
+//-----------------------------------------------------------------------------\r
const char *mmgl_alpha="subplot 2 2 0:title 'default':rotate 50 60:box\nsurf a\n"\r
"subplot 2 2 0:title 'light on':rotate 50 60:box\nlight on:surf a\n"\r
"subplot 2 2 0:title 'light on; alpha on':rotate 50 60:box\nalpha on:surf a\n"\r
void smgl_style(mglGraph *gr) // pen styles\r
{\r
gr->SubPlot(2,2,0);\r
- float d,x1,x2,x0,y=0.95;\r
+ double d,x1,x2,x0,y=0.95;\r
d=0.3, x0=0.2, x1=0.5, x2=0.6;\r
gr->Line(mglPoint(x0,1-0*d),mglPoint(x1,1-0*d),"k-"); gr->Puts(mglPoint(x2,y-0*d),"Solid '-'",":rL");\r
gr->Line(mglPoint(x0,1-1*d),mglPoint(x1,1-1*d),"k|"); gr->Puts(mglPoint(x2,y-1*d),"Long Dash '|'",":rL");\r
gr->Mark(mglPoint(x1,-5*d,0),"#>"); gr->Puts(mglPoint(x0,y-5*d),"'\\#>'",":rL");\r
\r
gr->SubPlot(2,2,1);\r
- float a=0.1,b=0.4,c=0.5;\r
+ double a=0.1,b=0.4,c=0.5;\r
gr->Line(mglPoint(a,1),mglPoint(b,1),"k-A"); gr->Puts(mglPoint(c,1),"Style 'A' or 'A\\_'",":rL");\r
gr->Line(mglPoint(a,0.8),mglPoint(b,0.8),"k-V"); gr->Puts(mglPoint(c,0.8),"Style 'V' or 'V\\_'",":rL");\r
gr->Line(mglPoint(a,0.6),mglPoint(b,0.6),"k-K"); gr->Puts(mglPoint(c,0.6),"Style 'K' or 'K\\_'",":rL");\r
const char *mmgl_text="subplot 2 2 0 ''\ntext 0 1 'Text can be in ASCII and in Unicode'\ntext 0 0.6 'It can be \\wire{wire}, \\big{big} or #r{colored}'\n"\r
"text 0 0.2 'One can change style in string: \\b{bold}, \\i{italic, \\b{both}}'\ntext 0 -0.2 'Easy to \\a{overline} or \\u{underline}'\n"\r
"text 0 -0.6 'Easy to change indexes ^{up} _{down} @{center}'\ntext 0 -1 'It parse TeX: \\int \\alpha \\cdot '\n'\\sqrt3{sin(\\pi x)^2 + \\gamma_{i_k}} dx'\n"\r
-"subplot0 2 2 1 ''\n text 0 0 '\\sqrt{\\frac{\\alpha^{\\gamma^2}+\\overset 1{\\big\\infty}}{\\sqrt3{2+b}}}' '@' -4\n"\r
+"subplot0 2 2 1 ''\n text 0 0 '\\sqrt{\\frac{\\alpha^{\\gamma^2}+\\overset 1{\\big\\infty}}{\\sqrt3{2+b}}}' '@' -2\n"\r
"subplot 2 2 2 '':box:plot y(:,0)\ntext y 'This is very very long string drawn along a curve' 'k'\ntext y 'Another string drawn above a curve' 'r:T'\n"\r
"subplot 2 2 3 '':line -1 -1 1 -1 'rA':text 0 -1 1 -1 'Horizontal'\n"\r
"line -1 -1 1 1 'rA':text 0 0 1 1 'At angle' '@'\nline -1 0 -1 1 'rA':text -1 0 -1 1 'Vertical'\n";\r
if(mini) return;\r
\r
gr->SubPlot(2,2,1,"");\r
- gr->Puts(mglPoint(0,0.5), "\\sqrt{\\frac{\\alpha^{\\gamma^2}+\\overset 1{\\big\\infty}}{\\sqrt3{2+b}}}", "@", -4);\r
+ gr->Puts(mglPoint(0,0.5), "\\sqrt{\\frac{\\alpha^{\\gamma^2}+\\overset 1{\\big\\infty}}{\\sqrt3{2+b}}}", "@", -2);\r
gr->Puts(mglPoint(0,-0.5),"Text can be printed\non several lines");\r
\r
gr->SubPlot(2,2,2,"");\r
"loadfont 'schola':text 0 1.1-8*d 'schola font'\nloadfont 'termes':text 0 1.1-9*d 'termes font'\nnloadfont ''\n";\r
void smgl_fonts(mglGraph *gr) // font typefaces\r
{\r
- float h=1.1, d=0.25;\r
+ double h=1.1, d=0.25;\r
gr->LoadFont("STIX"); gr->Puts(mglPoint(0,h), "default font (STIX)");\r
gr->LoadFont("adventor"); gr->Puts(mglPoint(0,h-d), "adventor font");\r
gr->LoadFont("bonum"); gr->Puts(mglPoint(0,h-2*d), "bonum font");\r
"subplot 2 2 3:rotate 50 60:axial a:box";\r
void smgl_type0(mglGraph *gr) // TranspType = 0\r
{\r
- // if(type==5 || type==9 || type==10) return;\r
gr->Alpha(true); gr->Light(true);\r
mglData a; mgls_prepare2d(&a);\r
gr->SetTranspType(0); gr->Clf();\r
"subplot 2 2 3:rotate 50 60:axial a:box";\r
void smgl_type1(mglGraph *gr) // TranspType = 1\r
{\r
- // if(type==5 || type==9 || type==10) return;\r
gr->Alpha(true); gr->Light(true);\r
mglData a; mgls_prepare2d(&a);\r
gr->SetTranspType(1); gr->Clf();\r
"subplot 2 2 3:rotate 50 60:axial a:box";\r
void smgl_type2(mglGraph *gr) // TranspType = 2\r
{\r
- // if(type==5 || type==9 || type==10) return;\r
gr->Alpha(true); gr->Light(true);\r
mglData a; mgls_prepare2d(&a);\r
gr->SetTranspType(2); gr->Clf();\r
{\r
mglData y; mgls_prepare1d(&y);\r
mglData x0(10), y0(10), ex0(10), ey0(10);\r
- float x;\r
+ double x;\r
for(int i=0;i<10;i++)\r
{\r
x = i/9.;\r
void smgl_parser(mglGraph *gr) // example of MGL parsing\r
{\r
gr->Title("MGL parser sample");\r
- float a[100]; // let a_i = sin(4*pi*x), x=0...1\r
+ double a[100]; // let a_i = sin(4*pi*x), x=0...1\r
for(int i=0;i<100;i++)a[i]=sin(4*M_PI*i/99);\r
mglParse *parser = new mglParse;\r
mglData *d = parser->AddVar("dat");\r
mglData rnd(100), in(100), res;\r
gr->Fill(rnd,"0.4*rnd+0.1+sin(2*pi*x)");\r
gr->Fill(in,"0.3+sin(2*pi*x)");\r
- float ini[3] = {1,1,3};\r
+ double ini[3] = {1,1,3};\r
mglData Ini(3,ini);\r
res = gr->Fit(rnd, "a+b*sin(c*x)", "abc", Ini);\r
if(!mini) gr->Title("Fitting sample");\r
if(mini) return;\r
gr->SubPlot(2,2,1); gr->Title("2 colors");\r
gr->Rotate(50,60); gr->Box(); gr->Cones(ys,"cbgGyr");\r
- gr->SubPlot(2,2,2); gr->Title("'#' style");\r
+ gr->SubPlot(2,2,2); gr->Title("'\\#' style");\r
gr->Rotate(50,60); gr->Box(); gr->Cones(ys,"#");\r
gr->SubPlot(2,2,3); gr->Title("'a' style");\r
gr->SetRange('z',-2,2); // increase range since summation can exceed [-1,1]\r
gr->SetTuneTicks(0); gr->Axis();\r
\r
gr->SubPlot(3,2,2); gr->Title("Manual ticks"); gr->SetRanges(-M_PI,M_PI, 0, 2);\r
- float val[]={-M_PI, -M_PI/2, 0, 0.886, M_PI/2, M_PI};\r
+ double val[]={-M_PI, -M_PI/2, 0, 0.886, M_PI/2, M_PI};\r
gr->SetTicksVal('x', mglData(6,val), "-\\pi\n-\\pi/2\n0\nx^*\n\\pi/2\n\\pi");\r
gr->Axis(); gr->Grid(); gr->FPlot("2*cos(x^2)^2", "r2");\r
\r
gr->MultiPlot(3,3,3,2,2,""); gr->SetRanges(-1,1,-1,1,0,1); gr->Box(); gr->Dots(x,y,z,"wyrRk");\r
gr->MultiPlot(3,3,0,2,1,""); gr->SetRanges(-1,1,0,1); gr->Box(); gr->Bars(xx);\r
gr->MultiPlot(3,3,5,1,2,""); gr->SetRanges(0,1,-1,1); gr->Box(); gr->Barh(yy);\r
- gr->SubPlot(3,3,2); gr->Puts(mglPoint(0.5,0.5),"Hist and\nMultiPlot\nsample","a",-6);\r
+ gr->SubPlot(3,3,2); gr->Puts(mglPoint(0.5,0.5),"Hist and\nMultiPlot\nsample","a",-3);\r
}\r
//-----------------------------------------------------------------------------\r
const char *mmgl_primitives=""; // TODO add later\r
mglData a(30,40); a.Modify("x*y");\r
gr->SubPlot(2,2,0); gr->Rotate(60,40);\r
gr->Surf(a); gr->Box();\r
- gr->Puts(mglPoint(0.7,1,1.2),"a(x,y)");\r
+ gr->Puts(mglPoint(0.7,1,1.2),"a(x,y)","",-2);\r
gr->SubPlot(2,2,1); gr->Rotate(60,40);\r
a.Diff("x"); gr->Surf(a); gr->Box();\r
- gr->Puts(mglPoint(0.7,1,1.2),"da/dx");\r
+ gr->Puts(mglPoint(0.7,1,1.2),"da/dx","",-2);\r
gr->SubPlot(2,2,2); gr->Rotate(60,40);\r
a.Integral("xy"); gr->Surf(a); gr->Box();\r
- gr->Puts(mglPoint(0.7,1,1.2),"\\int da/dx dxdy");\r
+ gr->Puts(mglPoint(0.7,1,1.2),"\\int da/dx dxdy","",-2);\r
gr->SubPlot(2,2,3); gr->Rotate(60,40);\r
a.Diff2("y"); gr->Surf(a); gr->Box();\r
- gr->Puts(mglPoint(0.7,1,1.2),"\\int {d^2}a/dxdy dx");\r
+ gr->Puts(mglPoint(0.7,1,1.2),"\\int {d^2}a/dxdy dx","",-2);\r
}\r
//-----------------------------------------------------------------------------\r
const char *mmgl_data_extra=""; // TODO add later\r
"triplot t xt yt zt 'b'\ntriplot t xt yt zt '#k'\n";\r
void smgl_triplot(mglGraph *gr)\r
{\r
- float q[] = {0,1,2,3, 4,5,6,7, 0,2,4,6, 1,3,5,7, 0,4,1,5, 2,6,3,7};\r
- float xc[] = {-1,1,-1,1,-1,1,-1,1}, yc[] = {-1,-1,1,1,-1,-1,1,1}, zc[] = {-1,-1,-1,-1,1,1,1,1};\r
+ double q[] = {0,1,2,3, 4,5,6,7, 0,2,4,6, 1,3,5,7, 0,4,1,5, 2,6,3,7};\r
+ double xc[] = {-1,1,-1,1,-1,1,-1,1}, yc[] = {-1,-1,1,1,-1,-1,1,1}, zc[] = {-1,-1,-1,-1,1,1,1,1};\r
mglData qq(6,4,q), xx(8,xc), yy(8,yc), zz(8,zc);\r
gr->Light(true); //gr->Alpha(true);\r
gr->SubPlot(2,1,0); gr->Title("QuadPlot sample"); gr->Rotate(50,60);\r
gr->QuadPlot(qq,xx,yy,zz,"yr");\r
gr->QuadPlot(qq,xx,yy,zz,"k#");\r
\r
- float t[] = {0,1,2, 0,1,3, 0,2,3, 1,2,3};\r
- float xt[] = {-1,1,0,0}, yt[] = {-1,-1,1,0}, zt[] = {-1,-1,-1,1};\r
+ double t[] = {0,1,2, 0,1,3, 0,2,3, 1,2,3};\r
+ double xt[] = {-1,1,0,0}, yt[] = {-1,-1,1,0}, zt[] = {-1,-1,-1,1};\r
mglData tt(4,3,t), uu(4,xt), vv(4,yt), ww(4,zt);\r
gr->SubPlot(2,1,1); gr->Title("TriPlot sample"); gr->Rotate(50,60);\r
gr->TriPlot(tt,uu,vv,ww,"b");\r
mglData x(n),y(n),z(n);\r
for(i=0;i<n;i++)\r
{\r
- float t=M_PI*(mgl_rnd()-0.5), f=2*M_PI*mgl_rnd();\r
+ double t=M_PI*(mgl_rnd()-0.5), f=2*M_PI*mgl_rnd();\r
x.a[i] = 0.9*cos(t)*cos(f);\r
y.a[i] = 0.9*cos(t)*sin(f);\r
z.a[i] = 0.6*sin(t);\r
gr->Rotate(50,60); gr->Box(); gr->Dots(x,y,z);\r
}\r
//-----------------------------------------------------------------------------\r
-\r
-//-----------------------------------------------------------------------------\r
-//-----------------------------------------------------------------------------\r
-//-----------------------------------------------------------------------------\r
-//-----------------------------------------------------------------------------\r
-//-----------------------------------------------------------------------------\r
-//-----------------------------------------------------------------------------\r
-//-----------------------------------------------------------------------------\r
-//-----------------------------------------------------------------------------\r
-// Sample functions\r
-//-----------------------------------------------------------------------------\r
-//-----------------------------------------------------------------------------\r
-//-----------------------------------------------------------------------------\r
/*void smgl_surf3_rgbd(mglGraph *gr)\r
{\r
mglData c; mgls_prepare3d(&c);\r
gr->Box(); gr->Surf3(c,"bgrd");\r
}*/\r
//-----------------------------------------------------------------------------\r
+const char *mmgl_mirror="new a 30 40 '-pi*x*exp(-(y+1)^2-4*x^2)'\nalpha on:light on:rotate 40 60:box\n"\r
+"surf a 'r';yrange 0 1\nsurf a 'b';yrange 0 -1\n";\r
void smgl_mirror(mglGraph *gr) // flag #\r
{\r
- gr->VertexColor(true); gr->TextureColor(false); // Let us use pre-lighting for this example\r
- mglData a(30,40),x(30),y1(40),y2(40);\r
- a.Modify("pi*(1-2*x)*exp(-4*y^2-4*(2*x-1)^2)");\r
- x.Fill(-1,1); y1.Fill(0,1); y2.Fill(0,-1);\r
+ mglData a(30,40);\r
+ gr->Fill(a,"-pi*x*exp(-(y+1)^2-4*x^2)");\r
\r
+ if(!mini) gr->Title("Example of options");\r
gr->Alpha(false); gr->Rotate(40,60);\r
gr->Light(true); gr->Box();\r
- gr->Surf(x,y1,a,"r"); gr->Surf(x,y2,a,"b");\r
- gr->VertexColor(false); gr->TextureColor(true); // set settings back\r
+ gr->Surf(a,"r","yrange 0 1"); gr->Surf(a,"b","yrange 0 -1");\r
}\r
//-----------------------------------------------------------------------------\r
//=============================================================================\r
return strcmp(aa->name, bb->name);\r
}\r
//-----------------------------------------------------------------------------\r
+#if !defined(_MSC_VER) && !defined(__BORLANDC__)\r
static struct option longopts[] =\r
{\r
{ "test", no_argument, &dotest, 1 },\r
void usage()\r
{\r
puts (\r
- "-png - output png\n"\r
- "-width=num - png picture width\n"\r
- "-height=num - png picture height\n"\r
- "-mini - png picture is 200x150\n"\r
- "-big - png picture is 1920x1440\n"\r
- "-idtf - output idtf\n"\r
- "-u3d - output u3d\n"\r
- "-pdf - output pdf\n"\r
- "-eps - output EPS\n"\r
- "-jpeg - output JPEG\n"\r
- "-solid - output solid PNG\n"\r
- "-svg - output SVG\n"\r
- "-obj - output obj/mtl\n"\r
- "-off - output off\n"\r
- "-stl - output stl\n"\r
- "-none - none output\n"\r
- "-srnd - use the same random numbers in any run\n"\r
- "-kind=name - produce only this picture"\r
- "-thread=num - number of threads used"\r
- "-test - perform test\n"\r
+ "--png - output png\n"\r
+ "--width=num - png picture width\n"\r
+ "--height=num - png picture height\n"\r
+ "--mini - png picture is 200x150\n"\r
+ "--big - png picture is 1920x1440\n"\r
+ "--idtf - output idtf\n"\r
+ "--u3d - output u3d\n"\r
+ "--pdf - output pdf\n"\r
+ "--eps - output EPS\n"\r
+ "--jpeg - output JPEG\n"\r
+ "--solid - output solid PNG\n"\r
+ "--svg - output SVG\n"\r
+ "--obj - output obj/mtl\n"\r
+ "--off - output off\n"\r
+ "--stl - output stl\n"\r
+ "--none - none output\n"\r
+ "--srnd - use the same random numbers in any run\n"\r
+ "--list - print list of sample names\n"\r
+ "--kind=name - produce only this sample\n"\r
+ "--thread=num - number of threads used\n"\r
+ "--test - perform test\n"\r
);\r
-};\r
+}\r
+#endif\r
//-----------------------------------------------------------------------------\r
void save(mglGraph *gr,const char *name,const char *suf="")\r
{\r
// mglGraphIDTF u3d;\r
mglGraph *gr = NULL;\r
mglSample *s=samp;\r
+#if !defined(_MSC_VER) && !defined(__BORLANDC__)\r
while(( ch = getopt_long_only(argc, argv, "", longopts, NULL)) != -1)\r
switch(ch)\r
{\r
case 0: break;\r
case 'w': width =atoi(optarg); break;\r
case 'h': height=atoi(optarg); break;\r
- case 'k': strcpy(name, optarg); tmp=strchr(name,'.');\r
- if(tmp) *tmp=0; break;\r
+ case 'k': strcpy(name, optarg);\r
+ tmp=strchr(name,'.'); if(tmp) *tmp=0;\r
+ tmp=strchr(name,'-'); if(tmp) *tmp=0;\r
+ break;\r
case 't': mglNumThr=atoi(optarg); break;\r
case 'l':\r
while(s->name[0]) { printf("%s ",s->name); s++; }\r
case '?':\r
default: usage(); return 0;\r
}\r
+#endif\r
\r
- gr = new mglGraph;\r
-// if(type==5 || type==9 || type==10) { u3d.unrotate_flag = true; gr = &u3d; }\r
+ gr = new mglGraph; //gr->SetQuality(0);\r
\r
- if(mini) { gr->SetSize(190,145); suf = "_sm"; }\r
+ if(mini) { gr->SetSize(190,145); suf = "-sm"; }\r
else if(big)\r
- { gr->SetSize(1920,1440); suf = "_lg"; }\r
+ { gr->SetSize(1920,1440); suf = "-lg"; }\r
else gr->SetSize(width,height);\r
\r
if(dotest)\r
{"barh", smgl_barh},\r
{"bars", smgl_bars},\r
{"belt", smgl_belt},\r
- {"boxplot", smgl_boxplot},\r
{"box", smgl_box},\r
+ {"boxplot", smgl_boxplot},\r
{"boxs", smgl_boxs},\r
{"candle", smgl_candle},\r
{"chart", smgl_chart},\r
{"tiles", smgl_tiles},\r
{"torus", smgl_torus},\r
{"traj", smgl_traj},\r
+ {"triangulation",smgl_triangulation},\r
{"triplot", smgl_triplot},\r
{"tube", smgl_tube},\r
{"type0", smgl_type0},\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdio.h>\r
#include "mgl2/glut.h"\r
//-----------------------------------------------------------------------------\r
int test_wnd(mglGraph *gr);\r
int sample_3(mglGraph *gr);\r
int sample_d(mglGraph *gr);\r
//-----------------------------------------------------------------------------\r
+typedef int (*draw_func)(mglGraph *gr);\r
int main(int argc,char **argv)\r
{\r
char key = 0;\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdio.h>\r
#include "mgl2/window.h"\r
+#if defined(WIN32) || defined(_MSC_VER) || defined(__BORLANDC__)\r
+#include <windows.h>\r
+#endif\r
//-----------------------------------------------------------------------------\r
int test_wnd(mglGraph *gr);\r
int sample(mglGraph *gr);\r
int sample_3(mglGraph *gr);\r
int sample_d(mglGraph *gr);\r
//-----------------------------------------------------------------------------\r
+//#define PTHREAD_SAMPLE\r
+#ifdef PTHREAD_SAMPLE\r
#include <pthread.h>\r
-#include <unistd.h>\r
+#endif\r
mglPoint pnt; // some global variable for changable data\r
void *mgl_qt_tmp(void *);\r
//-----------------------------------------------------------------------------\r
{\r
for(int i=0;i<30;i++) // do calculation\r
{\r
-#ifdef WIN32\r
+#if defined(WIN32) || defined(_MSC_VER) || defined(__BORLANDC__)\r
Sleep(1000);\r
#else\r
sleep(1); // which can be very long\r
return 0;\r
}\r
//-----------------------------------------------------\r
-//#define PTHREAD_SAMPLE\r
int main(int argc,char **argv)\r
{\r
#ifdef PTHREAD_SAMPLE\r
#else\r
mglWindow *gr;\r
char key = 0;\r
- if(argc>1 && argv[1][0]!='-') key = argv[1][0];\r
+ if(argc>1) key = argv[1][0]!='-' ? argv[1][0]:argv[1][1];\r
else printf("You may specify argument '1', '2', '3' or 'd' for viewing examples of 1d, 2d, 3d or dual plotting\n");\r
switch(key)\r
{\r
case '1': gr = new mglWindow(sample_1,"1D plots",1); break;\r
case '2': gr = new mglWindow(sample_2,"2D plots",1); break;\r
case '3': gr = new mglWindow(sample_3,"3D plots",1); break;\r
- case 'd': gr = new mglWindow(sample_d,"Dual plots",1);break;\r
+ case 'd': gr = new mglWindow(sample_d,"Dual plots",1); break;\r
case 't': gr = new mglWindow(test_wnd,"Testing",1); break;\r
default: gr = new mglWindow(sample,"Drop and waves",1); break;\r
}\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdio.h>\r
-#include <string.h>\r
-#include <stdlib.h>\r
-#include <math.h>\r
//-----------------------------------------------------------------------------\r
#include "mgl2/mgl.h"\r
#include "mgl2/parser.h"\r
int test_wnd(mglGraph *gr)\r
{\r
mgl_set_test_mode(true);\r
+ gr->SetQuality(6);\r
gr->Box();\r
return 0;\r
}\r
if(y) y->Create(n,3);\r
if(x1) x1->Create(n); if(x2) x2->Create(n);\r
if(y1) y1->Create(n); if(y2) y2->Create(n);\r
- float xx;\r
+ double xx;\r
for(i=0;i<n;i++)\r
{\r
xx = i/(n-1.);\r
register long i,j,n=50,m=40,i0;\r
if(a) a->Create(n,m); if(b) b->Create(n,m);\r
if(v) { v->Create(9); v->Fill(-1,1); }\r
- float x,y;\r
+ double x,y;\r
for(i=0;i<n;i++) for(j=0;j<m;j++)\r
{\r
x = i/(n-1.); y = j/(m-1.); i0 = i+n*j;\r
{\r
register long i,j,k,n=61,m=50,l=40,i0;\r
if(a) a->Create(n,m,l); if(b) b->Create(n,m,l);\r
- float x,y,z;\r
+ double x,y,z;\r
for(i=0;i<n;i++) for(j=0;j<m;j++) for(k=0;k<l;k++)\r
{\r
x=2*i/(n-1.)-1; y=2*j/(m-1.)-1; z=2*k/(l-1.)-1; i0 = i+n*(j+m*k);\r
{\r
register long i,j,n=20,m=30,i0;\r
if(a) a->Create(n,m); if(b) b->Create(n,m);\r
- float x,y;\r
+ double x,y;\r
for(i=0;i<n;i++) for(j=0;j<m;j++)\r
{\r
x=i/(n-1.); y=j/(m-1.); i0 = i+n*j;\r
register long i,j,k,n=10,i0;\r
if(!ex || !ey || !ez) return;\r
ex->Create(n,n,n); ey->Create(n,n,n); ez->Create(n,n,n);\r
- float x,y,z, r1,r2;\r
+ double x,y,z, r1,r2;\r
for(i=0;i<n;i++) for(j=0;j<n;j++) for(k=0;k<n;k++)\r
{\r
x=2*i/(n-1.)-1; y=2*j/(n-1.)-1; z=2*k/(n-1.)-1; i0 = i+n*(j+k*n);\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdio.h>\r
#include "mgl2/wx.h"\r
//-----------------------------------------------------------------------------\r
#ifdef ENABLE_MGLGRAPHWX\r
int sample_3(mglGraph *gr, void *);\r
int sample_d(mglGraph *gr, void *);\r
//-----------------------------------------------------------------------------\r
+//#define PTHREAD_SAMPLE\r
+#ifdef PTHREAD_SAMPLE\r
#include <pthread.h>\r
-#include <unistd.h>\r
+#endif\r
mglPoint pnt; // some global variable for changable data\r
void *mgl_wx_tmp(void *) { mglWxRun(); return 0; }\r
//-----------------------------------------------------------------------------\r
/* This define enables double precision in MathGL */
#define MGL_USE_DOUBLE ${MGL_USE_DOUBLE}
+#define MGL_NO_DATA_A ${MGL_NO_DATA_A}
#define MGL_HAVE_GSL ${MGL_HAVE_GSL}
#define MGL_HAVE_LTDL ${MGL_HAVE_LTDL}
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define MGL_HAVE_PTHREAD 0
+#else
#define MGL_HAVE_PTHREAD ${MGL_HAVE_PTHREAD}
+#endif
#define MGL_HAVE_HDF4 ${MGL_HAVE_HDF4}
#define MGL_HAVE_HDF5 ${MGL_HAVE_HDF5}
#define MGL_HAVE_HDF5_18 ${MGL_HAVE_HDF5_18}
#define MGL_HAVE_JPEG ${MGL_HAVE_JPEG}
+#define MGL_HAVE_PNG ${MGL_HAVE_PNG}
+#define MGL_HAVE_ZLIB ${MGL_HAVE_ZLIB}
#define MGL_HAVE_U3D ${MGL_HAVE_U3D}
#define MGL_HAVE_PDF ${MGL_HAVE_PDF}
#define MGL_HAVE_GIF ${MGL_HAVE_GIF}
#define MGL_HAVE_PYTHON ${MGL_HAVE_PYTHON}
#define MGL_HAVE_OCTAVE ${MGL_HAVE_OCTAVE}
#define MGL_HAVE_DOC ${MGL_HAVE_DOC}
+#define MGL_HAVE_MPI ${MGL_HAVE_MPI}
#endif
#ifndef _MGL_ADDON_H_
#define _MGL_ADDON_H_
/***************************************************************************/
-#include <stdio.h>
#ifdef __cplusplus
/***************************************************************************/
#include <complex>
/** Get uncommented string from file (NOTE: it is not thread safe!!!) */
char *mgl_fgetstr(FILE *fp);
/** Check if symbol denote true */
-bool mgl_istrue(char ch);
+int mgl_istrue(char ch);
/** Print test message */
void mgl_test(const char *str, ...);
/** Print info message */
***************************************************************************/\r
#ifndef _MGL_BASE_H_\r
#define _MGL_BASE_H_\r
-#include <string.h>\r
-#include <stdlib.h>\r
-#include <stdio.h>\r
-#include <math.h>\r
-#ifndef _MSC_VER\r
+#if !defined(_MSC_VER) && !defined(__BORLANDC__)\r
#include <stdint.h>\r
#endif\r
#include "mgl2/define.h"\r
#include "mgl2/eval.h"\r
#include "mgl2/font.h"\r
//-----------------------------------------------------------------------------\r
+class mglBase;\r
+class mglData;\r
+class mglParser;\r
+class mglFormula;\r
+typedef mglBase* HMGL;\r
+typedef mglData* HMDT;\r
+typedef mglParser* HMPR;\r
+typedef mglFormula* HMEX;\r
+//-----------------------------------------------------------------------------\r
+#if MGL_NO_DATA_A\r
+#define mglDataA mglData\r
+typedef const mglData* HCDT;\r
+#include "mgl2/data.h"\r
+#else\r
/// Abstract class for data array\r
class mglDataA\r
{\r
public:\r
+ virtual ~mglDataA() {};\r
virtual mreal v(long i,long j=0,long k=0) const = 0;\r
virtual mreal vthr(long i) const = 0;\r
virtual long GetNx() const = 0;\r
virtual long GetNy() const = 0;\r
virtual long GetNz() const = 0;\r
inline long GetNN() const { return GetNx()*GetNy()*GetNz(); }\r
- virtual float Maximal() const = 0;\r
- virtual float Minimal() const = 0;\r
+ virtual mreal Maximal() const = 0;\r
+ virtual mreal Minimal() const = 0;\r
virtual mreal dvx(long i,long j=0,long k=0) const = 0;\r
// { return i>0 ? (i<GetNx()-1 ? (v(i+1,j,k)-v(i-1,j,k))/2 : v(i,j,k)-v(i-1,j,k)) : v(1,j,k)-v(0,j,k); }\r
virtual mreal dvy(long i,long j=0,long k=0) const = 0;\r
virtual mreal dvz(long i,long j=0,long k=0) const = 0;\r
// { return k>0 ? (k<GetNz()-1 ? (v(i,j,k+1)-v(i,j,k-1))/2 : v(i,j,k)-v(i,j,k-1)) : v(i,j,1)-v(i,j,0); }\r
};\r
+#endif\r
+typedef const mglDataA* HCDT;\r
//-----------------------------------------------------------------------------\r
-inline float mgl_d(float v,float v1,float v2) { return v2!=v1?(v-v1)/(v2-v1):NAN; }\r
+inline mreal mgl_d(mreal v,mreal v1,mreal v2) { return v2!=v1?(v-v1)/(v2-v1):NAN; }\r
//-----------------------------------------------------------------------------\r
-mglPoint GetX(const mglDataA *x, int i, int j, int k=0);\r
-mglPoint GetY(const mglDataA *y, int i, int j, int k=0);\r
-mglPoint GetZ(const mglDataA *z, int i, int j, int k=0);\r
-inline mglPoint GetX(const mglDataA &x, int i, int j, int k=0)\r
-{ return GetX(&x,i,j,k); }\r
-inline mglPoint GetY(const mglDataA &y, int i, int j, int k=0)\r
-{ return GetY(&y,i,j,k); }\r
-inline mglPoint GetZ(const mglDataA &z, int i, int j, int k=0)\r
-{ return GetZ(&z,i,j,k); }\r
+mglPoint GetX(HCDT x, int i, int j, int k=0);\r
+mglPoint GetY(HCDT y, int i, int j, int k=0);\r
+mglPoint GetZ(HCDT z, int i, int j, int k=0);\r
//-----------------------------------------------------------------------------\r
/// Structure for simplest primitives\r
-struct mglPrim\r
+struct mglPrim // NOTE: use float for reducing memory size\r
{\r
// NOTE: n4 is used as mark; n3 -- as pen style for type=0,1,4\r
// NOTE: n3 is used as position of txt,font in Ptxt for type=6\r
long n1,n2,n3,n4; ///< coordinates of corners\r
int type; ///< primitive type (0-point, 1-line, 2-trig, 3-quad, 4-glyph, 6-text)\r
int id; ///< object id\r
- float z; ///< z-position\r
- float s; ///< size (if applicable) or fscl\r
- float w; ///< width (if applicable) or ftet\r
+ float z; ///< z-position\r
+ float s; ///< size (if applicable) or fscl\r
+ float w; ///< width (if applicable) or ftet\r
float p;\r
\r
mglPrim(int t=0) { n1=n2=n3=n4=id=0; z=s=w=p=0; type = t; }\r
{\r
std::wstring text;\r
std::string stl;\r
- float val;\r
- mglText(const wchar_t *txt=0, const char *fnt=0, float v=0) { text=txt; stl=fnt; val=v; }\r
- mglText(const std::wstring &txt, float v=0) { text=txt; val=v; }\r
+ mreal val;\r
+ mglText(const wchar_t *txt=0, const char *fnt=0, mreal v=0) { text=txt; stl=fnt; val=v; }\r
+ mglText(const std::wstring &txt, mreal v=0) { text=txt; val=v; }\r
};\r
//-----------------------------------------------------------------------------\r
/// Structure for internal point represenatation\r
-struct mglPnt\r
+struct mglPnt // NOTE: use float for reducing memory size\r
{\r
float xx,yy,zz; // original coordinates\r
- float x,y,z; // coordinates\r
+ float x,y,z; // coordinates\r
float c,t,ta; // index in color scheme\r
- float u,v,w; // normales\r
+ float u,v,w; // normales\r
float r,g,b,a; // RGBA color\r
mglPnt() { xx=yy=zz=x=y=z=c=t=ta=u=v=w=r=g=b=a=0; }\r
};\r
\r
char Sch[260]; ///< Color scheme used\r
int Smooth; ///< Type of texture (smoothing and so on)\r
- float Alpha; ///< Transparency\r
+ mreal Alpha; ///< Transparency\r
\r
- mglTexture() { n=0; }\r
- mglTexture(const char *cols, int smooth=0,float alpha=1)\r
+ mglTexture() { n=Smooth=0; Alpha=1; }\r
+ mglTexture(const char *cols, int smooth=0,mreal alpha=1)\r
{ n=0; Set(cols,smooth,alpha); }\r
void Clear() { n=0; }\r
- void Set(const char *cols, int smooth=0,float alpha=1);\r
- void GetC(float u,float v,mglPnt &p) const;\r
+ void Set(const char *cols, int smooth=0,mreal alpha=1);\r
+ void GetC(mreal u,mreal v,mglPnt &p) const;\r
inline bool IsSame(const mglTexture &t) const\r
{ return n==t.n && !memcmp(col,t.col,512*sizeof(mglColor)); }\r
void GetRGBA(unsigned char *f) const; // Write as BGRA for fastest export to TGA\r
bool Stop; ///< Flag that execution should be terminated.\r
mglPoint Min; ///< Lower edge of bounding box for graphics.\r
mglPoint Max; ///< Upper edge of bounding box for graphics.\r
+ mreal ZMin; ///< Adjusted minimal z-value 1D plots\r
std::string Mess; ///< Buffer for receiving messages\r
int ObjId; ///< object id for mglPrim\r
int HighId; ///< object id to be highlited\r
std::vector<mglGroup> Grp; ///< List of groups with names -- need for export\r
std::string PlotId; ///< Id of plot for saving filename (in GLUT window for example)\r
\r
- float CDef; ///< Default (current) color in texture\r
- float AlphaDef; ///< Default value of alpha channel (transparency)\r
- float BarWidth; ///< Relative width of rectangles in Bars().\r
+ mreal CDef; ///< Default (current) color in texture\r
+ mreal AlphaDef; ///< Default value of alpha channel (transparency)\r
+ mreal BarWidth; ///< Relative width of rectangles in Bars().\r
int MeshNum; ///< Set approximate number of lines in Mesh and Grid. By default (=0) it draw all lines.\r
char Arrow1, Arrow2;///< Style of arrows at end and at start of curve\r
long InUse; ///< Smart pointer (number of users)\r
inline void set(bool v,long fl) { Flag = v ? Flag|fl : Flag&(~fl); }\r
\r
/// Set values of mglGraph::Min and mglGraph::Max\r
- inline void SetRanges(float x1, float x2, float y1, float y2, float z1=0, float z2=0, float c1=0, float c2=0)\r
+ inline void SetRanges(mreal x1, mreal x2, mreal y1, mreal y2, mreal z1=0, mreal z2=0, mreal c1=0, mreal c2=0)\r
{ SetRanges(mglPoint(x1,y1,z1,c1),mglPoint(x2,y2,z2,c2)); }\r
void SetRanges(mglPoint v1, mglPoint v2);\r
/// Set values of mglGraph::Cmin and mglGraph::Cmax as minimal and maximal values of data a\r
- void CRange(const mglDataA &a, bool add = false, float fact=0);\r
- inline void CRange(float v1,float v2) { if(v1!=v2) {Min.c=v1; Max.c=v2; RecalcCRange();} }\r
+ void CRange(HCDT a, bool add = false, mreal fact=0);\r
+ inline void CRange(mreal v1,mreal v2) { if(v1!=v2) {Min.c=v1; Max.c=v2; RecalcCRange();} }\r
/// Set values of mglGraph::Min.x and mglGraph::Max.x as minimal and maximal values of data a\r
- void XRange(const mglDataA &a, bool add = false, float fact=0);\r
- inline void XRange(float v1,float v2) { if(v1!=v2) {Min.x=v1; Max.x=v2; RecalcBorder();} }\r
+ void XRange(HCDT a, bool add = false, mreal fact=0);\r
+ inline void XRange(mreal v1,mreal v2) { if(v1!=v2) {Min.x=v1; Max.x=v2; RecalcBorder();} }\r
/// Set values of mglGraph::Min.x and mglGraph::Max.x as minimal and maximal values of data a\r
- void YRange(const mglDataA &a, bool add = false, float fact=0);\r
- inline void YRange(float v1,float v2) { if(v1!=v2) {Min.y=v1; Max.y=v2; RecalcBorder();} }\r
+ void YRange(HCDT a, bool add = false, mreal fact=0);\r
+ inline void YRange(mreal v1,mreal v2) { if(v1!=v2) {Min.y=v1; Max.y=v2; RecalcBorder();} }\r
/// Set values of mglGraph::Min.x and mglGraph::Max.x as minimal and maximal values of data a\r
- void ZRange(const mglDataA &a, bool add = false, float fact=0);\r
- inline void ZRange(float v1,float v2) { if(v1!=v2) {Min.z=v1; Max.z=v2; RecalcBorder();} }\r
+ void ZRange(HCDT a, bool add = false, mreal fact=0);\r
+ inline void ZRange(mreal v1,mreal v2) { if(v1!=v2) {Min.z=v1; Max.z=v2; RecalcBorder();} }\r
/// Set ranges for automatic variables\r
- void SetAutoRanges(float x1, float x2, float y1=0, float y2=0, float z1=0, float z2=0, float c1=0, float c2=0);\r
+ void SetAutoRanges(mreal x1, mreal x2, mreal y1=0, mreal y2=0, mreal z1=0, mreal z2=0, mreal c1=0, mreal c2=0);\r
/// Set axis origin\r
- inline void SetOrigin(float x0, float y0, float z0=NAN, float c0=NAN)\r
+ inline void SetOrigin(mreal x0, mreal y0, mreal z0=NAN, mreal c0=NAN)\r
{ Org=mglPoint(x0,y0,z0,c0); }\r
/// Save ranges into internal variable and put parsed\r
- float SaveState(const char *opt);\r
+ mreal SaveState(const char *opt);\r
/// Load ranges from internal variable\r
void LoadState();\r
+ /// Increase ZMin\r
+ mreal AdjustZMin() { ZMin /= MGL_EPSILON; return Max.z - ZMin*(Max.z-Min.z); }\r
\r
/// Safetly set the transformation formulas for coordinate.\r
void SetFunc(const char *EqX, const char *EqY, const char *EqZ=0, const char *EqA=0);\r
/// Set cutting for points outside of bounding box\r
inline void SetCut(bool val) { set(val, MGL_ENABLE_CUT); }\r
/// Set additional cutting box\r
- inline void SetCutBox(float x1, float y1, float z1, float x2, float y2, float z2)\r
+ inline void SetCutBox(mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2)\r
{ CutMin=mglPoint(x1,y1,z1); CutMax=mglPoint(x2,y2,z2); }\r
inline void SetCutBox(mglPoint v1, mglPoint v2) { CutMin=v1; CutMax=v2; }\r
\r
virtual bool Light(bool enable)\r
{ bool t=get(MGL_ENABLE_LIGHT); set(enable,MGL_ENABLE_LIGHT); return t; }\r
/// Set ambient light brightness\r
- virtual void SetAmbient(float bright=0.5);\r
+ virtual void SetAmbient(mreal bright=0.5);\r
/// Use diffusive light (only for local light sources)\r
inline void SetDifLight(bool dif) { set(dif,MGL_DIFFUSIVE); }\r
/// Set the transparency on/off.\r
virtual bool Alpha(bool enable)\r
{ bool t=get(MGL_ENABLE_ALPHA); set(enable,MGL_ENABLE_ALPHA); return t; }\r
/// Set default value of alpha-channel\r
- inline void SetAlphaDef(float val) { AlphaDef=val; };\r
+ inline void SetAlphaDef(mreal val) { AlphaDef=val; };\r
/// Set default palette\r
inline void SetPalette(const char *colors)\r
{ Txt[0].Set(mgl_have_color(colors)?colors:MGL_DEF_PAL,-1); }\r
/// Set number of mesh lines\r
inline void SetMeshNum(int val) { MeshNum=val; };\r
/// Set relative width of rectangles in Bars, Barh, BoxPlot\r
- inline void SetBarWidth(float val) { BarWidth=val; };\r
+ inline void SetBarWidth(mreal val) { BarWidth=val; };\r
/// Set size of marks\r
- inline void SetMarkSize(float val) { MarkSize=0.02*val; }\r
+ inline void SetMarkSize(mreal val) { MarkSize=0.02*val; }\r
/// Set size of arrows\r
- inline void SetArrowSize(float val) { ArrowSize=0.03*val; }\r
+ inline void SetArrowSize(mreal val) { ArrowSize=0.03*val; }\r
\r
/// Set warning code ant fill Message\r
- void SetWarn(int code, const char *who="");\r
+ void SetWarn(int code, const char *who);\r
int inline GetWarn() const { return WarnCode; }\r
\r
virtual void StartAutoGroup (const char *)=0;\r
inline void Highlight(int id) { HighId=id; }\r
\r
/// Set FontSize by size in pt and picture DPI (default is 16 pt for dpi=72)\r
- virtual void SetFontSizePT(float pt, int dpi=72){ FontSize = pt*27.f/dpi; }\r
+ virtual void SetFontSizePT(mreal pt, int dpi=72){ FontSize = pt*27.f/dpi; }\r
/// Set FontSize by size in centimeters and picture DPI (default is 0.56 cm = 16 pt)\r
- inline void SetFontSizeCM(float cm, int dpi=72) { SetFontSizePT(cm*28.45f,dpi); };\r
+ inline void SetFontSizeCM(mreal cm, int dpi=72) { SetFontSizePT(cm*28.45f,dpi); };\r
/// Set FontSize by size in inch and picture DPI (default is 0.22 in = 16 pt)\r
- inline void SetFontSizeIN(float in, int dpi=72) { SetFontSizePT(in*72.27f,dpi); };\r
+ inline void SetFontSizeIN(mreal in, int dpi=72) { SetFontSizePT(in*72.27f,dpi); };\r
/// Set font typeface. Note that each mglFont instance can be used with ONLY ONE mglGraph instance at a moment of time!\r
void SetFont(mglFont *f);\r
/// Get current typeface. Note that this variable can be deleted at next SetFont() call!\r
/// Copy font from another mglGraph instance\r
inline void CopyFont(mglBase *gr) { fnt->Copy(gr->GetFont()); }\r
/// Set default font size\r
- inline void SetFontSize(float val) { FontSize=val>0 ? val:FontSize*val; }\r
- inline float GetFontSize() const { return FontSize; };\r
- inline float TextWidth(const wchar_t *text, const char *font, float size) const\r
+ inline void SetFontSize(mreal val) { FontSize=val>0 ? val:FontSize*val; }\r
+ inline mreal GetFontSize() const { return FontSize; };\r
+ inline mreal TextWidth(const wchar_t *text, const char *font, mreal size) const\r
{ return (size<0?-size*FontSize:size)*font_factor*fnt->Width(text,(font&&*font)?font:FontDef)/8; }\r
- inline float TextHeight(const char *font, float size) const\r
+ inline mreal TextHeight(const char *font, mreal size) const\r
{ return (size<0?-size*FontSize:size)*font_factor*fnt->Height(font?font:FontDef)/8; }\r
- inline float FontFactor() const { return font_factor; }\r
- virtual float GetRatio() const;\r
+ inline mreal FontFactor() const { return font_factor; }\r
+ virtual mreal GetRatio() const;\r
/// Set to use or not text rotation\r
inline void SetRotatedText(bool val) { set(val,MGL_ENABLE_RTEXT); }\r
/// Set default font style and color\r
\r
// ~~~~~~~~~~~~~~~~~~~~~~ Developer functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
/// Add point to the pntN and return its position\r
- long AddPnt(mglPoint p, float c=-1, mglPoint n=mglPoint(NAN), float a=-1, int scl=1);\r
- long CopyNtoC(long k, float c);\r
+ long AddPnt(mglPoint p, mreal c=-1, mglPoint n=mglPoint(NAN), mreal a=-1, int scl=1);\r
+ long CopyNtoC(long k, mreal c);\r
long CopyProj(long from, mglPoint p, mglPoint n);\r
virtual void Reserve(long n); ///< Allocate n-cells for pntC and return current position\r
/// Set to reduce accuracy of points (to reduc size of output files)\r
/// Scale coordinates and cut off some points\r
virtual bool ScalePoint(mglPoint &p, mglPoint &n, bool use_nan=true) const;\r
\r
- virtual float GetOrgX(char dir) const=0; ///< Get Org.x (parse NAN value)\r
- virtual float GetOrgY(char dir) const=0; ///< Get Org.y (parse NAN value)\r
- virtual float GetOrgZ(char dir) const=0; ///< Get Org.z (parse NAN value)\r
+ virtual mreal GetOrgX(char dir) const=0; ///< Get Org.x (parse NAN value)\r
+ virtual mreal GetOrgY(char dir) const=0; ///< Get Org.y (parse NAN value)\r
+ virtual mreal GetOrgZ(char dir) const=0; ///< Get Org.z (parse NAN value)\r
\r
/// Get color depending on single variable z, which should be scaled if scale=true\r
- inline float GetC(long s,float z,bool scale = true) const\r
- { return s+(scale?GetA(z):(z>0?z/MGL_FLT_EPS:0)); }\r
+ inline mreal GetC(long s,mreal z,bool scale = true) const\r
+ { return s+(scale?GetA(z):(z>0?z/MGL_EPSILON:0)); }\r
/// Get alpha value depending on single variable \a a\r
- float GetA(float a) const;\r
+ mreal GetA(mreal a) const;\r
/// Set pen/palette\r
char SetPenPal(const char *stl, long *id=0);\r
/// Add texture (like color scheme) and return the position of first color\r
long AddTexture(const char *cols, int smooth=0);\r
-// inline float AddTexture(char col) { return AddTexture(mglColor(col)); };\r
- float AddTexture(mglColor col);\r
+// inline mreal AddTexture(char col) { return AddTexture(mglColor(col)); };\r
+ mreal AddTexture(mglColor col);\r
inline void DefColor(mglColor col) { CDef = AddTexture(col); }\r
/// Set next color from palette\r
- float NextColor(long &id);\r
+ mreal NextColor(long &id);\r
\r
- virtual void mark_plot(long p, char type, float size=1)=0;\r
+ virtual void mark_plot(long p, char type, mreal size=1)=0;\r
virtual void arrow_plot(long p1, long p2, char st)=0;\r
virtual void line_plot(long p1, long p2)=0;\r
virtual void trig_plot(long p1, long p2, long p3)=0;\r
virtual void quad_plot(long p1, long p2, long p3, long p4)=0;\r
- virtual void Glyph(float x, float y, float f, int style, long icode, float col)=0;\r
- virtual float text_plot(long p,const wchar_t *text,const char *fnt,float size=-1,float sh=0,float col=-('k'),bool rot=true)=0;\r
- void vect_plot(long p1, long p2, float s=1);\r
- inline float mark_size() { return MarkSize*font_factor; }\r
+ virtual void Glyph(mreal x, mreal y, mreal f, int style, long icode, mreal col)=0;\r
+ virtual mreal text_plot(long p,const wchar_t *text,const char *fnt,mreal size=-1,mreal sh=0,mreal col=-('k'),bool rot=true)=0;\r
+ void vect_plot(long p1, long p2, mreal s=1);\r
+ inline mreal mark_size() { return MarkSize*font_factor; }\r
// inline char last_color() { return last_style[1]; }\r
inline const char *last_line() { return last_style; }\r
\r
\r
int TernAxis; ///< Flag that Ternary axis is used\r
unsigned PDef; ///< Pen bit mask\r
- float pPos; ///< Current position in pen mask\r
- float PenWidth; ///< Pen width for further line plotting (must be >0 !!!)\r
+ mreal pPos; ///< Current position in pen mask\r
+ mreal PenWidth; ///< Pen width for further line plotting (must be >0 !!!)\r
// long numT; ///< Number of textures\r
- float AmbBr; ///< Default ambient light brightness\r
+ mreal AmbBr; ///< Default ambient light brightness\r
\r
mglFont *fnt; ///< Class for printing vector text\r
- float FontSize; ///< The size of font for tick and axis labels\r
+ mreal FontSize; ///< The size of font for tick and axis labels\r
char FontDef[32]; ///< Font specification (see mglGraph::Puts). Default is Roman with align at center.\r
int Quality; ///< Quality of plot (0x0-pure, 0x1-fast; 0x2-fine; 0x4 - low memory)\r
\r
mglFormula *fc; ///< Cutting off condition (formula).\r
\r
long CurrPal; ///< Current palette index\r
- float MarkSize; ///< The size of marks for 1D plots.\r
- float ArrowSize; ///< The size of arrows.\r
+ mreal MarkSize; ///< The size of marks for 1D plots.\r
+ mreal ArrowSize; ///< The size of arrows.\r
char last_style[64];///< Last pen style\r
- float font_factor; ///< Font scaling factor\r
+ mreal font_factor; ///< Font scaling factor\r
\r
virtual void LightScale()=0; ///< Scale positions of light sources\r
\r
private:\r
mglPoint MinS; ///< Saved lower edge of bounding box for graphics.\r
mglPoint MaxS; ///< Saved upper edge of bounding box for graphics.\r
- float MSS, ASS, FSS, ADS, MNS, LSS; ///< Saved state\r
+ mreal MSS, ASS, FSS, ADS, MNS, LSS; ///< Saved state\r
long CSS; ///< Saved flags\r
bool saved; ///< State is saved\r
std::string leg_str;///< text to be save in legend\r
\r
void RecalcCRange(); ///< Recalculate internal parameter for correct coloring.\r
void RecalcBorder(); ///< Recalculate internal parameter for correct transformation rules.\r
- void SetFBord(float x,float y,float z); ///< Set internal boundng box depending on transformation formula\r
+ void SetFBord(mreal x,mreal y,mreal z); ///< Set internal boundng box depending on transformation formula\r
void ClearEq(); ///< Clear the used variables for axis transformation\r
};\r
//-----------------------------------------------------------------------------\r
+bool mgl_check_dim1(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT r, const char *name, bool less=false);\r
+bool mgl_check_dim2(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *name, bool less=false);\r
+bool mgl_check_dim3(HMGL gr, bool both, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *name);\r
+bool mgl_check_vec3(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *name);\r
+bool mgl_check_trig(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, HCDT a, const char *name, int d=3);\r
+bool mgl_isboth(HCDT x, HCDT y, HCDT z, HCDT a);\r
+//-----------------------------------------------------------------------------\r
#define _Da_(d) (*((const mglDataA *)(d)))\r
#define _DA_(a) ((const mglDataA *)*(a))\r
#define _GR_ ((mglBase *)(*gr))\r
#define _DM_(a) ((mglData *)*(a))\r
#define _DT_ ((mglData *)*d)\r
//-----------------------------------------------------------------------------\r
-class mglData;\r
-class mglParser;\r
-class mglFormula;\r
-typedef mglBase* HMGL;\r
-typedef mglData* HMDT;\r
-typedef mglParser* HMPR;\r
-typedef mglFormula* HMEX;\r
-typedef const mglDataA* HCDT;\r
#else\r
typedef void *HMGL;\r
typedef void *HMDT;\r
int mgl_get_warn(HMGL gr);\r
void mgl_set_warn(HMGL gr, int code, const char *text);\r
const char *mgl_get_mess(HMGL gr);\r
+int mgl_get_flag(HMGL gr, long flag);\r
+void mgl_set_flag(HMGL gr, int val, long flag);\r
+\r
long mgl_use_graph(HMGL gr, int inc);\r
void mgl_start_group(HMGL gr, const char *);\r
void mgl_end_group(HMGL gr);\r
void mgl_highlight(HMGL gr, int id);\r
\r
void mgl_set_palette(HMGL gr, const char *colors);\r
-void mgl_set_alpha_default(HMGL graph, float alpha);\r
-void mgl_set_bar_width(HMGL graph, float width);\r
+void mgl_set_alpha_default(HMGL graph, mreal alpha);\r
+void mgl_set_bar_width(HMGL graph, mreal width);\r
void mgl_set_meshnum(HMGL graph, int num);\r
-void mgl_set_ambbr(HMGL gr, float i);\r
+void mgl_set_ambbr(HMGL gr, mreal i);\r
void mgl_set_light_dif(HMGL gr, int enable);\r
\r
void mgl_set_rdc_acc(HMGL graph, int reduce);\r
void mgl_set_cut(HMGL graph, int cut);\r
-void mgl_set_cut_box(HMGL gr, float x1,float y1,float z1,float x2,float y2,float z2);\r
-void mgl_set_ranges(HMGL graph, float x1, float x2, float y1, float y2, float z1, float z2);\r
-void mgl_set_range_val(HMGL gr, char dir, float v1,float v2);\r
+void mgl_set_cut_box(HMGL gr, mreal x1,mreal y1,mreal z1,mreal x2,mreal y2,mreal z2);\r
+void mgl_set_ranges(HMGL graph, mreal x1, mreal x2, mreal y1, mreal y2, mreal z1, mreal z2);\r
+void mgl_set_range_val(HMGL gr, char dir, mreal v1,mreal v2);\r
void mgl_set_range_dat(HMGL gr, char dir, HCDT a, int add);\r
\r
-void mgl_set_origin(HMGL graph, float x0, float y0, float z0);\r
+void mgl_set_origin(HMGL graph, mreal x0, mreal y0, mreal z0);\r
void mgl_set_func(HMGL graph, const char *EqX,const char *EqY,const char *EqZ,const char *EqA);\r
void mgl_set_coor(HMGL gr, int how);\r
void mgl_set_ternary(HMGL gr, int enable);\r
void mgl_set_tick_rotate(HMGL graph, int enable);\r
void mgl_set_tick_skip(HMGL graph, int enable);\r
\r
-float mgl_data_get_value(HCDT d, long i, long j, long k);\r
+mreal mgl_data_get_value(HCDT d, long i, long j, long k);\r
long mgl_data_get_nx(HCDT d);\r
long mgl_data_get_ny(HCDT d);\r
long mgl_data_get_nz(HCDT d);\r
\r
-void mgl_set_mark_size(HMGL graph, float size);\r
-void mgl_set_arrow_size(HMGL graph, float size);\r
-void mgl_set_font_size(HMGL graph, float size);\r
+void mgl_set_mark_size(HMGL graph, mreal size);\r
+void mgl_set_arrow_size(HMGL graph, mreal size);\r
+void mgl_set_font_size(HMGL graph, mreal size);\r
void mgl_set_font_def(HMGL graph, const char *fnt);\r
void mgl_set_rotated_text(HMGL graph, int enable);\r
void mgl_load_font(HMGL gr, const char *name, const char *path);\r
void mgl_copy_font(HMGL gr, HMGL gr_from);\r
void mgl_restore_font(HMGL gr);\r
-void mgl_set_color(char id, float r, float g, float b);\r
+void mgl_set_color(char id, mreal r, mreal g, mreal b);\r
void mgl_set_def_sch(HMGL gr, const char *sch);\r
/*****************************************************************************/\r
void mgl_set_def_sch_(uintptr_t *gr, const char *sch,int);\r
-void mgl_set_color_(char *id, float *r, float *g, float *b, int);\r
+void mgl_set_color_(char *id, mreal *r, mreal *g, mreal *b, int);\r
int mgl_get_warn_(uintptr_t *gr);\r
void mgl_set_warn_(uintptr_t *gr, int *code, const char *text,int);\r
long mgl_use_graph_(uintptr_t *gr, int *inc);\r
void mgl_highlight_(uintptr_t *gr, int *id);\r
\r
void mgl_set_palette_(uintptr_t *gr, const char *colors, int);\r
-void mgl_set_pal_color_(uintptr_t *graph, int *n, float *r, float *g, float *b);\r
+void mgl_set_pal_color_(uintptr_t *graph, int *n, mreal *r, mreal *g, mreal *b);\r
void mgl_set_pal_num_(uintptr_t *graph, int *num);\r
-void mgl_set_alpha_default_(uintptr_t *graph, float *alpha);\r
-void mgl_set_bar_width_(uintptr_t *graph, float *width);\r
+void mgl_set_alpha_default_(uintptr_t *graph, mreal *alpha);\r
+void mgl_set_bar_width_(uintptr_t *graph, mreal *width);\r
void mgl_set_meshnum_(uintptr_t *graph, int *num);\r
-void mgl_set_ambbr_(uintptr_t *gr, float *i);\r
+void mgl_set_ambbr_(uintptr_t *gr, mreal *i);\r
void mgl_set_light_dif_(uintptr_t *graph, int *enable);\r
\r
void mgl_set_rdc_acc_(uintptr_t *graph, int *reduce);\r
void mgl_set_cut_(uintptr_t *graph, int *cut);\r
-void mgl_set_cut_box_(uintptr_t *gr, float *x1,float *y1,float *z1,float *x2,float *y2,float *z2);\r
-void mgl_set_ranges_(uintptr_t *graph, float *x1, float *x2, float *y1, float *y2, float *z1, float *z2);\r
-void mgl_set_range_val_(uintptr_t *gr, const char *dir, float *v1,float *v2,int);\r
+void mgl_set_cut_box_(uintptr_t *gr, mreal *x1,mreal *y1,mreal *z1,mreal *x2,mreal *y2,mreal *z2);\r
+void mgl_set_ranges_(uintptr_t *graph, mreal *x1, mreal *x2, mreal *y1, mreal *y2, mreal *z1, mreal *z2);\r
+void mgl_set_range_val_(uintptr_t *gr, const char *dir, mreal *v1,mreal *v2,int);\r
void mgl_set_range_dat_(uintptr_t *gr, const char *dir, uintptr_t *a, int *add,int);\r
\r
-void mgl_set_origin_(uintptr_t *gr, float *x0, float *y0, float *z0);\r
+void mgl_set_origin_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0);\r
void mgl_set_func_(uintptr_t *graph, const char *EqX, const char *EqY, const char *EqZ, const char *EqA, int, int, int, int);\r
void mgl_set_coor_(uintptr_t *gr, int *how);\r
void mgl_set_ternary_(uintptr_t *graph, int *enable);\r
void mgl_set_tick_rotate_(uintptr_t *graph, int *enable);\r
void mgl_set_tick_skip_(uintptr_t *graph, int *enable);\r
\r
-float mgl_data_get_value_(uintptr_t *d, int *i, int *j, int *k);\r
+mreal mgl_data_get_value_(uintptr_t *d, int *i, int *j, int *k);\r
long mgl_data_get_nx_(uintptr_t *d);\r
long mgl_data_get_ny_(uintptr_t *d);\r
long mgl_data_get_nz_(uintptr_t *d);\r
\r
-void mgl_set_mark_size_(uintptr_t *graph, float *size);\r
-void mgl_set_arrow_size_(uintptr_t *graph, float *size);\r
-void mgl_set_font_size_(uintptr_t *graph, float *size);\r
+void mgl_set_mark_size_(uintptr_t *graph, mreal *size);\r
+void mgl_set_arrow_size_(uintptr_t *graph, mreal *size);\r
+void mgl_set_font_size_(uintptr_t *graph, mreal *size);\r
void mgl_set_font_def_(uintptr_t *graph, const char *fnt, int);\r
void mgl_set_rotated_text_(uintptr_t *graph, int *enable);\r
void mgl_load_font_(uintptr_t *gr, char *name, char *path, int l, int n);\r
/// Structure for transformation matrix\r
struct mglMatrix\r
{\r
- float b[9];\r
- float x,y,z,pf;\r
+ mreal b[9];\r
+ mreal x,y,z,pf;\r
mglMatrix() { clear(); }\r
- inline void clear() { x=y=z=0; memset(b,0,9*sizeof(float)); b[0]=b[4]=b[8]=1; }\r
- inline mglMatrix &operator=(mglMatrix &a)\r
- { x=a.x; y=a.y; z=a.z; pf=a.pf; memcpy(b,a.b,9*sizeof(float)); return *this; }\r
+ inline void clear() { x=y=z=0; memset(b,0,9*sizeof(mreal)); b[0]=b[4]=b[8]=1; }\r
+ inline mglMatrix &operator=(const mglMatrix &a)\r
+ { x=a.x; y=a.y; z=a.z; pf=a.pf; memcpy(b,a.b,9*sizeof(mreal)); return *this; }\r
};\r
//-----------------------------------------------------------------------------\r
/// Structure for drawing axis and ticks\r
struct mglAxis\r
{\r
- mglAxis() { dv=ds=d=v0=v1=v2=o=0; ns=f=ch=*t=0; }\r
+ mglAxis() { dv=ds=d=v0=v1=v2=o=sh=0; ns=f=ch=*t=0; }\r
mglAxis(const mglAxis &aa)\r
- { dv=aa.dv; ds=aa.ds; d=aa.d; dir=aa.dir;\r
+ { dv=aa.dv; ds=aa.ds; d=aa.d; dir=aa.dir; sh=aa.sh;\r
v0=aa.v0; v1=aa.v1; v2=aa.v2; o=aa.o;\r
a = aa.a; b = aa.b; org=aa.org; txt=aa.txt;\r
ns=aa.ns; f=aa.f; ch=aa.ch; wcscpy(t,aa.t); }\r
- inline void AddLabel(const wchar_t *lbl, float v)\r
+ inline void AddLabel(const wchar_t *lbl, mreal v)\r
{ txt.push_back(mglText(lbl,"",v)); }\r
- inline void AddLabel(const std::wstring &lbl, float v)\r
+ inline void AddLabel(const std::wstring &lbl, mreal v)\r
{ txt.push_back(mglText(lbl,v)); }\r
\r
- float dv,ds; ///< Actual step for ticks and subticks.\r
- float d; ///< Step for axis ticks (if positive) or its number (if negative).\r
+ mreal dv,ds; ///< Actual step for ticks and subticks.\r
+ mreal d; ///< Step for axis ticks (if positive) or its number (if negative).\r
int ns; ///< Number of axis subticks.\r
wchar_t t[256]; ///< Tick template (set NULL to use default one ("%.2g" in simplest case))\r
mglPoint dir; ///< Axis direction\r
mglPoint a,b; ///< Directions of over axis\r
mglPoint org;\r
- float v0; ///< Center of axis cross section\r
- float v1; ///< Minimal axis range.\r
- float v2; ///< Maximal axis range.\r
- float o; ///< Point of starting ticks numbering (if NAN then Org is used).\r
+ mreal v0; ///< Center of axis cross section\r
+ mreal v1; ///< Minimal axis range.\r
+ mreal v2; ///< Maximal axis range.\r
+ mreal o; ///< Point of starting ticks numbering (if NAN then Org is used).\r
int f; ///< Flag 0x1 - time, 0x2 - manual, 0x4 - fixed dv\r
std::vector<mglText> txt; ///< Axis labels\r
- char ch; ///< Character of axis (like 'x','y','z','c')\r
+ char ch; ///< Character of axis (like 'x','y','z','c')\r
+ mreal sh; ///< Extra shift of ticks and axis labels\r
};\r
//-----------------------------------------------------------------------------\r
/// Structure for light source\r
mglPoint r; ///< Position of light sources (NAN for infinity)\r
mglPoint q; ///< Actual position of light sources (filled by LightScale() function)\r
mglPoint p; ///< Actual direction of light sources (filled by LightScale() function)\r
- float a; ///< Aperture of light sources\r
- float b; ///< Brightness of light sources\r
+ mreal a; ///< Aperture of light sources\r
+ mreal b; ///< Brightness of light sources\r
mglColor c; ///< Color of light sources\r
};\r
//-----------------------------------------------------------------------------\r
void DefaultPlotParam();\r
\r
/// Set angle of view indepently from mglCanvas::Rotate()\r
- virtual void View(float tetx,float tetz,float tety=0);\r
+ virtual void View(mreal tetx,mreal tetz,mreal tety=0);\r
/// Zoom in or zoom out (if Zoom(0, 0, 1, 1)) a part of picture\r
- virtual void Zoom(float x1, float y1, float x2, float y2);\r
+ virtual void Zoom(mreal x1, mreal y1, mreal x2, mreal y2);\r
/// Restore image after View() and Zoom()\r
virtual void Restore() { Bp.clear(); Bp.pf=0; }\r
\r
/// Push transformation matrix into stack\r
inline void Push() { stack.push_back(B); }\r
/// Set PlotFactor\r
- inline void SetPlotFactor(float val)\r
+ inline void SetPlotFactor(mreal val)\r
{ if(val<=0) {B.pf=1.55; set(MGL_AUTO_FACTOR);} else {B.pf=val; clr(MGL_AUTO_FACTOR);} }\r
/// Get PlotFactor\r
- inline float GetPlotFactor() { return B.pf; }\r
+ inline mreal GetPlotFactor() { return B.pf; }\r
/// Pop transformation matrix from stack\r
inline void Pop() { B = stack.back(); stack.pop_back(); }\r
/// Clear up the frame\r
virtual void Clf(mglColor back=WC);\r
\r
/// Put further plotting in cell of stick rotated on angles tet, phi\r
- void StickPlot(int num, int i, float tet, float phi);\r
+ void StickPlot(int num, int i, mreal tet, mreal phi);\r
/// Put further plotting in some region of whole frame surface.\r
- void InPlot(float x1,float x2,float y1,float y2,bool rel=true);\r
- void InPlot(float x1,float x2,float y1,float y2, const char *style);\r
+ void InPlot(mreal x1,mreal x2,mreal y1,mreal y2,bool rel=true);\r
+ void InPlot(mreal x1,mreal x2,mreal y1,mreal y2, const char *style);\r
/// Add title for current subplot/inplot\r
- void Title(const char *title,const char *stl="#",float size=-2);\r
- void Title(const wchar_t *title,const char *stl="#",float size=-2);\r
+ void Title(const char *title,const char *stl="#",mreal size=-2);\r
+ void Title(const wchar_t *title,const char *stl="#",mreal size=-2);\r
/// Set aspect ratio for further plotting.\r
- void Aspect(float Ax,float Ay,float Az);\r
+ void Aspect(mreal Ax,mreal Ay,mreal Az);\r
/// Rotate a further plotting.\r
- void Rotate(float TetX,float TetZ,float TetY=0);\r
+ void Rotate(mreal TetX,mreal TetZ,mreal TetY=0);\r
/// Rotate a further plotting around vector {x,y,z}.\r
- void RotateN(float Tet,float x,float y,float z);\r
+ void RotateN(mreal Tet,mreal x,mreal y,mreal z);\r
/// Set perspective (in range [0,1)) for plot. Set to zero for switching off.\r
- void Perspective(float a) { Bp.pf = fabs(a); }\r
+ void Perspective(mreal a) { Bp.pf = fabs(a); }\r
\r
/// Set size of frame in pixels. Normally this function is called internaly.\r
virtual void SetSize(int w,int h);\r
- /// Get ratio (float width)/(float height).\r
- float GetRatio() const;\r
+ /// Get ratio (mreal width)/(mreal height).\r
+ mreal GetRatio() const;\r
/// Get bitmap data prepared for saving to file\r
virtual unsigned char **GetRGBLines(long &w, long &h, unsigned char *&f, bool alpha=false);\r
/// Get RGB bitmap of current state image.\r
void MPI_Send(int id);\r
/// Receive graphical information from node id using MPI\r
void MPI_Recv(int id);\r
- inline float GetDelay() const { return Delay; }\r
- inline void SetDelay(float d) { Delay=d; }\r
+ inline mreal GetDelay() const { return Delay; }\r
+ inline void SetDelay(mreal d) { Delay=d; }\r
\r
/// Calculate 3D coordinate {x,y,z} for screen point {xs,ys}\r
mglPoint CalcXYZ(int xs, int ys) const;\r
inline void SetTranspType(int val)\r
{ Flag=(Flag&(~3)) + (val&3); SetAxisStl(val==2?"w-":"k-"); }\r
/// Set the fog distance or switch it off (if d=0).\r
- virtual void Fog(float d, float dz=0.25);\r
+ virtual void Fog(mreal d, mreal dz=0.25);\r
/// Switch on/off the specified light source.\r
virtual void Light(int n, bool enable);\r
/// Add a light source.\r
- virtual void AddLight(int n,mglPoint r, mglPoint d, char c='w', float bright=0.5, float ap=0);\r
- inline void AddLight(int n,mglPoint d, char c='w', float bright=0.5, float ap=0)\r
+ virtual void AddLight(int n,mglPoint r, mglPoint d, char c='w', mreal bright=0.5, mreal ap=0);\r
+ inline void AddLight(int n,mglPoint d, char c='w', mreal bright=0.5, mreal ap=0)\r
{ AddLight(n,mglPoint(NAN),d,c,bright,ap); }\r
\r
/// Set ticks position and text (\n separated). Use n=0 to disable this feature.\r
void SetTickTempl(char dir, const wchar_t *t);\r
void SetTickTempl(char dir, const char *t);\r
/// Set time templates for ticks\r
- void SetTickTime(char dir, float d=0, const char *t="");\r
+ void SetTickTime(char dir, mreal d=0, const char *t="");\r
/// Set the ticks parameters\r
- void SetTicks(char dir, float d=0, int ns=0, float org=NAN);\r
+ void SetTicks(char dir, mreal d=0, int ns=0, mreal org=NAN);\r
/// Auto adjust ticks\r
void AdjustTicks(const char *dir="xyzc", bool force=false);\r
/// Tune ticks\r
- inline void SetTuneTicks(int tune, float pos=1.15)\r
+ inline void SetTuneTicks(int tune, mreal pos=1.15)\r
{ TuneTicks = tune; FactorPos = pos; };\r
/// Set ticks styles\r
void SetAxisStl(const char *stl="k", const char *tck=0, const char *sub=0);\r
/// Set ticks length\r
- void SetTickLen(float tlen, float stt=1.);\r
+ void SetTickLen(mreal tlen, mreal stt=1.);\r
\r
/// Draws bounding box outside the plotting volume with color \a c.\r
void Box(const char *col=0, bool ticks=true);\r
/// Draw grid lines perpendicular to direction determined by string parameter \a dir.\r
void Grid(const char *dir="xyzt",const char *pen="B-");\r
/// Print the label \a text for axis \a dir.\r
- void Label(char dir, const char *text, float pos=0, float shift=0);\r
- void Labelw(char dir, const wchar_t *text, float pos=0, float shift=0);\r
-\r
- /// Print the \a text at arbitrary position of the picture \a x, \a y in range [0,1]x[0,1].\r
- void Label(float x, float y, const char *text, const char *fnt=0, bool rel=false);\r
- void Labelw(float x, float y, const wchar_t *text, const char *fnt=0, bool rel=false);\r
-// /// Print the title text for the picture\r
-// void Title(const wchar_t *text,const char *font=0);\r
-// void Title(const char *text,const char *font=0);\r
+ void Label(char dir, const char *text, mreal pos=0, mreal shift=0);\r
+ void Labelw(char dir, const wchar_t *text, mreal pos=0, mreal shift=0);\r
\r
/// Draw colorbar at edge of axis\r
void Colorbar(const char *sch=0);\r
- void Colorbar(const char *sch, float x, float y, float w, float h);\r
+ void Colorbar(const char *sch, mreal x, mreal y, mreal w, mreal h);\r
/// Draw colorbar at edge of axis for manual colors\r
void Colorbar(HCDT v, const char *sch=0);\r
- void Colorbar(HCDT v, const char *sch, float x, float y, float w, float h);\r
+ void Colorbar(HCDT v, const char *sch, mreal x, mreal y, mreal w, mreal h);\r
\r
/// Draw legend of accumulated strings at position (x, y) by \a font with \a size\r
- inline void Legend(float x, float y, const char *font="#", float size=-0.8, float llen=0.1)\r
+ inline void Legend(mreal x, mreal y, const char *font="#", mreal size=-0.8, mreal llen=0.1)\r
{ Legend(Leg,x,y,font,size,llen); }\r
/// Draw legend of accumulated strings by \a font with \a size\r
- inline void Legend(int where=0x3, const char *font="#", float size=-0.8, float llen=0.1)\r
+ inline void Legend(int where=0x3, const char *font="#", mreal size=-0.8, mreal llen=0.1)\r
{ Legend(Leg,(where&1)?1:0,(where&2)?1:0,font,size,llen); }\r
/// Draw legend of accumulated strings by \a font with \a size\r
- inline void Legend(const std::vector<mglText> &leg, int where=3, const char *font="#", float size=-0.8, float llen=0)\r
+ inline void Legend(const std::vector<mglText> &leg, int where=3, const char *font="#", mreal size=-0.8, mreal llen=0)\r
{ Legend(leg,(where&1)?1:0,(where&2)?1:0,font,size,llen); }\r
/// Draw legend strings \a text at position (x, y) by \a font with \a size\r
- void Legend(const std::vector<mglText> &leg, float x, float y, const char *font="#", float size=-0.8, float llen=0);\r
+ void Legend(const std::vector<mglText> &leg, mreal x, mreal y, const char *font="#", mreal size=-0.8, mreal llen=0);\r
/// Number of marks in legend sample\r
inline void SetLegendMarks(int num=1) { LegendMarks = num>0?num:1; };\r
\r
void EndGroup();\r
/// Retur color for primitive depending lighting\r
mglColor GetColor(const mglPrim &p);\r
+ /// Set extra shift for tick and axis labels\r
+ inline void SetTickShift(mglPoint p)\r
+ { ax.sh = p.x; ay.sh = p.y; az.sh = p.z; ac.sh = p.c; }\r
\r
protected:\r
- float Delay; ///< Delay for animation in seconds\r
+ mreal Delay; ///< Delay for animation in seconds\r
+ // NOTE: Z should be float for reducing space and for compatibility reasons\r
float *Z; ///< Height for given level in Z-direction\r
unsigned char *C; ///< Picture for given level in Z-direction\r
int *OI; ///< ObjId arrays\r
mglAxis ax,ay,az,ac;///< Axis parameters\r
\r
int TuneTicks; ///< Draw tuned ticks with extracted common component\r
- float FactorPos; ///< Position of axis ticks factor (0 at Min, 1 at Max, 1.1 is default)\r
- float TickLen; ///< Length of tiks (subticks length is sqrt(1+st_t)=1.41... times smaller)\r
+ mreal FactorPos; ///< Position of axis ticks factor (0 at Min, 1 at Max, 1.1 is default)\r
+ mreal TickLen; ///< Length of tiks (subticks length is sqrt(1+st_t)=1.41... times smaller)\r
char AxisStl[32]; ///< Axis line style. Default is "k"\r
char TickStl[32]; ///< Tick line style. Default is "k"\r
char SubTStl[32]; ///< Subtick line style. Default is "k"\r
- float st_t; ///< Subtick-to-tick ratio (ls=lt/sqrt(1+st_t)). Default is 1.\r
+ mreal st_t; ///< Subtick-to-tick ratio (ls=lt/sqrt(1+st_t)). Default is 1.\r
\r
int CurFrameId; ///< Number of automaticle created frames\r
int Width; ///< Width of the image\r
mglMatrix Bp; ///< Transformation matrix for View() and Zoom()\r
mglMatrix B; ///< Transformation matrix\r
mglMatrix B1; ///< Transformation matrix for colorbar\r
- float inW, inH; ///< Width and height of last InPlot\r
+ mreal inW, inH; ///< Width and height of last InPlot\r
mglLight light[10]; ///< Light sources\r
- float FogDist; ///< Inverse fog distance (fog ~ exp(-FogDist*Z))\r
- float FogDz; ///< Relative shift of fog\r
+ mreal FogDist; ///< Inverse fog distance (fog ~ exp(-FogDist*Z))\r
+ mreal FogDz; ///< Relative shift of fog\r
\r
/// Auto adjust ticks\r
void AdjustTicks(mglAxis &aa, bool ff);\r
/// Get drawing data for i-th frame.\r
void GetDrwDat(long i);\r
\r
- float GetOrgX(char dir) const; ///< Get Org.x (parse NAN value)\r
- float GetOrgY(char dir) const; ///< Get Org.y (parse NAN value)\r
- float GetOrgZ(char dir) const; ///< Get Org.z (parse NAN value)\r
+ mreal GetOrgX(char dir) const; ///< Get Org.x (parse NAN value)\r
+ mreal GetOrgY(char dir) const; ///< Get Org.y (parse NAN value)\r
+ mreal GetOrgZ(char dir) const; ///< Get Org.z (parse NAN value)\r
\r
- void mark_plot(long p, char type, float size=1); // position in pntC\r
+ void mark_plot(long p, char type, mreal size=1); // position in pntC\r
void arrow_plot(long p1, long p2, char st); // position in pntC\r
void line_plot(long p1, long p2); // position in pntC\r
void trig_plot(long p1, long p2, long p3); // position in pntN\r
void quad_plot(long p1, long p2, long p3, long p4); // position in pntN\r
- void Glyph(float x, float y, float f, int style, long icode, float col);\r
- float text_plot(long p,const wchar_t *text,const char *fnt,float size=-1,float sh=0,float col=-('k'), bool rot=true); // position in pntN\r
+ void Glyph(mreal x, mreal y, mreal f, int style, long icode, mreal col);\r
+ mreal text_plot(long p,const wchar_t *text,const char *fnt,mreal size=-1,mreal sh=0,mreal col=-('k'), bool rot=true); // position in pntN\r
\r
void add_prim(mglPrim &a); ///< add primitive to list\r
- void mark_draw(long p, char type, float size, mglDrawReg *d);\r
- void arrow_draw(long p1, long p2, char st, float size, mglDrawReg *d);\r
+ void mark_draw(long p, char type, mreal size, mglDrawReg *d);\r
+ void arrow_draw(long p1, long p2, char st, mreal size, mglDrawReg *d);\r
virtual void line_draw(long p1, long p2, mglDrawReg *d);\r
virtual void trig_draw(long p1, long p2, long p3, bool anorm, mglDrawReg *d);\r
virtual void quad_draw(long p1, long p2, long p3, long p4, mglDrawReg *d);\r
virtual void pnt_draw(long p, mglDrawReg *d);\r
void glyph_draw(const mglPrim *P, mglDrawReg *d);\r
- bool IsSame(const mglPrim &pr,float wp,mglColor cp,int st);\r
+ bool IsSame(const mglPrim &pr,mreal wp,mglColor cp,int st);\r
\r
// functions for multi-threading\r
void PreparePrim(bool fast);\r
void PutDrawReg(mglDrawReg *d, const mglCanvas *gr);\r
\r
private:\r
-// float _tetx,_tety,_tetz; // extra angles\r
+// mreal _tetx,_tety,_tetz; // extra angles\r
std::vector<mglMatrix> stack; ///< stack for transformation matrixes\r
int dr_nx1, dr_nx2, dr_ny1, dr_ny2; // Allowed drawing region\r
GifFileType *gif;\r
- float fscl,ftet; ///< last scale and rotation for glyphs\r
+ mreal fscl,ftet; ///< last scale and rotation for glyphs\r
\r
/// Draw generic colorbar\r
- void colorbar(HCDT v, const float *s, int where, float x, float y, float w, float h);\r
+ void colorbar(HCDT v, const mreal *s, int where, mreal x, mreal y, mreal w, mreal h);\r
/// Draw labels for ticks\r
void DrawLabels(mglAxis &aa);\r
/// Draw tick\r
void tick_draw(mglPoint o, mglPoint d1, mglPoint d2, int f, const char *stl);\r
/// Plot point \a p with color \a c\r
- void pnt_plot(long x,long y,float z,const unsigned char c[4]);\r
- float FindOptOrg(char dir, int ind) const;\r
- /// Transform float color and alpha to bits format\r
+ void pnt_plot(long x,long y,mreal z,const unsigned char c[4]);\r
+ mreal FindOptOrg(char dir, int ind) const;\r
+ /// Transform mreal color and alpha to bits format\r
unsigned char* col2int(const mglPnt &p, unsigned char *r);\r
/// Combine colors in 2 plane.\r
void combine(unsigned char *c1,unsigned char *c2);\r
inline void PostScale(mglPoint *p,long n) const { for(long i=0;i<n;i++) PostScale(p[i]); }\r
\r
// functions for glyph drawing\r
- void glyph_fill(const mglPnt &p, float f, int nt, const short *trig, mglDrawReg *d);\r
- void glyph_wire(const mglPnt &p, float f, int nl, const short *line, mglDrawReg *d);\r
- void glyph_line(const mglPnt &p, float f, bool solid, mglDrawReg *d);\r
+ void glyph_fill(const mglPnt &p, mreal f, int nt, const short *trig, mglDrawReg *d);\r
+ void glyph_wire(const mglPnt &p, mreal f, int nl, const short *line, mglDrawReg *d);\r
+ void glyph_line(const mglPnt &p, mreal f, bool solid, mglDrawReg *d);\r
};\r
//-----------------------------------------------------------------------------\r
struct mglThreadG\r
void mgl_set_quality(HMGL gr, int qual);\r
void mgl_combine_gr(HMGL gr, HMGL in);\r
\r
-void mgl_set_tick_len(HMGL gr, float len, float stt);\r
+void mgl_set_tick_len(HMGL gr, mreal len, mreal stt);\r
void mgl_set_axis_stl(HMGL gr, const char *stl, const char *tck, const char *sub);\r
void mgl_adjust_ticks(HMGL gr, const char *dir);\r
-void mgl_set_ticks(HMGL gr, char dir, float d, int ns, float org);\r
+void mgl_set_ticks(HMGL gr, char dir, mreal d, int ns, mreal org);\r
void mgl_set_ticks_str(HMGL gr, char dir, const char *lbl, int add);\r
void mgl_set_ticks_wcs(HMGL gr, char dir, const wchar_t *lbl, int add);\r
void mgl_set_ticks_val(HMGL gr, char dir, HCDT val, const char *lbl, int add);\r
void mgl_set_ticks_valw(HMGL gr, char dir, HCDT val, const wchar_t *lbl, int add);\r
-void mgl_tune_ticks(HMGL gr, int tune, float fact_pos);\r
+void mgl_tune_ticks(HMGL gr, int tune, mreal fact_pos);\r
void mgl_set_tick_templ(HMGL gr, char dir, const char *templ);\r
void mgl_set_tick_templw(HMGL gr, char dir, const wchar_t *templ);\r
-void mgl_set_ticks_time(HMGL gr, char dir, float d, const char *t);\r
+void mgl_set_ticks_time(HMGL gr, char dir, mreal d, const char *t);\r
+void mgl_set_tick_shift(HMGL gr, mreal sx, mreal sy, mreal sz, mreal sc);\r
\r
void mgl_box(HMGL graph);\r
void mgl_box_str(HMGL gr, const char *col, int ticks);\r
void mgl_axis(HMGL gr, const char *dir, const char *stl);\r
void mgl_axis_grid(HMGL gr, const char *dir,const char *pen);\r
void mgl_label(HMGL gr, char dir, const char *text);\r
-void mgl_label_ext(HMGL gr, char dir, const char *text, float pos, float shift);\r
-void mgl_labelw_ext(HMGL gr, char dir, const wchar_t *text, float pos, float shift);\r
+void mgl_label_ext(HMGL gr, char dir, const char *text, mreal pos, mreal shift);\r
+void mgl_labelw_ext(HMGL gr, char dir, const wchar_t *text, mreal pos, mreal shift);\r
\r
void mgl_colorbar(HMGL gr, const char *sch);\r
-void mgl_colorbar_ext(HMGL gr, const char *sch, float x, float y, float w, float h);\r
+void mgl_colorbar_ext(HMGL gr, const char *sch, mreal x, mreal y, mreal w, mreal h);\r
void mgl_colorbar_val(HMGL gr, HCDT dat, const char *sch);\r
-void mgl_colorbar_val_ext(HMGL gr, HCDT dat, const char *sch,float x, float y, float w, float h);\r
+void mgl_colorbar_val_ext(HMGL gr, HCDT dat, const char *sch,mreal x, mreal y, mreal w, mreal h);\r
\r
void mgl_add_legend(HMGL gr, const char *text,const char *style);\r
void mgl_add_legendw(HMGL gr, const wchar_t *text,const char *style);\r
void mgl_clear_legend(HMGL graph);\r
-void mgl_legend_pos(HMGL gr, float x, float y, const char *font, float size, float llen);\r
-void mgl_legend(HMGL gr, int where, const char *font, float size, float llen);\r
+void mgl_legend_pos(HMGL gr, mreal x, mreal y, const char *font, mreal size, mreal llen);\r
+void mgl_legend(HMGL gr, int where, const char *font, mreal size, mreal llen);\r
void mgl_set_legend_marks(HMGL gr, int num);\r
\r
HMEX mgl_create_expr(const char *expr);\r
int mgl_get_spl_id(HMGL gr, long x, long y);\r
int mgl_get_width(HMGL graph);\r
int mgl_get_height(HMGL graph);\r
-void mgl_calc_xyz(HMGL gr, int xs, int ys, float *x, float *y, float *z);\r
-void mgl_calc_scr(HMGL gr, float x, float y, float z, int *xs, int *ys);\r
+void mgl_calc_xyz(HMGL gr, int xs, int ys, mreal *x, mreal *y, mreal *z);\r
+void mgl_calc_scr(HMGL gr, mreal x, mreal y, mreal z, int *xs, int *ys);\r
\r
int mgl_new_frame(HMGL graph);\r
void mgl_end_frame(HMGL graph);\r
\r
void mgl_set_transp_type(HMGL gr, int type);\r
void mgl_set_alpha(HMGL gr, int enable);\r
-void mgl_set_fog(HMGL gr, float d, float dz);\r
+void mgl_set_fog(HMGL gr, mreal d, mreal dz);\r
void mgl_set_light(HMGL gr, int enable);\r
void mgl_set_light_n(HMGL gr, int n, int enable);\r
\r
void mgl_mat_pop(HMGL gr);\r
void mgl_mat_push(HMGL gr);\r
void mgl_clf(HMGL graph);\r
-void mgl_clf_rgb(HMGL gr, float r, float g, float b);\r
+void mgl_clf_rgb(HMGL gr, mreal r, mreal g, mreal b);\r
\r
-void mgl_subplot_d(HMGL gr, int nx,int ny,int m,const char *style, float dx, float dy);\r
+void mgl_subplot_d(HMGL gr, int nx,int ny,int m,const char *style, mreal dx, mreal dy);\r
void mgl_subplot(HMGL gr, int nx,int ny,int m,const char *style);\r
void mgl_multiplot(HMGL gr, int nx,int ny,int m,int dx,int dy,const char *style);\r
-void mgl_inplot(HMGL gr, float x1,float x2,float y1,float y2);\r
-void mgl_relplot(HMGL gr, float x1,float x2,float y1,float y2);\r
-void mgl_columnplot(HMGL gr, int num, int ind, float d);\r
-void mgl_gridplot(HMGL gr, int nx, int ny, int m, float d);\r
-void mgl_stickplot(HMGL gr, int num, int ind, float tet, float phi);\r
-void mgl_title(HMGL gr, const char *title, const char *stl, float size);\r
-void mgl_titlew(HMGL gr, const wchar_t *title, const char *stl, float size);\r
-void mgl_set_plotfactor(HMGL gr, float val);\r
+void mgl_inplot(HMGL gr, mreal x1,mreal x2,mreal y1,mreal y2);\r
+void mgl_relplot(HMGL gr, mreal x1,mreal x2,mreal y1,mreal y2);\r
+void mgl_columnplot(HMGL gr, int num, int ind, mreal d);\r
+void mgl_gridplot(HMGL gr, int nx, int ny, int m, mreal d);\r
+void mgl_stickplot(HMGL gr, int num, int ind, mreal tet, mreal phi);\r
+void mgl_title(HMGL gr, const char *title, const char *stl, mreal size);\r
+void mgl_titlew(HMGL gr, const wchar_t *title, const char *stl, mreal size);\r
+void mgl_set_plotfactor(HMGL gr, mreal val);\r
\r
-void mgl_aspect(HMGL gr, float Ax,float Ay,float Az);\r
-void mgl_rotate(HMGL gr, float TetX,float TetZ,float TetY);\r
-void mgl_view(HMGL gr, float TetX,float TetZ,float TetY);\r
-void mgl_zoom(HMGL gr, float x1, float y1, float x2, float y2);\r
-void mgl_rotate_vector(HMGL gr, float Tet,float x,float y,float z);\r
-void mgl_perspective(HMGL gr, float val);\r
+void mgl_aspect(HMGL gr, mreal Ax,mreal Ay,mreal Az);\r
+void mgl_rotate(HMGL gr, mreal TetX,mreal TetZ,mreal TetY);\r
+void mgl_view(HMGL gr, mreal TetX,mreal TetZ,mreal TetY);\r
+void mgl_zoom(HMGL gr, mreal x1, mreal y1, mreal x2, mreal y2);\r
+void mgl_rotate_vector(HMGL gr, mreal Tet,mreal x,mreal y,mreal z);\r
+void mgl_perspective(HMGL gr, mreal val);\r
\r
void mgl_draw_thr(void *);\r
/*****************************************************************************/\r
void mgl_set_quality_(uintptr_t *gr, int *qual);\r
void mgl_combine_gr_(uintptr_t *gr, uintptr_t *in);\r
\r
-void mgl_set_tick_len_(uintptr_t *graph, float *len, float *stt);\r
+void mgl_set_tick_len_(uintptr_t *graph, mreal *len, mreal *stt);\r
void mgl_set_axis_stl_(uintptr_t *graph, const char *stl, const char *tck, const char *sub, int,int,int);\r
+void mgl_set_tick_shift_(uintptr_t *gr, mreal *sx, mreal *sy, mreal *sz, mreal *sc);\r
\r
void mgl_adjust_ticks_(uintptr_t *gr, const char *dir, int l);\r
-void mgl_set_ticks_(uintptr_t *gr, char *dir, float *d, int *ns, float *org, int);\r
+void mgl_set_ticks_(uintptr_t *gr, char *dir, mreal *d, int *ns, mreal *org, int);\r
void mgl_set_ticks_str_(uintptr_t *gr, const char *dir, const char *lbl, int *add,int,int l);\r
void mgl_set_ticks_val_(uintptr_t *gr, const char *dir, uintptr_t *val, const char *lbl, int *add,int,int l);\r
-void mgl_tune_ticks_(uintptr_t *gr, int *tune, float *fact_pos);\r
+void mgl_tune_ticks_(uintptr_t *gr, int *tune, mreal *fact_pos);\r
void mgl_set_tick_templ_(uintptr_t *gr, const char *dir, const char *templ,int,int l);\r
-void mgl_set_ticks_time_(uintptr_t *gr, const char *dir, float *d, const char *t,int,int l);\r
+void mgl_set_ticks_time_(uintptr_t *gr, const char *dir, mreal *d, const char *t,int,int l);\r
void mgl_box_(uintptr_t *gr);\r
void mgl_box_str_(uintptr_t *gr, const char *col, int *ticks, int l);\r
void mgl_axis_(uintptr_t *gr, const char *dir, const char *stl,int,int);\r
void mgl_axis_grid_(uintptr_t *gr, const char *dir,const char *pen,int l,int n);\r
void mgl_label_(uintptr_t *gr, const char *dir, const char *text,int,int l);\r
-void mgl_label_ext_(uintptr_t *gr, const char *dir, const char *text, float *pos, float *shift,int,int l);\r
+void mgl_label_ext_(uintptr_t *gr, const char *dir, const char *text, mreal *pos, mreal *shift,int,int l);\r
/*****************************************************************************/\r
void mgl_colorbar_(uintptr_t *gr, const char *sch,int l);\r
-void mgl_colorbar_ext_(uintptr_t *gr, const char *sch, float *x, float *y, float *w, float *h, int l);\r
+void mgl_colorbar_ext_(uintptr_t *gr, const char *sch, mreal *x, mreal *y, mreal *w, mreal *h, int l);\r
void mgl_colorbar_val_(uintptr_t *gr, uintptr_t *dat, const char *sch,int l);\r
-void mgl_colorbar_val_ext_(uintptr_t *gr, uintptr_t *dat, const char *sch, float *x, float *y, float *w, float *h, int l);\r
+void mgl_colorbar_val_ext_(uintptr_t *gr, uintptr_t *dat, const char *sch, mreal *x, mreal *y, mreal *w, mreal *h, int l);\r
\r
void mgl_add_legend_(uintptr_t *gr, const char *text,const char *style,int l,int n);\r
void mgl_clear_legend_(uintptr_t *gr);\r
-void mgl_legend_pos_(uintptr_t *gr, float *x, float *y, const char *font, float *size, float *llen,int l);\r
-void mgl_legend_(uintptr_t *gr, int *where, const char *font, float *size, float *llen,int l);\r
+void mgl_legend_pos_(uintptr_t *gr, mreal *x, mreal *y, const char *font, mreal *size, mreal *llen,int l);\r
+void mgl_legend_(uintptr_t *gr, int *where, const char *font, mreal *size, mreal *llen,int l);\r
void mgl_set_legend_marks_(uintptr_t *gr, int *num);\r
\r
uintptr_t mgl_create_expr_(const char *expr, int);\r
void mgl_delete_expr_(uintptr_t *ex);\r
-float mgl_eval_expr_(uintptr_t *ex, float *x, float *y,float *z);\r
-float mgl_diff_expr_(uintptr_t *ex, const char *dir, float *x, float *y,float *z, int);\r
+mreal mgl_eval_expr_(uintptr_t *ex, mreal *x, mreal *y,mreal *z);\r
+mreal mgl_diff_expr_(uintptr_t *ex, const char *dir, mreal *x, mreal *y,mreal *z, int);\r
\r
void mgl_show_image_(uintptr_t *graph, const char *viewer, int *keep, int);\r
void mgl_write_frame_(uintptr_t *graph, const char *fname,const char *descr,int lf,int ld);\r
int mgl_get_spl_id_(uintptr_t *graph, int *x, int *y);\r
int mgl_get_width_(uintptr_t *graph);\r
int mgl_get_height_(uintptr_t *graph);\r
-void mgl_calc_xyz_(uintptr_t *gr, int *xs, int *ys, float *x, float *y, float *z);\r
-void mgl_calc_scr_(uintptr_t *gr, float *x, float *y, float *z, int *xs, int *ys);\r
+void mgl_calc_xyz_(uintptr_t *gr, int *xs, int *ys, mreal *x, mreal *y, mreal *z);\r
+void mgl_calc_scr_(uintptr_t *gr, mreal *x, mreal *y, mreal *z, int *xs, int *ys);\r
\r
int mgl_new_frame_(uintptr_t *graph);\r
void mgl_end_frame_(uintptr_t *graph);\r
\r
void mgl_set_transp_type_(uintptr_t *graph, int *type);\r
void mgl_set_alpha_(uintptr_t *graph, int *enable);\r
-void mgl_set_fog_(uintptr_t *graph, float *dist, float *dz);\r
+void mgl_set_fog_(uintptr_t *graph, mreal *dist, mreal *dz);\r
void mgl_set_light_(uintptr_t *graph, int *enable);\r
void mgl_set_light_n_(uintptr_t *gr, int *n, int *enable);\r
-void mgl_add_light_(uintptr_t *graph, int *n, float *x, float *y, float *z);\r
-void mgl_add_light(HMGL gr, int n, float x, float y, float z);\r
-void mgl_add_light_ext_(uintptr_t *graph, int *n, float *x, float *y, float *z, char *c, float *br, float *ap, int);\r
-void mgl_add_light_ext(HMGL gr, int n, float x, float y, float z, char c, float br, float ap);\r
-void mgl_add_light_loc_(uintptr_t *graph, int *n, float *x, float *y, float *z, float *dx, float *dy, float *dz, char *c, float *br, float *ap, int);\r
-void mgl_add_light_loc(HMGL gr, int n, float x, float y, float z, float dx, float dy, float dz, char c, float br, float ap);\r
+void mgl_add_light_(uintptr_t *graph, int *n, mreal *x, mreal *y, mreal *z);\r
+void mgl_add_light(HMGL gr, int n, mreal x, mreal y, mreal z);\r
+void mgl_add_light_ext_(uintptr_t *graph, int *n, mreal *x, mreal *y, mreal *z, char *c, mreal *br, mreal *ap, int);\r
+void mgl_add_light_ext(HMGL gr, int n, mreal x, mreal y, mreal z, char c, mreal br, mreal ap);\r
+void mgl_add_light_loc_(uintptr_t *graph, int *n, mreal *x, mreal *y, mreal *z, mreal *dx, mreal *dy, mreal *dz, char *c, mreal *br, mreal *ap, int);\r
+void mgl_add_light_loc(HMGL gr, int n, mreal x, mreal y, mreal z, mreal dx, mreal dy, mreal dz, char c, mreal br, mreal ap);\r
\r
void mgl_mat_push_(uintptr_t *gr);\r
void mgl_mat_pop_(uintptr_t *gr);\r
void mgl_clf_(uintptr_t *graph);\r
-void mgl_clf_rgb_(uintptr_t *graph, float *r, float *g, float *b);\r
+void mgl_clf_rgb_(uintptr_t *graph, mreal *r, mreal *g, mreal *b);\r
\r
void mgl_subplot_(uintptr_t *graph, int *nx,int *ny,int *m);\r
-void mgl_subplot_d_(uintptr_t *graph, int *nx,int *ny,int *m,float *dx,float *dy);\r
+void mgl_subplot_d_(uintptr_t *graph, int *nx,int *ny,int *m,mreal *dx,mreal *dy);\r
void mgl_subplot_s_(uintptr_t *graph, int *nx,int *ny,int *m, const char *s,int);\r
void mgl_multiplot_(uintptr_t *graph, int *nx,int *ny,int *m,int *dx,int *dy, const char *s,int);\r
-void mgl_inplot_(uintptr_t *graph, float *x1,float *x2,float *y1,float *y2);\r
-void mgl_relplot_(uintptr_t *graph, float *x1,float *x2,float *y1,float *y2);\r
-void mgl_columnplot_(uintptr_t *graph, int *num, int *i, float *d);\r
-void mgl_gridplot_(uintptr_t *graph, int *nx, int *ny, int *i, float *d);\r
-void mgl_stickplot_(uintptr_t *graph, int *num, int *i, float *tet, float *phi);\r
-void mgl_set_plotfactor_(uintptr_t *graph, float *val);\r
+void mgl_inplot_(uintptr_t *graph, mreal *x1,mreal *x2,mreal *y1,mreal *y2);\r
+void mgl_relplot_(uintptr_t *graph, mreal *x1,mreal *x2,mreal *y1,mreal *y2);\r
+void mgl_columnplot_(uintptr_t *graph, int *num, int *i, mreal *d);\r
+void mgl_gridplot_(uintptr_t *graph, int *nx, int *ny, int *i, mreal *d);\r
+void mgl_stickplot_(uintptr_t *graph, int *num, int *i, mreal *tet, mreal *phi);\r
+void mgl_set_plotfactor_(uintptr_t *graph, mreal *val);\r
\r
-void mgl_title_(uintptr_t *gr, const char *title, const char *stl, float *size, int,int);\r
-void mgl_aspect_(uintptr_t *graph, float *Ax,float *Ay,float *Az);\r
-void mgl_rotate_(uintptr_t *graph, float *TetX,float *TetZ,float *TetY);\r
-void mgl_view_(uintptr_t *graph, float *TetX,float *TetZ,float *TetY);\r
-void mgl_zoom_(uintptr_t *graph, float *x1, float *y1, float *x2, float *y2);\r
-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
+void mgl_title_(uintptr_t *gr, const char *title, const char *stl, mreal *size, int,int);\r
+void mgl_aspect_(uintptr_t *graph, mreal *Ax,mreal *Ay,mreal *Az);\r
+void mgl_rotate_(uintptr_t *graph, mreal *TetX,mreal *TetZ,mreal *TetY);\r
+void mgl_view_(uintptr_t *graph, mreal *TetX,mreal *TetZ,mreal *TetY);\r
+void mgl_zoom_(uintptr_t *graph, mreal *x1, mreal *y1, mreal *x2, mreal *y2);\r
+void mgl_rotate_vector_(uintptr_t *graph, mreal *Tet,mreal *x,mreal *y,mreal *z);\r
+void mgl_perspective_(uintptr_t *graph, mreal val);\r
/*****************************************************************************/\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_qt_run_();\r
/*****************************************************************************/\r
-void mgl_wnd_set_delay(HMGL gr, float dt);\r
+void mgl_wnd_set_delay(HMGL gr, mreal dt);\r
void mgl_setup_window(HMGL gr, int clf_upd, int showpos);\r
void mgl_wnd_toggle_alpha(HMGL gr);\r
void mgl_wnd_toggle_light(HMGL gr);\r
void mgl_wnd_next_frame(HMGL gr);\r
void mgl_wnd_prev_frame(HMGL gr);\r
void mgl_wnd_animation(HMGL gr);\r
-void mgl_get_last_mouse_pos(HMGL gr, float *x, float *y, float *z);\r
+void mgl_get_last_mouse_pos(HMGL gr, mreal *x, mreal *y, mreal *z);\r
/*****************************************************************************/\r
-void mgl_get_last_mouse_pos_(uintptr_t *gr, float *x, float *y, float *z);\r
-void mgl_wnd_set_delay_(uintptr_t *gr, float *dt);\r
+void mgl_get_last_mouse_pos_(uintptr_t *gr, mreal *x, mreal *y, mreal *z);\r
+void mgl_wnd_set_delay_(uintptr_t *gr, mreal *dt);\r
void mgl_setup_window_(uintptr_t *gr, int *clf_upd, int *showpos);\r
void mgl_wnd_toggle_alpha_(uintptr_t *gr);\r
void mgl_wnd_toggle_light_(uintptr_t *gr);\r
#ifndef _MGL_CANVAS_WND_H_\r
#define _MGL_CANVAS_WND_H_\r
/*****************************************************************************/\r
+#include "mgl2/canvas.h"\r
#include "mgl2/window.h"\r
//-----------------------------------------------------------------------------\r
/// Base class for windows containing MathGL graphics\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 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 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
void SetDrawFunc(int (*draw)(mglBase *gr, void *p), void *par=NULL, void (*reload)(void *p)=NULL);\r
\r
private:\r
- int CurFig; ///< Current figure in the list.\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 mgl_text_xy(HMGL gr, HCDT x, HCDT y, const char *text, const char *font, const char *opt);\r
void mgl_text_y(HMGL gr, HCDT y, const char *text, const char *font, const char *opt);\r
\r
-void mgl_cont_gen(HMGL gr, float val, HCDT a, HCDT x, HCDT y, HCDT z, const char *stl);\r
-void mgl_contf_gen(HMGL gr, float v1, float v2, HCDT a, HCDT x, HCDT y, HCDT z, const char *stl);\r
+void mgl_cont_gen(HMGL gr, mreal val, HCDT a, HCDT x, HCDT y, HCDT z, const char *stl);\r
+void mgl_contf_gen(HMGL gr, mreal v1, mreal v2, HCDT a, HCDT x, HCDT y, HCDT z, const char *stl);\r
\r
void mgl_cont_xy_val(HMGL graph, HCDT v, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt);\r
void mgl_cont_val(HMGL graph, HCDT v, HCDT z, const char *sch, const char *opt);\r
\r
void mgl_torus(HMGL graph, HCDT r, HCDT z, const char *col, const char *opt);\r
\r
-void mgl_grid3_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_grid3(HMGL graph, HCDT a, const char *stl, float sVal, const char *opt);\r
+void mgl_grid3_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_grid3(HMGL graph, HCDT a, const char *stl, mreal sVal, const char *opt);\r
\r
-void mgl_dens3_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_dens3(HMGL graph, HCDT a, const char *stl, float sVal, const char *opt);\r
+void mgl_dens3_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_dens3(HMGL graph, HCDT a, const char *stl, mreal sVal, const char *opt);\r
\r
-void mgl_cont3_xyz_val(HMGL graph, HCDT v, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, float sVal, const char *opt);\r
-void mgl_cont3_val(HMGL graph, HCDT v, HCDT a, const char *sch, float sVal, const char *opt);\r
-void mgl_cont3_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, float sVal, const char *opt);\r
-void mgl_cont3(HMGL graph, HCDT a, const char *sch, float sVal, const char *opt);\r
+void mgl_cont3_xyz_val(HMGL graph, HCDT v, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, mreal sVal, const char *opt);\r
+void mgl_cont3_val(HMGL graph, HCDT v, HCDT a, const char *sch, mreal sVal, const char *opt);\r
+void mgl_cont3_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, mreal sVal, const char *opt);\r
+void mgl_cont3(HMGL graph, HCDT a, const char *sch, mreal sVal, const char *opt);\r
\r
-void mgl_contf3_xyz_val(HMGL graph, HCDT v, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, float sVal, const char *opt);\r
-void mgl_contf3_val(HMGL graph, HCDT v, HCDT a, const char *sch, float sVal, const char *opt);\r
-void mgl_contf3_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, float sVal, const char *opt);\r
-void mgl_contf3(HMGL graph, HCDT a, const char *sch, float sVal, const char *opt);\r
+void mgl_contf3_xyz_val(HMGL graph, HCDT v, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, mreal sVal, const char *opt);\r
+void mgl_contf3_val(HMGL graph, HCDT v, HCDT a, const char *sch, mreal sVal, const char *opt);\r
+void mgl_contf3_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, mreal sVal, const char *opt);\r
+void mgl_contf3(HMGL graph, HCDT a, const char *sch, mreal sVal, const char *opt);\r
\r
/*****************************************************************************/\r
void mgl_text_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z,const char *text,const char *font, const char *opt,int,int l,int n);\r
\r
void mgl_torus_(uintptr_t *graph, uintptr_t *r, uintptr_t *z, const char *pen, const char *opt,int,int);\r
\r
-void mgl_grid3_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
-void mgl_grid3_(uintptr_t *graph, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
+void mgl_grid3_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
+void mgl_grid3_(uintptr_t *graph, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
\r
-void mgl_dens3_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
-void mgl_dens3_(uintptr_t *graph, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
+void mgl_dens3_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
+void mgl_dens3_(uintptr_t *graph, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
\r
-void mgl_cont3_xyz_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
-void mgl_cont3_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
-void mgl_cont3_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
-void mgl_cont3_(uintptr_t *graph, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
+void mgl_cont3_xyz_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
+void mgl_cont3_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
+void mgl_cont3_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
+void mgl_cont3_(uintptr_t *graph, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
\r
-void mgl_contf3_xyz_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
-void mgl_contf3_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
-void mgl_contf3_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
-void mgl_contf3_(uintptr_t *graph, uintptr_t *a, const char *sch, float *sVal, const char *opt,int,int);\r
+void mgl_contf3_xyz_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
+void mgl_contf3_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
+void mgl_contf3_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
+void mgl_contf3_(uintptr_t *graph, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int,int);\r
\r
/*****************************************************************************/\r
#ifdef __cplusplus\r
#ifdef __cplusplus\r
//-----------------------------------------------------------------------------\r
#include <vector>\r
+#include <string>\r
//-----------------------------------------------------------------------------\r
/// Class for working with data array\r
+#if MGL_NO_DATA_A\r
+class mglData\r
+#else\r
class mglData : public mglDataA\r
+#endif\r
{\r
public:\r
\r
long ny; ///< number of points in 2nd dimensions ('y' dimension)\r
long nz; ///< number of points in 3d dimensions ('z' dimension)\r
mreal *a; ///< data array\r
- char *id; ///< column (or slice) names\r
+ std::string id; ///< column (or slice) names\r
+// char *id; ///< column (or slice) names\r
bool link; ///< use external data (i.e. don't free it)\r
\r
/// Initiate by other mglData variable\r
inline mglData(const mglData &d) { a=0; mgl_data_set(this,&d); }\r
inline mglData(const mglDataA *d) { a=0; mgl_data_set(this, d); }\r
inline mglData(bool, mglData *d) // NOTE: Variable d will be deleted!!!\r
- { if(d) {memcpy((void*)this,(void*)d,sizeof(mglData)); d->id=0; d->link=true; delete d; }\r
+ { if(d)\r
+ { nx=d->nx; ny=d->ny; nz=d->nz; a=d->a; d->a=0;\r
+ id=d->id; link=d->link; delete d; }\r
else { a=0; Create(1); } }\r
/// Initiate by flat array\r
inline mglData(int size, const float *d) { a=0; Set(d,size); }\r
/// Allocate the memory for data array and initialize it zero\r
inline mglData(long xx=1,long yy=1,long zz=1) { a=0; Create(xx,yy,zz); }\r
/// Delete the array\r
- virtual ~mglData() { if(id && a) delete []id; if(!link && a) delete []a; }\r
+ virtual ~mglData() { if(!link && a) delete []a; }\r
inline mreal GetVal(long i, long j=0, long k=0)\r
{ return mgl_data_get_value(this,i,j,k);}\r
inline void SetVal(mreal f, long i, long j=0, long k=0)\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
{ return mgl_data_fill(this,x1,x2,dir); }\r
+ /// Set the data by triangulated surface values assuming x,y,z in range [r1,r2]\r
+ inline void Grid(mglBase *gr, const mglData &x, const mglData &y, const mglData &z, const char *opt="")\r
+ { mgl_data_grid(gr,this,&x,&y,&z,opt); }\r
/// Put value to data element(s)\r
inline void Put(mreal val, long i=-1, long j=-1, long k=-1)\r
{ mgl_data_put_val(this,val,i,j,k); }\r
inline void SetColumnId(const char *ids)\r
{ mgl_data_set_id(this,ids); }\r
/// Make new id\r
- inline void NewId()\r
- { delete []id; id=new char[nx]; memset(id,0,nx*sizeof(char)); }\r
+ inline void NewId() { id.clear(); }\r
\r
/// Read data from tab-separated text file with auto determining size\r
inline bool Read(const char *fname)\r
inline void PrintInfo(FILE *fp) const\r
{ if(fp) { fprintf(fp,"%s",mgl_data_info(this)); fflush(fp); } }\r
/// Get maximal value of the data\r
- inline float Maximal() const { return mgl_data_max(this); }\r
+ inline mreal Maximal() const { return mgl_data_max(this); }\r
/// Get minimal value of the data\r
- inline float Minimal() const { return mgl_data_min(this); }\r
+ inline mreal Minimal() const { return mgl_data_min(this); }\r
/// Get maximal value of the data and its position\r
inline mreal Maximal(long &i,long &j,long &k) const\r
{ return mgl_data_max_int(this,&i,&j,&k); }\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
+#if MGL_NO_DATA_A\r
+ inline long GetNN() const { return nx*ny*nz; }\r
+#else\r
protected:\r
+#endif\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
#ifdef DEBUG\r
inline mglData mglJacobian(const mglData &x, const mglData &y, const mglData &z)\r
{ return mglData(true, mgl_jacobian_3d(&x, &y, &z)); }\r
/// Do something like Delone triangulation\r
-inline mglData mglTriangulation(const mglData &x, const mglData &y, const mglData &z, float er=0)\r
-{ return mglData(true,mgl_triangulation_3d(&x,&y,&z,er)); }\r
-inline mglData mglTriangulation(const mglData &x, const mglData &y, float er=0)\r
-{ return mglData(true,mgl_triangulation_2d(&x,&y,er)); }\r
+inline mglData mglTriangulation(const mglData &x, const mglData &y, const mglData &z)\r
+{ return mglData(true,mgl_triangulation_3d(&x,&y,&z)); }\r
+inline mglData mglTriangulation(const mglData &x, const mglData &y)\r
+{ return mglData(true,mgl_triangulation_2d(&x,&y)); }\r
//-----------------------------------------------------------------------------\r
#endif\r
#endif\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_value(HMDT dat, mreal v, long i, long j, long k);\r
+mreal 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
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
+void mgl_data_export(HCDT dat, const char *fname, const char *scheme,mreal v1,mreal v2,long ns);\r
+void mgl_data_import(HMDT dat, const char *fname, const char *scheme,mreal v1,mreal 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
+void mgl_data_norm(HMDT dat, mreal v1,mreal v2,long sym,long dim);\r
+void mgl_data_norm_slice(HMDT dat, mreal v1,mreal 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(HMDT dat, mreal x1,mreal 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_grid(HMGL gr, HMDT d, HCDT xdat, HCDT ydat, HCDT zdat,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_max(HCDT dat);\r
+mreal 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
+mreal mgl_data_first(HCDT dat, const char *cond, long *i, long *j, long *k);\r
+mreal 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
+mreal mgl_data_max_int(HCDT dat, long *i, long *j, long *k);\r
+mreal mgl_data_max_real(HCDT dat, mreal *x, mreal *y, mreal *z);\r
+mreal mgl_data_min_int(HCDT dat, long *i, long *j, long *k);\r
+mreal mgl_data_min_real(HCDT dat, mreal *x, mreal *y, mreal *z);\r
+mreal 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
/*****************************************************************************/\r
/* Data manipulation functions */\r
/*****************************************************************************/\r
-void mgl_data_smooth(HMDT d, const char *dirs, float delta);\r
+void mgl_data_smooth(HMDT d, const char *dirs, mreal 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_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
+mreal mgl_data_spline(HCDT dat, mreal x,mreal y,mreal z);\r
+mreal mgl_data_linear(HCDT dat, mreal x,mreal y,mreal 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_resize_box(HCDT dat, long mx,long my,long mz,mreal x1,mreal x2,mreal y1,mreal y2,mreal z1,mreal z2);\r
+HMDT mgl_data_hist(HCDT dat, long n, mreal v1, mreal v2, long nsub);\r
+HMDT mgl_data_hist_w(HCDT dat, HCDT weight, long n, mreal v1, mreal 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_sew(HMDT dat, const char *dirs, mreal da);\r
void mgl_data_crop(HMDT dat, long n1, long n2, char dir);\r
/*****************************************************************************/\r
/* Data operations */\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
+void mgl_data_mul_num(HMDT dat, mreal d);\r
+void mgl_data_div_num(HMDT dat, mreal d);\r
+void mgl_data_add_num(HMDT dat, mreal d);\r
+void mgl_data_sub_num(HMDT dat, mreal 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_pde_solve(HMGL gr, const char *ham, HCDT ini_re, HCDT ini_im, mreal dz, mreal k0,const char *opt);\r
+HMDT mgl_qo2d_solve(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray, mreal r, mreal k0, HMDT xx, HMDT yy);\r
+HMDT mgl_ray_trace(const char *ham, mreal x0, mreal y0, mreal z0, mreal px, mreal py, mreal pz, mreal dt, mreal 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
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
+HMDT mgl_triangulation_3d(HCDT x, HCDT y, HCDT z);\r
+HMDT mgl_triangulation_2d(HCDT x, HCDT y);\r
/*****************************************************************************/\r
/* Data creation functions */\r
/*****************************************************************************/\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_value_(uintptr_t *d, mreal *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
+mreal 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_export_(uintptr_t *dat, const char *fname, const char *scheme,mreal *v1,mreal *v2,int *ns,int,int);\r
+void mgl_data_import_(uintptr_t *dat, const char *fname, const char *scheme,mreal *v1,mreal *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
+void mgl_data_norm_(uintptr_t *dat, mreal *v1,mreal *v2,int *sym,int *dim);\r
+void mgl_data_norm_slice_(uintptr_t *dat, mreal *v1,mreal *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_(uintptr_t *dat, mreal *x1,mreal *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_grid_(uintptr_t *gr, uintptr_t *dat, uintptr_t *xdat, uintptr_t *ydat, uintptr_t *zdat, const char *opt,int);\r
+void mgl_data_put_val_(uintptr_t *dat, mreal *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
+mreal mgl_data_max_(uintptr_t *dat);\r
+mreal 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
+mreal mgl_data_first_(uintptr_t *dat, const char *cond, int *i, int *j, int *k, int);\r
+mreal 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
+mreal mgl_data_max_int_(uintptr_t *dat, int *i, int *j, int *k);\r
+mreal mgl_data_max_real_(uintptr_t *dat, mreal *x, mreal *y, mreal *z);\r
+mreal mgl_data_min_int_(uintptr_t *dat, int *i, int *j, int *k);\r
+mreal mgl_data_min_real_(uintptr_t *dat, mreal *x, mreal *y, mreal *z);\r
+mreal mgl_data_momentum_val_(uintptr_t *dat, char *dir, mreal *m, mreal *w, mreal *s, mreal *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
/*****************************************************************************/\r
/* Data manipulation functions */\r
/*****************************************************************************/\r
-void mgl_data_smooth_(uintptr_t *dat, const char *dirs, float *delta,int);\r
+void mgl_data_smooth_(uintptr_t *dat, const char *dirs, mreal *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_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
+mreal mgl_data_spline_(uintptr_t *dat, mreal *x,mreal *y,mreal *z);\r
+mreal mgl_data_linear_(uintptr_t *dat, mreal *x,mreal *y,mreal *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_resize_box_(uintptr_t *dat, int *mx,int *my,int *mz,mreal *x1,mreal *x2,mreal *y1,mreal *y2,mreal *z1,mreal *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_hist_(uintptr_t *dat, int *n, mreal *v1, mreal *v2, int *nsub);\r
+uintptr_t mgl_data_hist_w_(uintptr_t *dat, uintptr_t *weight, int *n, mreal *v1, mreal *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_sew_(uintptr_t *dat, const char *dirs, mreal *da, int);\r
void mgl_data_crop_(uintptr_t *dat, int *n1, int *n2, const char *dir,int);\r
/*****************************************************************************/\r
/* Data operations */\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
+void mgl_data_mul_num_(uintptr_t *dat, mreal *d);\r
+void mgl_data_div_num_(uintptr_t *dat, mreal *d);\r
+void mgl_data_add_num_(uintptr_t *dat, mreal *d);\r
+void mgl_data_sub_num_(uintptr_t *dat, mreal *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_pde_solve_(uintptr_t* gr, const char *ham, uintptr_t* ini_re, uintptr_t* ini_im, mreal *dz, mreal *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, mreal *r, mreal *k0, uintptr_t* xx, uintptr_t* yy, int);\r
+uintptr_t mgl_ray_trace_(const char *ham, mreal *x0, mreal *y0, mreal *z0, mreal *px, mreal *py, mreal *pz, mreal *dt, mreal *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
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
+uintptr_t mgl_triangulation_3d_(uintptr_t *x, uintptr_t *y, uintptr_t *z);\r
+uintptr_t mgl_triangulation_2d_(uintptr_t *x, uintptr_t *y);\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
#ifndef _MGL_DEFINE_H_\r
#define _MGL_DEFINE_H_\r
//-----------------------------------------------------------------------------\r
+#include "mgl2/config.h"\r
+//-----------------------------------------------------------------------------\r
#ifdef WIN32 //_MSC_VER needs this before math.h\r
#define _USE_MATH_DEFINES\r
#endif\r
\r
+#if MGL_HAVE_ZLIB\r
+#include <zlib.h>\r
+#ifndef Z_BEST_COMPRESSION\r
+#define Z_BEST_COMPRESSION 9\r
+#endif\r
+#else\r
+#define gzFile FILE*\r
+#define gzread(fp,buf,size) fread(buf,1,size,fp)\r
+#define gzopen fopen\r
+#define gzclose fclose\r
+#define gzprintf fprintf\r
+#define gzgets(fp,str,size) fgets(str,size,fp)\r
+#define gzgetc fgetc\r
+#endif\r
+\r
#include <math.h>\r
+#include <stdio.h>\r
#include <stdlib.h>\r
#include <string.h>\r
+#include <wchar.h>\r
+\r
+#if defined(_MSC_VER) || defined(__BORLANDC__)\r
+#define fmin(a,b) ((a)<(b))?(a):(b)\r
+#define fmax(a,b) ((a)>(b))?(a):(b)\r
+#endif\r
\r
-#define MGL_VER2 0.0\r
+#define MGL_VER2 0.3\r
\r
//#ifdef WIN32\r
-#ifdef _MSC_VER\r
+#if defined(_MSC_VER) || defined(__BORLANDC__)\r
#define hypot _hypot\r
#define getcwd _getcwd\r
#define isfinite _finite\r
#define mglprintf swprintf\r
#endif\r
//#define FLT_EPS 1.1920928955078125e-07\r
-#define MGL_FLT_EPS (1.+1e-05)\r
-//-----------------------------------------------------------------------------\r
-#include "mgl2/config.h"\r
//-----------------------------------------------------------------------------\r
#if MGL_USE_DOUBLE\r
typedef double mreal;\r
+#define MGL_EPSILON (1.+1e-10)\r
#else\r
typedef float mreal;\r
+#define MGL_EPSILON (1.+1e-5)\r
#endif\r
//-----------------------------------------------------------------------------\r
#ifndef MGL_CMAP_COLOR\r
// flags for internal use only\r
#define MGL_DISABLE_SCALE 0x000200 ///< Temporary flag for disable scaling (used for axis)\r
#define MGL_FINISHED 0x000400 ///< Flag that final picture (i.e. mglCanvas::G) is ready\r
-//#define MGL_AUTO_CLF 0x000800 ///< Clear canvas between drawing\r
+#define MGL_USE_GMTIME 0x000800 ///< Use gmtime instead of localtime\r
#define MGL_SHOW_POS 0x001000 ///< Switch to show or not mouse click position\r
#define MGL_CLF_ON_UPD 0x002000 ///< Clear plot before Update()\r
-//#define MGL_HIGHLIGHT 0x004000 ///< Highlight plot\r
+#define MGL_NOSUBTICKS 0x004000 ///< Disable subticks drawing (for bounding box)\r
#define MGL_DIFFUSIVE 0x008000 ///< Use diffusive light instead of specular\r
#define MGL_USEDRWDAT 0x010000 ///< Use DrwDat to remember all data of frames\r
#define MGL_REDUCEACC 0x020000 ///< Reduce accuracy of points (to reduc size of output files)\r
+#define MGL_PREFERVC 0x040000 ///< Prefer vertex color instead of texture if output format supports\r
+#define MGL_ONESIDED 0x080000 ///< Render only front side of surfaces if output format supports (for debugging)\r
//-----------------------------------------------------------------------------\r
//#define mgl_realloc(T,o,no,nn) {T *_tmp = new T[nn]; memcpy(_tmp,o,(no)*sizeof(T)); delete []o; o=_tmp;}\r
//-----------------------------------------------------------------------------\r
void *v; // pointer to data/grapher\r
int id; // thread id\r
long n; // total number of iteration\r
- char *s;\r
+ const char *s;\r
};\r
/// Start several thread for the task\r
void mglStartThread(void *(*func)(void *), void (*post)(mglThreadD *,mreal *), long n,\r
mreal *a=0, const mreal *b=0, const mreal *c=0, const long *p=0,\r
- void *v=0, const mreal *d=0, const mreal *e=0, char *s=0);\r
+ void *v=0, const mreal *d=0, const mreal *e=0, const char *s=0);\r
extern int mglNumThr; ///< Number of thread for plotting and data handling\r
//-----------------------------------------------------------------------------\r
extern "C" {\r
#ifdef __cplusplus\r
}\r
#endif\r
+//#if MGL_HAVE_PTHREAD && defined(MGL_SRC)\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
#ifndef _MGL_EVAL_H_\r
#define _MGL_EVAL_H_\r
//---------------------------------------------------------------------------\r
-#include <math.h>\r
#include "mgl2/define.h"\r
/// types of errors\r
#define MGL_ERR_LOG 1\r
* fit.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 *
- * 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. *
- ***************************************************************************/
+ * 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_FIT_H_\r
-#define _MGL_FIT_H_
+#define _MGL_FIT_H_\r
#include "mgl2/base.h"\r
/*****************************************************************************/\r
-#ifdef __cplusplus
+#ifdef __cplusplus\r
extern "C" {\r
#endif\r
-/*****************************************************************************/
-extern int mglFitPnts; ///< Number of output points in fitting
+/*****************************************************************************/\r
+extern int mglFitPnts; ///< Number of output points in fitting\r
extern char mglFitRes[1024]; ///< Last fitted formula\r
HMDT mgl_fit_1(HMGL gr, HCDT y, const char *eq, const char *var, HMDT ini, const char *opt);\r
HMDT mgl_fit_2(HMGL gr, HCDT z, const char *eq, const char *var, HMDT ini, const char *opt);\r
HMDT mgl_fit_xyzas(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, HCDT s, const char *eq, const char *var, HMDT ini, const char *opt);\r
\r
const char *mgl_get_fit(HMGL gr);\r
-
+\r
HMDT mgl_hist_x(HMGL gr, HCDT x, HCDT a, const char *opt);\r
HMDT mgl_hist_xy(HMGL gr, HCDT x, HCDT y, HCDT a, const char *opt);\r
HMDT mgl_hist_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *opt);\r
-
+\r
+void mgl_puts_fit(HMGL gr, mreal x, mreal y, mreal z, const char *prefix, const char *font, mreal size);\r
/*****************************************************************************/\r
uintptr_t mgl_fit_1_(uintptr_t* gr, uintptr_t* y, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
uintptr_t mgl_fit_2_(uintptr_t* gr, uintptr_t* z, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
uintptr_t mgl_fit_xys_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* ss, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
uintptr_t mgl_fit_xyzs_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, uintptr_t* ss, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
uintptr_t mgl_fit_xyzas_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, uintptr_t* a, uintptr_t* ss, const char *eq, const char *var, uintptr_t *ini, const char *opt,int, int l, int n);\r
-
-uintptr_t mgl_hist_x_(uintptr_t* gr, uintptr_t* x, uintptr_t* a, const char *opt,int);
-uintptr_t mgl_hist_xy_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* a, const char *opt,int);
-uintptr_t mgl_hist_xyz_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, uintptr_t* a, const char *opt,int);
+\r
+uintptr_t mgl_hist_x_(uintptr_t* gr, uintptr_t* x, uintptr_t* a, const char *opt,int);\r
+uintptr_t mgl_hist_xy_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* a, const char *opt,int);\r
+uintptr_t mgl_hist_xyz_(uintptr_t* gr, uintptr_t* x, uintptr_t* y, uintptr_t* z, uintptr_t* a, const char *opt,int);\r
+\r
+void mgl_puts_fit_(uintptr_t* gr, mreal *x, mreal *y, mreal *z, const char *prefix, const char *font, mreal *size, int l, int n);\r
/*****************************************************************************/\r
#ifdef __cplusplus\r
}\r
-#endif
+#endif\r
/*****************************************************************************/\r
-#endif
+#endif\r
/// Update (redraw) plot\r
virtual void update();\r
/// Set angles for additional plot rotation\r
- inline void set_angle(float t, float p){ tet = t; phi = p; }\r
+ inline void set_angle(mreal t, mreal p){ tet = t; phi = p; }\r
/// Set bitwise flags for general state (1-Alpha, 2-Light)\r
inline void set_flag(int f) { flag = f; }\r
/// Set flags for handling mouse\r
/// Set drawing functions and its parameter\r
inline void set_draw(int (*func)(mglBase *gr, void *par), void *par=0)\r
{ draw_func = func; draw_par = par; }\r
- inline void set_draw(mglDraw *dr)\r
- { set_draw(mgl_draw_class,(void*)dr); }\r
+ inline void set_draw(mglDraw *dr) { draw_cl = dr; }\r
inline void set_draw(int (*dr)(mglGraph *gr))\r
{ set_draw(mgl_draw_graph,(void*)dr); }\r
void set_state(bool z, bool r) { zoom = z; rotate = r; }\r
/// Set popup menu pointer\r
inline void set_popup(const Fl_Menu_Item *pmenu, Fl_Widget *wdg, void *v)\r
{ popup = pmenu; wpar = wdg; vpar = v; }\r
- inline void zoom_region(float xx1,float xx2,float yy1, float yy2)\r
+ inline void zoom_region(mreal xx1,mreal xx2,mreal yy1, mreal yy2)\r
{ x1=xx1; y1=yy1; x2=xx2; y2=yy2; }\r
\r
protected:\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
+ mglDraw *draw_cl;\r
\r
const Fl_Menu_Item *popup; ///< pointer to popup menu items\r
Fl_Widget *wpar; ///< widget for popup menu\r
- void *vpar; ///< parameter for popup menu\r
- float tet,phi; ///< rotation angles\r
+ void *vpar; ///< parameter for popup menu\r
+ mreal tet,phi; ///< rotation angles\r
bool rotate; ///< flag for handle mouse\r
- bool zoom; ///< flag for zoom by mouse\r
+ bool zoom; ///< flag for zoom by mouse\r
bool wire;\r
- float x1,x2,y1,y2; ///< zoom region\r
- int flag; ///< bitwise flag for general state (1-Alpha, 2-Light)\r
+ mreal x1,x2,y1,y2; ///< zoom region\r
+ int flag; ///< bitwise flag for general state (1-Alpha, 2-Light)\r
int x0,y0,xe,ye; ///< mouse position\r
char pos[128];\r
\r
virtual void draw(); ///< quick drawing function\r
- int handle(int code); ///< handle mouse events\r
+ int handle(int code); ///< handle mouse events\r
void resize(int x, int y, int w, int h); ///< resize control\r
};\r
//-----------------------------------------------------------------------------\r
void *par; ///< Parameter for handling animation\r
void (*next)(void*); ///< Callback function for next frame\r
void (*prev)(void*); ///< Callback function for prev frame\r
- float (*delay)(void*); ///< Callback function for delay\r
+ mreal (*delay)(void*); ///< Callback function for delay\r
void (*reload)(void*); ///< Callback function for reloading\r
\r
void toggle_alpha() { toggle(alpha, alpha_bt, "Graphics/Alpha"); }\r
void toggle_wire() { toggle(wire, wire_bt, "Graphics/Wire"); }\r
void toggle_zoom() { toggle(zoom, zoom_bt); }\r
void toggle_rotate(){ toggle(rotate, rotate_bt); }\r
- void setoff_zoom() { setoff(zoom,zoom_bt); }\r
+ void setoff_zoom() { setoff(zoom, zoom_bt); }\r
void setoff_rotate(){ setoff(rotate, rotate_bt); }\r
bool is_sshow() { return sshow; }\r
\r
#ifndef _MGL_FONT_H_\r
#define _MGL_FONT_H_\r
\r
-#include <stdio.h>\r
#include "mgl2/define.h"\r
//-----------------------------------------------------------------------------\r
#define MGL_FONT_BOLD 0x01000000 // This value is used binary\r
friend void _mgl_key_up(unsigned char ch,int ,int );\r
friend void _mgl_timer(int);\r
public:\r
- float Delay; ///< Delay for animation in seconds\r
+ mreal Delay; ///< Delay for animation in seconds\r
bool AutoClf; ///< Clear canvas between drawing\r
\r
mglCanvasGLUT();\r
#include "mgl2/define.h"\r
#include "mgl2/mgl_cf.h"\r
#include "mgl2/data.h"\r
-#ifndef NO_OPENGL\r
-#include "mgl2/opengl.h"\r
-#endif\r
//-----------------------------------------------------------------------------\r
/// Wrapper class for all graphics\r
class mglGraph\r
inline mglGraph(int kind=0, int width=600, int height=400)\r
{\r
if(kind==-1) gr=NULL;\r
-#ifndef NO_OPENGL\r
- else if(kind==1) gr=mgl_create_graph_gl();\r
+#if MGL_HAVE_OPENGL\r
+ else if(kind==1) gr=mgl_create_graph_gl();\r
#endif\r
-// else if(kind==2) gr=mgl_create_graph_idtf();\r
else gr=mgl_create_graph(width, height);\r
}\r
inline mglGraph(const mglGraph &graph)\r
/// Set the transparency on/off.\r
inline void Alpha(bool enable) { mgl_set_alpha(gr, enable); }\r
/// Set default value of alpha-channel\r
- inline void SetAlphaDef(float alpha) { mgl_set_alpha_default(gr, alpha); }\r
+ inline void SetAlphaDef(mreal alpha) { mgl_set_alpha_default(gr, alpha); }\r
/// Set the transparency type (0 - usual, 1 - glass, 2 - lamp)\r
inline void SetTranspType(int type) { mgl_set_transp_type(gr, type);}\r
\r
/// Use diffusive light (only for local light sources)\r
inline void SetDifLight(bool dif) { mgl_set_light_dif(gr, dif); }\r
/// Add a light source.\r
- inline void AddLight(int n, mglPoint p, char col='w', float bright=0.5, float ap=0)\r
+ inline void AddLight(int n, mglPoint p, char col='w', mreal bright=0.5, mreal ap=0)\r
{ mgl_add_light_ext(gr, n, p.x, p.y, p.z, col, bright, ap); }\r
- inline void AddLight(int n, mglPoint r, mglPoint p, char col='w', float bright=0.5, float ap=0)\r
+ inline void AddLight(int n, mglPoint r, mglPoint p, char col='w', mreal bright=0.5, mreal ap=0)\r
{ mgl_add_light_loc(gr, n, r.x, r.y, r.z, p.x, p.y, p.z, col, bright, ap); }\r
/// Set ambient light brightness\r
- inline void SetAmbient(float i) { mgl_set_ambbr(gr, i); }\r
+ inline void SetAmbient(mreal i) { mgl_set_ambbr(gr, i); }\r
/// Set the fog distance or switch it off (if d=0).\r
- inline void Fog(float d, float dz=0.25) { mgl_set_fog(gr, d, dz); }\r
+ inline void Fog(mreal d, mreal dz=0.25) { mgl_set_fog(gr, d, dz); }\r
\r
/// Set relative width of rectangles in Bars, Barh, BoxPlot\r
- inline void SetBarWidth(float width) { mgl_set_bar_width(gr, width); }\r
+ inline void SetBarWidth(mreal width) { mgl_set_bar_width(gr, width); }\r
/// Set size of marks\r
- inline void SetMarkSize(float size) { mgl_set_mark_size(gr, size); }\r
+ inline void SetMarkSize(mreal size) { mgl_set_mark_size(gr, size); }\r
/// Set size of arrows\r
- inline void SetArrowSize(float size) { mgl_set_arrow_size(gr, size); }\r
+ inline void SetArrowSize(mreal size) { mgl_set_arrow_size(gr, size); }\r
/// Set number of mesh lines\r
inline void SetMeshNum(int num) { mgl_set_meshnum(gr, num); }\r
\r
inline void CutOff(const char *EqC) { mgl_set_cutoff(gr, EqC); }\r
\r
/// Set default font size\r
- inline void SetFontSize(float size) { mgl_set_font_size(gr, size); }\r
+ inline void SetFontSize(mreal size) { mgl_set_font_size(gr, size); }\r
/// Set default font style and color\r
inline void SetFontDef(const char *fnt) { mgl_set_font_def(gr, fnt); }\r
/// Set FontSize by size in pt and picture DPI (default is 16 pt for dpi=72)\r
- virtual void SetFontSizePT(float pt, int dpi=72){ SetFontSize(pt*27.f/dpi); }\r
+ virtual void SetFontSizePT(mreal pt, int dpi=72){ SetFontSize(pt*27.f/dpi); }\r
/// Set FontSize by size in centimeters and picture DPI (default is 0.56 cm = 16 pt)\r
- inline void SetFontSizeCM(float cm, int dpi=72) { SetFontSizePT(cm*28.45f,dpi); }\r
+ inline void SetFontSizeCM(mreal cm, int dpi=72) { SetFontSizePT(cm*28.45f,dpi); }\r
/// Set FontSize by size in inch and picture DPI (default is 0.22 in = 16 pt)\r
- inline void SetFontSizeIN(float in, int dpi=72) { SetFontSizePT(in*72.27f,dpi); }\r
+ inline void SetFontSizeIN(mreal in, int dpi=72) { SetFontSizePT(in*72.27f,dpi); }\r
/// Load font from file\r
inline void LoadFont(const char *name, const char *path=NULL)\r
{ mgl_load_font(gr, name, path); }\r
/// Get last warning code\r
inline int GetWarn() { return mgl_get_warn(gr);}\r
/// Set warning code ant fill message\r
- inline void SetWarn(int code, const char *info="") { mgl_set_warn(gr,code,info); }\r
+ inline void SetWarn(int code, const char *info) { mgl_set_warn(gr,code,info); }\r
/// Set buffer for warning messages\r
inline const char *Message() { return mgl_get_mess(gr); }\r
\r
/// Set range in direction dir as [v1, v2]\r
- inline void SetRange(char dir, float v1, float v2)\r
+ inline void SetRange(char dir, mreal v1, mreal v2)\r
{ mgl_set_range_val(gr, dir, v1, v2); }\r
/// Set range in direction dir as minimal and maximal values of data a\r
inline void SetRange(char dir, const mglDataA &dat, bool add=false)\r
{ mgl_set_range_dat(gr, dir, &dat, add); }\r
/// Set values of mglGraph::Min and mglGraph::Max as minimal and maximal values of datas\r
- inline void SetRanges(const mglData &xx, const mglData &yy, const mglData &zz, const mglData &cc)\r
+ inline void SetRanges(const mglDataA &xx, const mglDataA &yy, const mglDataA &zz, const mglDataA &cc)\r
{ mgl_set_range_dat(gr,'x',&xx,0); mgl_set_range_dat(gr,'y',&yy,0);\r
mgl_set_range_dat(gr,'z',&zz,0); mgl_set_range_dat(gr,'c',&cc,0); }\r
/// Set values of mglGraph::Min and mglGraph::Max as minimal and maximal values of datas\r
- inline void SetRanges(const mglData &xx, const mglData &yy, const mglData &zz)\r
+ inline void SetRanges(const mglDataA &xx, const mglDataA &yy, const mglDataA &zz)\r
{ mgl_set_range_dat(gr,'x',&xx,0); mgl_set_range_dat(gr,'y',&yy,0);\r
mgl_set_range_dat(gr,'z',&zz,0); mgl_set_range_dat(gr,'c',&zz,0); }\r
/// Set values of mglGraph::Min and mglGraph::Max as minimal and maximal values of datas\r
- inline void SetRanges(const mglData &xx, const mglData &yy)\r
+ inline void SetRanges(const mglDataA &xx, const mglDataA &yy)\r
{ mgl_set_range_dat(gr,'x',&xx,0); mgl_set_range_dat(gr,'y',&yy,0); }\r
/// Set values of mglGraph::Min and mglGraph::Max\r
- inline void SetRanges(float x1, float x2, float y1, float y2, float z1=0, float z2=0)\r
+ inline void SetRanges(mreal x1, mreal x2, mreal y1, mreal y2, mreal z1=0, mreal z2=0)\r
{ mgl_set_ranges(gr, x1, x2, y1, y2, z1, z2); }\r
/// Set values of mglGraph::Min and mglGraph::Max\r
inline void SetRanges(mglPoint p1, mglPoint p2)\r
/// Set axis origin\r
inline void SetOrigin(mglPoint p)\r
{ mgl_set_origin(gr, p.x, p.y, p.z); }\r
- inline void SetOrigin(float x0, float y0, float z0=NaN)\r
+ inline void SetOrigin(mreal x0, mreal y0, mreal z0=NaN)\r
{ mgl_set_origin(gr, x0, y0, z0); }\r
\r
/// Set the transformation formulas for coordinate\r
/// Set to use or not tick labels skipping\r
inline void SetTickSkip(bool val) { mgl_set_tick_skip(gr,val); }\r
/// Set tick length\r
- inline void SetTickLen(float len, float stt=1)\r
+ inline void SetTickLen(mreal len, mreal stt=1)\r
{ mgl_set_tick_len(gr, len, stt); }\r
/// Set axis and ticks style\r
inline void SetAxisStl(const char *stl="k", const char *tck=0, const char *sub=0)\r
{ mgl_set_axis_stl(gr, stl, tck, sub); }\r
\r
/// Set time templates for ticks\r
- inline void SetTicksTime(char dir, float d=0, const char *t="")\r
+ inline void SetTicksTime(char dir, mreal d=0, const char *t="")\r
{ mgl_set_ticks_time(gr,dir,d,t); }\r
/// Set ticks text (\n separated). Use "" to disable this feature.\r
inline void SetTicksVal(char dir, const char *lbl, bool add=false)\r
inline void SetTicksVal(char dir, const mglDataA &v, const wchar_t *lbl, bool add=false)\r
{ mgl_set_ticks_valw(gr,dir,&v,lbl,add); }\r
/// Set the ticks parameters\r
- inline void SetTicks(char dir, float d=0, int ns=0, float org=NaN)\r
+ inline void SetTicks(char dir, mreal d=0, int ns=0, mreal org=NaN)\r
{ mgl_set_ticks(gr, dir, d, ns, org); }\r
/// Auto adjust ticks\r
inline void Adjust(const char *dir="xyzc")\r
inline void SetTickTempl(char dir, const wchar_t *t)\r
{ mgl_set_tick_templw(gr,dir,t); }\r
/// Tune ticks\r
- inline void SetTuneTicks(int tune, float fact_pos=1.15)\r
+ inline void SetTuneTicks(int tune, mreal fact_pos=1.15)\r
{ mgl_tune_ticks(gr, tune, fact_pos); }\r
-\r
+ /// Set additional shift of tick labels\r
+ inline void SetTickShift(mglPoint p)\r
+ { mgl_set_tick_shift(gr,p.x,p.y,p.z,p.c); }\r
+ /// Set to use UTC time instead of local time\r
+ inline void SetTimeUTC(bool enable)\r
+ { mgl_set_flag(gr,enable, MGL_USE_GMTIME); }\r
+ \r
/// Put further plotting in some region of whole frame surface.\r
- inline void SubPlot(int nx,int ny,int m,const char *style="<>_^", float dx=0, float dy=0)\r
+ inline void SubPlot(int nx,int ny,int m,const char *style="<>_^", mreal dx=0, mreal dy=0)\r
{ mgl_subplot_d(gr, nx, ny, m, style, dx, dy); }\r
/// Like SubPlot bot "join" several cells\r
inline void MultiPlot(int nx,int ny,int m, int dx, int dy, const char *style="<>_^")\r
{ mgl_multiplot(gr, nx, ny, m, dx, dy, style); }\r
/// Put further plotting in some region of whole frame surface.\r
- inline void InPlot(float x1,float x2,float y1,float y2, bool rel=true)\r
+ inline void InPlot(mreal x1,mreal x2,mreal y1,mreal y2, bool rel=true)\r
{ if(rel) mgl_relplot(gr, x1, x2, y1, y2);\r
else mgl_inplot(gr, x1, x2, y1, y2); }\r
/// Put further plotting in column cell of previous subplot\r
- inline void ColumnPlot(int num, int ind, float d=0)\r
+ inline void ColumnPlot(int num, int ind, mreal d=0)\r
{ mgl_columnplot(gr,num,ind,d); }\r
/// Put further plotting in matrix cell of previous subplot\r
- inline void GridPlot(int nx, int ny, int ind, float d=0)\r
+ inline void GridPlot(int nx, int ny, int ind, mreal d=0)\r
{ mgl_gridplot(gr,nx,ny,ind,d); }\r
/// Put further plotting in cell of stick rotated on angles tet, phi\r
- inline void StickPlot(int num, int i, float tet, float phi)\r
+ inline void StickPlot(int num, int i, mreal tet, mreal phi)\r
{ mgl_stickplot(gr,num,i,tet,phi); }\r
\r
/// Set PlotFactor\r
- inline void SetPlotFactor(float val)\r
+ inline void SetPlotFactor(mreal val)\r
{ mgl_set_plotfactor(gr,val); }\r
/// Push transformation matrix into stack\r
inline void Push() { mgl_mat_push(gr); }\r
inline void Pop() { mgl_mat_pop(gr); }\r
\r
/// Add title for current subplot/inplot\r
- inline void Title(const char *title,const char *stl="",float size=-2)\r
+ inline void Title(const char *title,const char *stl="",mreal size=-2)\r
{ mgl_title(gr,title,stl,size); }\r
- inline void Title(const wchar_t *title,const char *stl="",float size=-2)\r
+ inline void Title(const wchar_t *title,const char *stl="",mreal size=-2)\r
{ mgl_titlew(gr,title,stl,size); }\r
/// Set aspect ratio for further plotting.\r
- inline void Aspect(float Ax,float Ay,float Az=1)\r
+ inline void Aspect(mreal Ax,mreal Ay,mreal Az=1)\r
{ mgl_aspect(gr, Ax, Ay, Az); }\r
/// Rotate a further plotting.\r
- inline void Rotate(float TetX,float TetZ=0,float TetY=0)\r
+ inline void Rotate(mreal TetX,mreal TetZ=0,mreal TetY=0)\r
{ mgl_rotate(gr, TetX, TetZ, TetY); }\r
/// Rotate a further plotting around vector {x,y,z}.\r
- inline void RotateN(float Tet,float x,float y,float z)\r
+ inline void RotateN(mreal Tet,mreal x,mreal y,mreal z)\r
{ mgl_rotate_vector(gr, Tet, x, y, z); }\r
/// Set perspective (in range [0,1)) for plot. Set to zero for switching off.\r
- inline void Perspective(float val)\r
+ inline void Perspective(mreal val)\r
{ mgl_perspective(gr, val); }\r
/// Set angle of view independently from Rotate().\r
- inline void View(float TetX,float TetZ=0,float TetY=0)\r
+ inline void View(mreal TetX,mreal TetZ=0,mreal TetY=0)\r
{ mgl_view(gr, TetX, TetZ, TetY); }\r
/// Zoom in or zoom out (if Zoom(0, 0, 1, 1)) a part of picture\r
- inline void Zoom(float x1, float y1, float x2, float y2)\r
+ inline void Zoom(mreal x1, mreal y1, mreal x2, mreal y2)\r
{ mgl_zoom(gr, x1, y1, x2, y2); }\r
\r
/// Set size of frame in pixels. Normally this function is called internaly.\r
/// Write the frame in file using PostScript format\r
inline void WriteEPS(const char *fname,const char *descr="")\r
{ mgl_write_eps(gr, fname, descr); }\r
- /// Write the frame in file using PostScript format\r
+ /// Write the frame in file using LaTeX format\r
inline void WriteTEX(const char *fname,const char *descr="")\r
{ mgl_write_tex(gr, fname, descr); }\r
/// Write the frame in file using PostScript format as bitmap\r
/// Calculate 3D coordinate {x,y,z} for screen point {xs,ys}\r
inline mglPoint CalcXYZ(int xs, int ys)\r
{\r
- float x,y,z;\r
+ mreal x,y,z;\r
mgl_calc_xyz(gr,xs,ys,&x,&y,&z);\r
return mglPoint(x,y,z);\r
}\r
inline void MPI_Recv(int id) { mgl_mpi_recv(gr,id); }\r
\r
/// Clear up the frame\r
- inline void Clf(float r, float g, float b) { mgl_clf_rgb(gr, r, g, b); }\r
+ inline void Clf(mreal r, mreal g, mreal b) { mgl_clf_rgb(gr, r, g, b); }\r
inline void Clf() { mgl_clf(gr); }\r
/// Draws the point (ball) at position {x,y,z} with color c\r
inline void Ball(mglPoint p, char c)\r
inline void Face(mglPoint p1, mglPoint p2, mglPoint p3, mglPoint p4, const char *stl="r")\r
{ mgl_face(gr, p1.x, p1.y, p1.z, p2.x, p2.y, p2.z, p3.x, p3.y, p3.z, p4.x, p4.y, p4.z, stl); }\r
/// Draws the face in y-z plane at point p with color stl (include interpolation up to 4 colors).\r
- inline void FaceX(mglPoint p, float wy, float wz, const char *stl="w", float dx=0, float dy=0)\r
+ inline void FaceX(mglPoint p, mreal wy, mreal wz, const char *stl="w", mreal dx=0, mreal dy=0)\r
{ mgl_facex(gr, p.x, p.y, p.z, wy, wz, stl, dx, dy); }\r
/// Draws the face in x-z plane at point p with color stl (include interpolation up to 4 colors).\r
- inline void FaceY(mglPoint p, float wx, float wz, const char *stl="w", float dx=0, float dy=0)\r
+ inline void FaceY(mglPoint p, mreal wx, mreal wz, const char *stl="w", mreal dx=0, mreal dy=0)\r
{ mgl_facey(gr, p.x, p.y, p.z, wx, wz, stl, dx, dy); }\r
/// Draws the face in x-y plane at point p with color stl (include interpolation up to 4 colors).\r
- inline void FaceZ(mglPoint p, float wx, float wy, const char *stl="w", float dx=0, float dy=0)\r
+ inline void FaceZ(mglPoint p, mreal wx, mreal wy, const char *stl="w", mreal dx=0, mreal dy=0)\r
{ mgl_facez(gr, p.x, p.y, p.z, wx, wy, stl, dx, dy); }\r
/// Draws the drop at point p in direction d with color col and radius r\r
- inline void Drop(mglPoint p, mglPoint d, float r, const char *col="r", float shift=1, float ap=1)\r
+ inline void Drop(mglPoint p, mglPoint d, mreal r, const char *col="r", mreal shift=1, mreal ap=1)\r
{ mgl_drop(gr, p.x, p.y, p.z, d.x, d.y, d.z, r, col, shift, ap); }\r
/// Draws the sphere at point p with color col and radius r\r
- inline void Sphere(mglPoint p, float r, const char *col="r")\r
+ inline void Sphere(mglPoint p, mreal r, const char *col="r")\r
{ mgl_sphere(gr, p.x, p.y, p.z, r, col); }\r
/// Draws the cone between points p1,p2 with radius r1,r2 with style stl\r
- inline void Cone(mglPoint p1, mglPoint p2, float r1, float r2=-1, const char *stl="r@")\r
+ inline void Cone(mglPoint p1, mglPoint p2, mreal r1, mreal r2=-1, const char *stl="r@")\r
{ mgl_cone(gr, p1.x, p1.y, p1.z, p2.x, p2.y, p2.z,r1,r2,stl); }\r
/// Draws the ellipse between points p1,p2 with color stl and width r\r
- inline void Ellipse(mglPoint p1, mglPoint p2, float r, const char *stl="r")\r
+ inline void Ellipse(mglPoint p1, mglPoint p2, mreal r, const char *stl="r")\r
{ mgl_ellipse(gr, p1.x, p1.y, p1.z, p2.x, p2.y, p2.z, r,stl); }\r
/// Draws the circle at point p with color stl and radius r\r
- inline void Circle(mglPoint p, float r, const char *stl="r")\r
+ inline void Circle(mglPoint p, mreal r, const char *stl="r")\r
{ mgl_ellipse(gr, p.x, p.y, p.z, p.x, p.y, p.z, r,stl); }\r
/// Draws the rhomb between points p1,p2 with color stl and width r\r
- inline void Rhomb(mglPoint p1, mglPoint p2, float r, const char *stl="r")\r
+ inline void Rhomb(mglPoint p1, mglPoint p2, mreal r, const char *stl="r")\r
{ mgl_rhomb(gr, p1.x, p1.y, p1.z, p2.x, p2.y, p2.z, r,stl); }\r
\r
/// Print text in position p with specified font\r
- inline void Putsw(mglPoint p,const wchar_t *text,const char *font=":C",float size=-1)\r
+ inline void Putsw(mglPoint p,const wchar_t *text,const char *font=":C",mreal size=-1)\r
{ mgl_putsw(gr, p.x, p.y, p.z, text, font, size); }\r
- inline void Puts(mglPoint p,const char *text,const char *font=":C",float size=-1)\r
+ inline void Puts(mglPoint p,const char *text,const char *font=":C",mreal size=-1)\r
{ mgl_puts(gr, p.x, p.y, p.z, text, font, size); }\r
- inline void Putsw(float x, float y,const wchar_t *text,const char *font=":AC",float size=-1)\r
+ inline void Putsw(mreal x, mreal y,const wchar_t *text,const char *font=":AC",mreal size=-1)\r
{ mgl_putsw(gr, x, y, 0, text, font, size); }\r
- inline void Puts(float x, float y,const char *text,const char *font=":AC",float size=-1)\r
+ inline void Puts(mreal x, mreal y,const char *text,const char *font=":AC",mreal size=-1)\r
{ mgl_puts(gr, x, y, 0, text, font, size); }\r
/// Print text in position p along direction d with specified font\r
- inline void Putsw(mglPoint p, mglPoint d, const wchar_t *text, const char *font=":L", float size=-1)\r
+ inline void Putsw(mglPoint p, mglPoint d, const wchar_t *text, const char *font=":L", mreal size=-1)\r
{ mgl_putsw_dir(gr, p.x, p.y, p.z, d.x, d.y, d.z, text, font, size); }\r
- inline void Puts(mglPoint p, mglPoint d, const char *text, const char *font=":L", float size=-1)\r
+ inline void Puts(mglPoint p, mglPoint d, const char *text, const char *font=":L", mreal size=-1)\r
{ mgl_puts_dir(gr, p.x, p.y, p.z, d.x, d.y, d.z, text, font, size); }\r
\r
/// Print text along the curve\r
inline void Grid(const char *dir="xyzt",const char *pen="B")\r
{ mgl_axis_grid(gr, dir, pen); }\r
/// Print the label \a text for axis \a dir.\r
- inline void Label(char dir, const char *text, float pos=+1, float shift=0)\r
+ inline void Label(char dir, const char *text, mreal pos=+1, mreal shift=0)\r
{ mgl_label_ext(gr, dir, text, pos, shift); }\r
- inline void Label(char dir, const wchar_t *text, float pos=+1, float shift=0)\r
+ inline void Label(char dir, const wchar_t *text, mreal pos=+1, mreal shift=0)\r
{ mgl_labelw_ext(gr, dir, text, pos, shift); }\r
\r
/// Draw colorbar at edge of axis\r
inline void Colorbar(const char *sch="")\r
{ mgl_colorbar(gr, sch); }\r
- inline void Colorbar(const char *sch,float x,float y,float w=1,float h=1)\r
+ inline void Colorbar(const char *sch,mreal x,mreal y,mreal w=1,mreal h=1)\r
{ mgl_colorbar_ext(gr, sch, x,y,w,h); }\r
/// Draw colorbar with manual colors at edge of axis\r
inline void Colorbar(const mglDataA &val, const char *sch="")\r
{ mgl_colorbar_val(gr, &val, sch); }\r
- inline void Colorbar(const mglDataA &val, const char *sch,float x,float y,float w=1,float h=1)\r
+ inline void Colorbar(const mglDataA &val, const char *sch,mreal x,mreal y,mreal w=1,mreal h=1)\r
{ mgl_colorbar_val_ext(gr, &val, sch, x,y,w,h); }\r
\r
/// Add string to legend\r
inline void ClearLegend()\r
{ mgl_clear_legend(gr); }\r
/// Draw legend of accumulated strings at position {x,y}\r
- inline void Legend(float x, float y, const char *font="#", float size=-0.8, float llen=0)\r
+ inline void Legend(mreal x, mreal y, const char *font="#", mreal size=-0.8, mreal llen=0)\r
{ mgl_legend_pos(gr, x, y, font, size, llen); }\r
/// Draw legend of accumulated strings\r
- inline void Legend(int where=3, const char *font="#", float size=-0.8, float llen=0)\r
+ inline void Legend(int where=3, const char *font="#", mreal size=-0.8, mreal llen=0)\r
{ mgl_legend(gr, where, font, size, llen); }\r
/// Set number of marks in legend sample\r
inline void SetLegendMarks(int num) { mgl_set_legend_marks(gr, num); }\r
/// Draw tube with radius r for points in arrays {x,y,z}\r
inline void Tube(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &r, const char *pen="", const char *opt="")\r
{ mgl_tube_xyzr(gr, &x, &y, &z, &r, pen, opt); }\r
- inline void Tube(const mglDataA &x, const mglDataA &y, const mglDataA &z, float r, const char *pen="", const char *opt="")\r
+ inline void Tube(const mglDataA &x, const mglDataA &y, const mglDataA &z, mreal r, const char *pen="", const char *opt="")\r
{ mgl_tube_xyz(gr, &x, &y, &z, r, pen, opt); }\r
inline void Tube(const mglDataA &x, const mglDataA &y, const mglDataA &r, const char *pen="", const char *opt="")\r
{ mgl_tube_xyr(gr, &x, &y, &r, pen, opt); }\r
- inline void Tube(const mglDataA &x, const mglDataA &y, float r, const char *pen="", const char *opt="")\r
+ inline void Tube(const mglDataA &x, const mglDataA &y, mreal r, const char *pen="", const char *opt="")\r
{ mgl_tube_xy(gr, &x, &y, r, pen, opt); }\r
inline void Tube(const mglDataA &y, const mglDataA &r, const char *pen="", const char *opt="")\r
{ mgl_tube_r(gr, &y, &r, pen, opt); }\r
- inline void Tube(const mglDataA &y, float r, const char *pen="", const char *opt="")\r
+ inline void Tube(const mglDataA &y, mreal r, const char *pen="", const char *opt="")\r
{ mgl_tube(gr, &y, r, pen, opt); }\r
/// Draw surface of curve {r,z} rotatation around axis\r
inline void Torus(const mglDataA &r, const mglDataA &z, const char *pen="", const char *opt="")\r
{ mgl_axial(gr, &z, sch, opt); }\r
\r
/// Draw grid lines for density plot at slice for 3d data specified parametrically\r
- inline void Grid3(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *stl="", float sVal=-1, const char *opt="")\r
+ inline void Grid3(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *stl="", mreal sVal=-1, const char *opt="")\r
{ mgl_grid3_xyz(gr, &x, &y, &z, &a, stl, sVal, opt); }\r
- inline void Grid3(const mglDataA &a, const char *stl="", float sVal=-1, const char *opt="")\r
+ inline void Grid3(const mglDataA &a, const char *stl="", mreal sVal=-1, const char *opt="")\r
{ mgl_grid3(gr, &a, stl, sVal, opt); }\r
/// Draw density plot at slice for 3d data specified parametrically\r
- inline void Dens3(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *stl="", float sVal=-1, const char *opt="")\r
+ inline void Dens3(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *stl="", mreal sVal=-1, const char *opt="")\r
{ mgl_dens3_xyz(gr, &x, &y, &z, &a, stl, sVal, opt); }\r
- inline void Dens3(const mglDataA &a, const char *stl="", float sVal=-1, const char *opt="")\r
+ inline void Dens3(const mglDataA &a, const char *stl="", mreal sVal=-1, const char *opt="")\r
{ mgl_dens3(gr, &a, stl, sVal, opt); }\r
\r
/// Draw isosurface(s) for 3d data specified parametrically\r
- inline void Surf3(float Val, const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *stl="", const char *opt="")\r
+ inline void Surf3(mreal Val, const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *stl="", const char *opt="")\r
{ mgl_surf3_xyz_val(gr, Val, &x, &y, &z, &a, stl, opt); }\r
- inline void Surf3(float Val, const mglDataA &a, const char *stl="", const char *opt="")\r
+ inline void Surf3(mreal Val, const mglDataA &a, const char *stl="", const char *opt="")\r
{ mgl_surf3_val(gr, Val, &a, stl, opt); }\r
inline void Surf3(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *stl="", const char *opt="")\r
{ mgl_surf3_xyz(gr, &x, &y, &z, &a, stl, opt); }\r
{ mgl_cloud(gr, &a, stl, opt); }\r
\r
/// Draw contour lines at slice for 3d data specified parametrically\r
- inline void Cont3(const mglDataA &v, const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *sch="", float sVal=-1, const char *opt="")\r
+ inline void Cont3(const mglDataA &v, const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *sch="", mreal sVal=-1, const char *opt="")\r
{ mgl_cont3_xyz_val(gr, &v, &x, &y, &z, &a, sch, sVal, opt); }\r
- inline void Cont3(const mglDataA &v, const mglDataA &a, const char *sch="", float sVal=-1, const char *opt="")\r
+ inline void Cont3(const mglDataA &v, const mglDataA &a, const char *sch="", mreal sVal=-1, const char *opt="")\r
{ mgl_cont3_val(gr, &v, &a, sch, sVal, opt); }\r
- inline void Cont3(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *sch="", float sVal=-1, const char *opt="")\r
+ inline void Cont3(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *sch="", mreal sVal=-1, const char *opt="")\r
{ mgl_cont3_xyz(gr, &x, &y, &z, &a, sch, sVal, opt); }\r
- inline void Cont3(const mglDataA &a, const char *sch="", float sVal=-1, const char *opt="")\r
+ inline void Cont3(const mglDataA &a, const char *sch="", mreal sVal=-1, const char *opt="")\r
{ mgl_cont3(gr, &a, sch, sVal, opt); }\r
\r
/// Draw solid contours at slice for 3d data specified parametrically\r
- inline void ContF3(const mglDataA &v, const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *sch="", float sVal=-1, const char *opt="")\r
+ inline void ContF3(const mglDataA &v, const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *sch="", mreal sVal=-1, const char *opt="")\r
{ mgl_contf3_xyz_val(gr, &v, &x, &y, &z, &a, sch, sVal, opt); }\r
- inline void ContF3(const mglDataA &v, const mglDataA &a, const char *sch="", float sVal=-1, const char *opt="")\r
+ inline void ContF3(const mglDataA &v, const mglDataA &a, const char *sch="", mreal sVal=-1, const char *opt="")\r
{ mgl_contf3_val(gr, &v, &a, sch, sVal, opt); }\r
- inline void ContF3(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *sch="", float sVal=-1, const char *opt="")\r
+ inline void ContF3(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const char *sch="", mreal sVal=-1, const char *opt="")\r
{ mgl_contf3_xyz(gr, &x, &y, &z, &a, sch, sVal, opt); }\r
- inline void ContF3(const mglDataA &a, const char *sch="", float sVal=-1, const char *opt="")\r
+ inline void ContF3(const mglDataA &a, const char *sch="", mreal sVal=-1, const char *opt="")\r
{ mgl_contf3(gr, &a, sch, sVal, opt); }\r
\r
/// Draw several isosurfaces for 3d beam in curvilinear coordinates\r
- inline void Beam(const mglDataA &tr, const mglDataA &g1, const mglDataA &g2, const mglDataA &a, float r, const char *stl=0, int flag=0, int num=3)\r
+ inline void Beam(const mglDataA &tr, const mglDataA &g1, const mglDataA &g2, const mglDataA &a, mreal r, const char *stl=0, int flag=0, int num=3)\r
{ mgl_beam(gr, &tr,&g1,&g2,&a,r,stl,flag,num); }\r
- inline void Beam(float val, const mglDataA &tr, const mglDataA &g1, const mglDataA &g2, const mglDataA &a, float r, const char *stl=NULL, int flag=0)\r
+ inline void Beam(mreal val, const mglDataA &tr, const mglDataA &g1, const mglDataA &g2, const mglDataA &a, mreal r, const char *stl=NULL, int flag=0)\r
{ mgl_beam_val(gr,val,&tr,&g1,&g2,&a,r,stl,flag); }\r
\r
/// Draw vertical tiles with variable size for 2d data specified parametrically\r
{ mgl_stfa(gr, &re, &im, dn, sch, opt); }\r
\r
/// Draw isosurface(s) for 3d data specified parametrically with alpha proportional to b\r
- inline void Surf3A(float Val, const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const mglDataA &b, const char *stl="", const char *opt="")\r
+ inline void Surf3A(mreal Val, const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const mglDataA &b, const char *stl="", const char *opt="")\r
{ mgl_surf3a_xyz_val(gr, Val, &x, &y, &z, &a, &b, stl, opt); }\r
- inline void Surf3A(float Val, const mglDataA &a, const mglDataA &b, const char *stl="", const char *opt="")\r
+ inline void Surf3A(mreal Val, const mglDataA &a, const mglDataA &b, const char *stl="", const char *opt="")\r
{ mgl_surf3a_val(gr, Val, &a, &b, stl, opt); }\r
inline void Surf3A(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const mglDataA &b, const char *stl="", const char *opt="")\r
{ mgl_surf3a_xyz(gr, &x, &y, &z, &a, &b, stl, opt); }\r
inline void Surf3A(const mglDataA &a, const mglDataA &b, const char *stl="", const char *opt="")\r
{ mgl_surf3a(gr, &a, &b, stl, opt); }\r
/// Draw isosurface(s) for 3d data specified parametrically with color proportional to b\r
- inline void Surf3C(float Val, const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const mglDataA &b, const char *stl="", const char *opt="")\r
+ inline void Surf3C(mreal Val, const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const mglDataA &b, const char *stl="", const char *opt="")\r
{ mgl_surf3c_xyz_val(gr, Val, &x, &y, &z, &a, &b, stl,opt); }\r
- inline void Surf3C(float Val, const mglDataA &a, const mglDataA &b, const char *stl="", const char *opt="")\r
+ inline void Surf3C(mreal Val, const mglDataA &a, const mglDataA &b, const char *stl="", const char *opt="")\r
{ mgl_surf3c_val(gr, Val, &a, &b, stl, opt); }\r
inline void Surf3C(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const mglDataA &b, const char *stl="", const char *opt="")\r
{ mgl_surf3c_xyz(gr, &x, &y, &z, &a, &b, stl, opt); }\r
{ mgl_grad(gr,&phi,sch,opt); }\r
\r
/// Plot flow pipes for vector field {ax,ay,ay} parametrically depended on coordinate {x,y,z} with color proportional to |a|\r
- inline void Pipe(const mglDataA &x, const mglDataA &y, const mglDataA &ax, const mglDataA &ay, const char *sch="", float r0=0.05, const char *opt="")\r
+ inline void Pipe(const mglDataA &x, const mglDataA &y, const mglDataA &ax, const mglDataA &ay, const char *sch="", mreal r0=0.05, const char *opt="")\r
{ mgl_pipe_xy(gr, &x, &y, &ax, &ay, sch, r0, opt); }\r
- inline void Pipe(const mglDataA &ax, const mglDataA &ay, const char *sch="", float r0=0.05, const char *opt="")\r
+ inline void Pipe(const mglDataA &ax, const mglDataA &ay, const char *sch="", mreal r0=0.05, const char *opt="")\r
{ mgl_pipe_2d(gr, &ax, &ay, sch, r0, opt); }\r
- inline void Pipe(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &ax, const mglDataA &ay, const mglDataA &az, const char *sch="", float r0=0.05, const char *opt="")\r
+ inline void Pipe(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &ax, const mglDataA &ay, const mglDataA &az, const char *sch="", mreal r0=0.05, const char *opt="")\r
{ mgl_pipe_xyz(gr, &x, &y, &z, &ax, &ay, &az, sch, r0, opt); }\r
- inline void Pipe(const mglDataA &ax, const mglDataA &ay, const mglDataA &az, const char *sch="", float r0=0.05, const char *opt="")\r
+ inline void Pipe(const mglDataA &ax, const mglDataA &ay, const mglDataA &az, const char *sch="", mreal r0=0.05, const char *opt="")\r
{ mgl_pipe_3d(gr, &ax, &ay, &az, sch, r0, opt); }\r
\r
/// Draw density plot for data at x = sVal\r
- inline void DensX(const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void DensX(const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_dens_x(gr, &a, stl, sVal, opt); }\r
/// Draw density plot for data at y = sVal\r
- inline void DensY(const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void DensY(const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_dens_y(gr, &a, stl, sVal, opt); }\r
/// Draw density plot for data at z = sVal\r
- inline void DensZ(const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void DensZ(const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_dens_z(gr, &a, stl, sVal, opt); }\r
/// Draw contour plots for data at x = sVal\r
- inline void ContX(const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContX(const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_cont_x(gr, &a, stl, sVal, opt); }\r
- inline void ContX(const mglDataA &v, const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContX(const mglDataA &v, const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_cont_x_val(gr, &v, &a, stl, sVal, opt); }\r
/// Draw contour plots for data at y = sVal\r
- inline void ContY(const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContY(const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_cont_y(gr, &a, stl, sVal, opt); }\r
- inline void ContY(const mglDataA &v, const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContY(const mglDataA &v, const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_cont_y_val(gr, &v, &a, stl, sVal, opt); }\r
/// Draw contour plots for data at z = sVal\r
- inline void ContZ(const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContZ(const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_cont_z(gr, &a, stl, sVal, opt); }\r
- inline void ContZ(const mglDataA &v, const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContZ(const mglDataA &v, const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_cont_z_val(gr, &v, &a, stl, sVal, opt); }\r
/// Draw solid contour plots for data at x = sVal\r
- inline void ContFX(const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContFX(const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_contf_x(gr, &a, stl, sVal, opt); }\r
- inline void ContFX(const mglDataA &v, const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContFX(const mglDataA &v, const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_contf_x_val(gr, &v, &a, stl, sVal, opt); }\r
/// Draw solid contour plots for data at y = sVal\r
- inline void ContFY(const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContFY(const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_contf_y(gr, &a, stl, sVal, opt); }\r
- inline void ContFY(const mglDataA &v, const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContFY(const mglDataA &v, const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_contf_y_val(gr, &v, &a, stl, sVal, opt); }\r
/// Draw solid contour plots for data at z = sVal\r
- inline void ContFZ(const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContFZ(const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_contf_z(gr, &a, stl, sVal, opt); }\r
- inline void ContFZ(const mglDataA &v, const mglDataA &a, const char *stl="", float sVal=NaN, const char *opt="")\r
+ inline void ContFZ(const mglDataA &v, const mglDataA &a, const char *stl="", mreal sVal=NaN, const char *opt="")\r
{ mgl_contf_z_val(gr, &v, &a, stl, sVal, opt); }\r
\r
/// Draw curve for formula with x in range [Min.x, Max.x]\r
inline mglData FitS(const mglDataA &x, const mglDataA &y, const mglDataA &z, const mglDataA &a, const mglDataA &s, const char *eq, const char *var, mglData &ini, const char *opt="")\r
{ return mglData(true,mgl_fit_xyzas(gr, &x, &y, &z, &a, &s, eq, var, &ini, opt)); }\r
/// Print fitted last formula (with coefficients)\r
- inline void PutsFit(mglPoint p, const char *prefix=0, const char *font=0, float size=-1)\r
+ inline void PutsFit(mglPoint p, const char *prefix=0, const char *font=0, mreal size=-1)\r
{ mgl_puts_fit(gr, p.x, p.y, p.z, prefix, font, size); }\r
/// Get last fitted formula\r
inline const char *GetFit()\r
{ return mgl_get_fit(gr); }\r
\r
/// Solve PDE with x,y,z in range [Min, Max]\r
- inline mglData PDE(const char *ham, const mglDataA &ini_re, const mglDataA &ini_im, float dz=0.1, float k0=100, const char *opt="")\r
+ inline mglData PDE(const char *ham, const mglDataA &ini_re, const mglDataA &ini_im, mreal dz=0.1, mreal k0=100, const char *opt="")\r
{ return mglData(true,mgl_pde_solve(gr,ham,&ini_re,&ini_im,dz,k0, opt)); }\r
/// Fill data by formula with x,y,z in range [Min, Max]\r
inline void Fill(mglData &u, const char *eq, const char *opt="")\r
inline void Fill(mglData &u, const char *eq, const mglDataA &v, const mglDataA &w, const char *opt="")\r
{ mgl_data_fill_eq(gr, &u, eq, &v, &w, opt); }\r
\r
+ /// Set the data by triangulated surface values assuming x,y,z in range [Min, Max]\r
+ inline void DataGrid(mglData &d, const mglDataA &x, const mglDataA &y, const mglDataA &z, const char *opt="")\r
+ { mgl_data_grid(gr,&d,&x,&y,&z,opt); }\r
+ \r
/// Make histogram (distribution) of data. This function do not plot data.\r
inline mglData Hist(const mglDataA &x, const mglDataA &a, const char *opt="")\r
{ return mglData(true, mgl_hist_x(gr, &x, &a, opt)); }\r
{ return mglData(true, mgl_hist_xyz(gr, &x, &y, &z, &a, opt)); }\r
\r
inline void Compression(bool){} // NOTE: Add later -- IDTF\r
- inline void VertexColor(bool){} // NOTE: Add later -- IDTF\r
- inline void DoubleSided(bool){} // NOTE: Add later -- IDTF\r
+ /// Set the preference for vertex color on/off (for formats that support it, now only PRC does).\r
+ inline void VertexColor(bool enable) { mgl_set_flag(gr,enable, MGL_PREFERVC); }\r
+ /// Render only front side of surfaces for dubugging purposes (for formats that support it, now only PRC does).\r
+ inline void DoubleSided(bool enable) { mgl_set_flag(gr,!enable, MGL_ONESIDED); }\r
inline void TextureColor(bool){} // NOTE: Add later -- IDTF\r
};\r
//-----------------------------------------------------------------------------\r
#include "mgl2/canvas_cf.h"\r
#include "mgl2/addon.h"\r
/*****************************************************************************/\r
+#if MGL_HAVE_OPENGL\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+HMGL mgl_create_graph_gl();\r
+uintptr_t mgl_create_graph_gl_();\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+#endif\r
+/*****************************************************************************/\r
#endif\r
void SetQuality(int =0) { Quality=2; }\r
void Finish(bool fast=true);\r
void SetSize(int ,int ) {}\r
- void View(float tetX,float tetY,float tetZ);\r
+ void View(mreal tetX,mreal tetY,mreal tetZ);\r
int NewFrame();\r
void EndFrame();\r
\r
bool Alpha(bool enable);\r
- void Fog(float d, float dz=0.25);\r
+ void Fog(mreal d, mreal dz=0.25);\r
bool Light(bool enable);\r
void Light(int n, bool enable);\r
- void AddLight(int n,mglPoint r,mglPoint d, char c='w', float bright=0.5, float ap=0);\r
+ void AddLight(int n,mglPoint r,mglPoint d, char c='w', mreal bright=0.5, mreal ap=0);\r
void Clf(mglColor Back=WC);\r
\r
protected:\r
\r
unsigned char **GetRGBLines(long &w, long &h, unsigned char *&f, bool solid=true);\r
void LightScale();\r
- void set_pen(unsigned style,float width);\r
+ void set_pen(unsigned style,mreal width);\r
};\r
extern "C" {\r
#endif\r
* other.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 *
- * 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. *
- ***************************************************************************/
+ * 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_OTHER_H_\r
-#define _MGL_OTHER_H_
+#define _MGL_OTHER_H_\r
#include "mgl2/base.h"\r
/*****************************************************************************/\r
-#ifdef __cplusplus
+#ifdef __cplusplus\r
extern "C" {\r
#endif\r
/*****************************************************************************/\r
void mgl_triplot_xyzc(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, HCDT c, const char *sch, const char *opt);\r
void mgl_triplot_xyz(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt);\r
void mgl_triplot_xy(HMGL gr, HCDT nums, HCDT x, HCDT y, const char *sch, const char *opt);\r
-
+\r
void mgl_quadplot_xyzc(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, HCDT c, const char *sch, const char *opt);\r
void mgl_quadplot_xyz(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt);\r
void mgl_quadplot_xy(HMGL gr, HCDT nums, HCDT x, HCDT y, const char *sch, const char *opt);\r
-
+\r
void mgl_tricont_xyzcv(HMGL gr, HCDT v, HCDT nums, HCDT x, HCDT y, HCDT z, HCDT c, const char *sch, const char *opt);\r
void mgl_tricont_xycv(HMGL gr, HCDT v, HCDT nums, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt);\r
void mgl_tricont_xyzc(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, HCDT c, const char *sch, const char *opt);\r
void mgl_tricont_xyc(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt);\r
-
+\r
void mgl_dots(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt);\r
void mgl_dots_a(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, const char *opt);\r
-
+\r
void mgl_crust(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt);\r
-
-void mgl_dens_x(HMGL graph, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_dens_y(HMGL graph, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_dens_z(HMGL graph, HCDT a, const char *stl, float sVal, const char *opt);
\r
-void mgl_cont_x(HMGL graph, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_cont_y(HMGL graph, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_cont_z(HMGL graph, HCDT a, const char *stl, float sVal, const char *opt);
+void mgl_dens_x(HMGL graph, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_dens_y(HMGL graph, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_dens_z(HMGL graph, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+\r
+void mgl_cont_x(HMGL graph, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_cont_y(HMGL graph, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_cont_z(HMGL graph, HCDT a, const char *stl, mreal sVal, const char *opt);\r
\r
-void mgl_cont_x_val(HMGL graph, HCDT v, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_cont_y_val(HMGL graph, HCDT v, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_cont_z_val(HMGL graph, HCDT v, HCDT a, const char *stl, float sVal, const char *opt);
+void mgl_cont_x_val(HMGL graph, HCDT v, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_cont_y_val(HMGL graph, HCDT v, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_cont_z_val(HMGL graph, HCDT v, HCDT a, const char *stl, mreal sVal, const char *opt);\r
\r
-void mgl_contf_x(HMGL graph, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_contf_y(HMGL graph, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_contf_z(HMGL graph, HCDT a, const char *stl, float sVal, const char *opt);
+void mgl_contf_x(HMGL graph, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_contf_y(HMGL graph, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_contf_z(HMGL graph, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+\r
+void mgl_contf_x_val(HMGL graph, HCDT v, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_contf_y_val(HMGL graph, HCDT v, HCDT a, const char *stl, mreal sVal, const char *opt);\r
+void mgl_contf_z_val(HMGL graph, HCDT v, HCDT a, const char *stl, mreal sVal, const char *opt);\r
\r
-void mgl_contf_x_val(HMGL graph, HCDT v, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_contf_y_val(HMGL graph, HCDT v, HCDT a, const char *stl, float sVal, const char *opt);\r
-void mgl_contf_z_val(HMGL graph, HCDT v, HCDT a, const char *stl, float sVal, const char *opt);\r
-
/*****************************************************************************/\r
\r
void mgl_triplot_xyzc_(uintptr_t *gr, uintptr_t *nums, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *c, const char *sch, const char *opt,int,int);\r
void mgl_quadplot_xyzc_(uintptr_t *gr, uintptr_t *nums, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *c, const char *sch, const char *opt,int,int);\r
void mgl_quadplot_xyz_(uintptr_t *gr, uintptr_t *nums, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *sch, const char *opt,int,int);\r
void mgl_quadplot_xy_(uintptr_t *gr, uintptr_t *nums, uintptr_t *x, uintptr_t *y, const char *sch, const char *opt,int,int);\r
-
+\r
void mgl_tricont_xyzcv_(uintptr_t *gr, uintptr_t *v, uintptr_t *nums, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *c, const char *sch, const char *opt,int,int);\r
void mgl_tricont_xycv_(uintptr_t *gr, uintptr_t *v, uintptr_t *nums, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *sch, const char *opt,int,int);\r
void mgl_tricont_xyzc_(uintptr_t *gr, uintptr_t *nums, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *c, const char *sch, const char *opt,int, int);\r
void mgl_tricont_xyc_(uintptr_t *gr, uintptr_t *nums, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *sch, const char *opt,int, int);\r
-
+\r
void mgl_dots_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *sch, const char *opt,int,int);\r
void mgl_dots_a_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, const char *opt,int,int);\r
void mgl_dots_tr_(uintptr_t *gr, uintptr_t *tr, const char *sch, const char *opt,int,int);\r
void mgl_crust_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *sch, const char *opt,int,int);\r
void mgl_crust_tr_(uintptr_t *gr, uintptr_t *tr, const char *sch, const char *opt,int,int);\r
-
-void mgl_dens_x_(uintptr_t *graph, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_dens_y_(uintptr_t *graph, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_dens_z_(uintptr_t *graph, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_cont_x_(uintptr_t *graph, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_cont_y_(uintptr_t *graph, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_cont_z_(uintptr_t *graph, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_cont_x_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_cont_y_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_cont_z_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_contf_x_(uintptr_t *graph, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_contf_y_(uintptr_t *graph, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_contf_z_(uintptr_t *graph, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_contf_x_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_contf_y_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-void mgl_contf_z_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, float *sVal, const char *opt,int,int);\r
-
+\r
+void mgl_dens_x_(uintptr_t *graph, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_dens_y_(uintptr_t *graph, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_dens_z_(uintptr_t *graph, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_cont_x_(uintptr_t *graph, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_cont_y_(uintptr_t *graph, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_cont_z_(uintptr_t *graph, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_cont_x_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_cont_y_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_cont_z_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_contf_x_(uintptr_t *graph, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_contf_y_(uintptr_t *graph, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_contf_z_(uintptr_t *graph, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_contf_x_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_contf_y_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+void mgl_contf_z_val_(uintptr_t *graph, uintptr_t *v, uintptr_t *a, const char *stl, mreal *sVal, const char *opt,int,int);\r
+\r
/*****************************************************************************/\r
#ifdef __cplusplus\r
}\r
-#endif
+#endif\r
/*****************************************************************************/\r
-#endif
+#endif\r
{\r
long pos;\r
int narg;\r
- std::wstring func;\r
- mglFunc *next;\r
- mglFunc(long p, const wchar_t *f, mglFunc *prev=0);\r
- ~mglFunc() { if(next) delete next; };\r
+// std::wstring func;\r
+ wchar_t func[64];\r
+ mglFunc(long p, const wchar_t *f);\r
+ mglFunc(const mglFunc &f);\r
+ mglFunc() { pos=narg=-1; *func=0; }\r
};\r
//-----------------------------------------------------------------------------\r
/// Structure for stack of functions and its arguments.\r
friend void mgl_export(wchar_t *out, const wchar_t *in, int type);\r
public:\r
mglVar *DataList; ///< List with data and its names\r
- mglNum *NumList; ///< List with numbers and its names\r
+ mglNum *NumList; ///< List with numbers and its names\r
bool AllowSetSize; ///< Allow using setsize command\r
bool Stop; ///< Stop command was. Flag prevent further execution\r
- mglCommand *Cmd; ///< Table of MGL commands (can be changed by user). It MUST be sorted by 'name'!!!\r
+ mglCommand *Cmd; ///< Table of MGL commands (can be changed by user). It MUST be sorted by 'name'!!!\r
wchar_t *op1, *op2; ///< Buffer for options (are used if out!=NULL)\r
long InUse; ///< Smart pointer (number of users)\r
\r
/// Delete variable by its name\r
void DeleteVar(const wchar_t *name);\r
private:\r
- long parlen; ///< Length of parameter strings\r
+ long parlen; ///< Length of parameter strings\r
wchar_t *par[40]; ///< Parameter for substituting instead of $1, ..., $9\r
wchar_t *out; ///< Buffer for writing C++ code (if not NULL)\r
wchar_t leg[128]; ///< Buffer for legend\r
- bool Once; ///< Flag for command which should be executed only once\r
- bool Skip; ///< Flag that commands should be skiped (inside 'once' block)\r
+ bool Once; ///< Flag for command which should be executed only once\r
+ bool Skip; ///< Flag that commands should be skiped (inside 'once' block)\r
int if_stack[40]; ///< Stack for if-else-endif commands\r
- int if_pos; ///< position in if_stack\r
- mglFunc *func; ///< function names and position\r
- mglFnStack *fn_stack; ///< function calls stack\r
- int fn_pos; ///< position in function stack\r
- int fn_num; ///< size of function stack\r
- int if_for[40]; ///< position in if_stack for for-cycle start\r
- mglData *fval; ///< Values for for-cycle. Note that nx - number of elements, ny - next element, nz - address (or string number) of first cycle command\r
+ int if_pos; ///< position in if_stack\r
+ std::vector<mglFunc> func; ///< function names and position\r
+ mglFnStack *fn_stack; ///< function calls stack\r
+ int fn_pos; ///< position in function stack\r
+ int fn_num; ///< size of function stack\r
+ int if_for[40]; ///< position in if_stack for for-cycle start\r
+ mglData *fval; ///< Values for for-cycle. Note that nx - number of elements, ny - next element, nz - address (or string number) of first cycle command\r
int for_stack[40]; ///< The order of for-variables\r
- int for_addr; ///< Flag for saving address in variable (for_addr-1)\r
- bool for_br; ///< Break is switched on (skip all comands until 'next')\r
+ int for_addr; ///< Flag for saving address in variable (for_addr-1)\r
+ bool for_br; ///< Break is switched on (skip all comands until 'next')\r
\r
/// Parse command\r
int Exec(mglGraph *gr, const wchar_t *com, long n, mglArg *a, const wchar_t *var, const wchar_t *opt);\r
void mgl_tube_xyzr(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT r, const char *pen, const char *opt);\r
void mgl_tube_xyr(HMGL graph, HCDT x, HCDT y, HCDT r, const char *pen, const char *opt);\r
void mgl_tube_r(HMGL graph, HCDT y, HCDT r, const char *pen, const char *opt);\r
-void mgl_tube_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, float r, const char *pen, const char *opt);\r
-void mgl_tube_xy(HMGL graph, HCDT x, HCDT y, float r, const char *penl, const char *opt);\r
-void mgl_tube(HMGL graph, HCDT y, float r, const char *pen, const char *opt);\r
+void mgl_tube_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, mreal r, const char *pen, const char *opt);\r
+void mgl_tube_xy(HMGL graph, HCDT x, HCDT y, mreal r, const char *penl, const char *opt);\r
+void mgl_tube(HMGL graph, HCDT y, mreal r, const char *pen, const char *opt);\r
/*****************************************************************************/\r
void mgl_candle_xyv(HMGL gr, HCDT x, HCDT v1, HCDT v2, HCDT y1, HCDT y2, const char *pen, const char *opt);\r
void mgl_candle_yv(HMGL gr, HCDT v1, HCDT v2, HCDT y1, HCDT y2, const char *pen, const char *opt);\r
void mgl_tube_xyzr_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *r, const char *pen, const char *opt,int,int);\r
void mgl_tube_xyr_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *r, const char *pen, const char *opt,int,int);\r
void mgl_tube_r_(uintptr_t *graph, uintptr_t *y, uintptr_t *r, const char *pen, const char *opt,int,int);\r
-void mgl_tube_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, float *r, const char *pen, const char *opt,int,int);\r
-void mgl_tube_xy_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, float *r, const char *pen, const char *opt,int,int);\r
-void mgl_tube_(uintptr_t *graph, uintptr_t *y, float *r, const char *pen, const char *opt,int,int);\r
+void mgl_tube_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, mreal *r, const char *pen, const char *opt,int,int);\r
+void mgl_tube_xy_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, mreal *r, const char *pen, const char *opt,int,int);\r
+void mgl_tube_(uintptr_t *graph, uintptr_t *y, mreal *r, const char *pen, const char *opt,int,int);\r
void mgl_candle_xyv_(uintptr_t *gr, uintptr_t *x, uintptr_t *v1, uintptr_t *v2, uintptr_t *y1, uintptr_t *y2, const char *pen, const char *opt,int,int);\r
void mgl_candle_yv_(uintptr_t *gr, uintptr_t *v1, uintptr_t *v2, uintptr_t *y1, uintptr_t *y2, const char *pen, const char *opt,int,int);\r
void mgl_candle_(uintptr_t *gr, uintptr_t *y, uintptr_t *y1, uintptr_t *y2, const char *pen, const char *opt,int,int);\r
extern "C" {\r
#endif\r
/*****************************************************************************/\r
-void mgl_mark(HMGL gr, float x,float y,float z,const char *mark);\r
-void mgl_ball(HMGL gr, float x,float y,float z);\r
+void mgl_mark(HMGL gr, mreal x,mreal y,mreal z,const char *mark);\r
+void mgl_ball(HMGL gr, mreal x,mreal y,mreal z);\r
/*****************************************************************************/\r
-void mgl_line(HMGL gr, float x1, float y1, float z1, float x2, float y2, float z2, const char *pen,int n);\r
-void mgl_curve(HMGL gr, float x1, float y1, float z1, float dx1, float dy1, float dz1, float x2, float y2, float z2, float dx2, float dy2, float dz2, const char *pen,int n);\r
+void mgl_line(HMGL gr, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, const char *pen,int n);\r
+void mgl_curve(HMGL gr, mreal x1, mreal y1, mreal z1, mreal dx1, mreal dy1, mreal dz1, mreal x2, mreal y2, mreal z2, mreal dx2, mreal dy2, mreal dz2, const char *pen,int n);\r
/*****************************************************************************/\r
-void mgl_error_box(HMGL gr, float x, float y, float z, float ex, float ey, float ez, const char *pen);\r
+void mgl_error_box(HMGL gr, mreal x, mreal y, mreal z, mreal ex, mreal ey, mreal ez, const char *pen);\r
/*****************************************************************************/\r
-void mgl_face(HMGL gr, float x0, float y0, float z0, float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, const char *stl);\r
-void mgl_facex(HMGL gr, float x0, float y0, float z0, float wy, float wz, const char *stl, float dx, float dy);\r
-void mgl_facey(HMGL gr, float x0, float y0, float z0, float wx, float wz, const char *stl, float dx, float dy);\r
-void mgl_facez(HMGL gr, float x0, float y0, float z0, float wx, float wy, const char *stl, float dx, float dy);\r
+void mgl_face(HMGL gr, mreal x0, mreal y0, mreal z0, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, mreal x3, mreal y3, mreal z3, const char *stl);\r
+void mgl_facex(HMGL gr, mreal x0, mreal y0, mreal z0, mreal wy, mreal wz, const char *stl, mreal dx, mreal dy);\r
+void mgl_facey(HMGL gr, mreal x0, mreal y0, mreal z0, mreal wx, mreal wz, const char *stl, mreal dx, mreal dy);\r
+void mgl_facez(HMGL gr, mreal x0, mreal y0, mreal z0, mreal wx, mreal wy, const char *stl, mreal dx, mreal dy);\r
/*****************************************************************************/\r
-void mgl_sphere(HMGL gr, float x, float y, float z, float r, const char *stl);\r
-void mgl_drop(HMGL gr, float x1, float y1, float z1, float x2, float y2, float z2, float r, const char *stl, float shift, float ap);\r
-void mgl_cone(HMGL gr, float x1, float y1, float z1, float x2, float y2, float z2, float r1, float r2, const char *stl);\r
-void mgl_ellipse(HMGL gr, float x1, float y1, float z1, float x2, float y2, float z2, float r, const char *stl);\r
-void mgl_rhomb(HMGL gr, float x1, float y1, float z1, float x2, float y2, float z2, float r, const char *stl);\r
+void mgl_sphere(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl);\r
+void mgl_drop(HMGL gr, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, mreal r, const char *stl, mreal shift, mreal ap);\r
+void mgl_cone(HMGL gr, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, mreal r1, mreal r2, const char *stl);\r
+void mgl_ellipse(HMGL gr, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, mreal r, const char *stl);\r
+void mgl_rhomb(HMGL gr, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, mreal r, const char *stl);\r
/*****************************************************************************/\r
void mgl_cones_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, const char *pen, const char *opt);\r
void mgl_cones_xz(HMGL graph, HCDT x, HCDT z, const char *pen, const char *opt);\r
void mgl_dew_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt);\r
void mgl_dew_2d(HMGL gr, HCDT ax, HCDT ay, const char *sch, const char *optl);\r
/*****************************************************************************/\r
-void mgl_puts(HMGL graph, float x, float y, float z,const char *text, const char *font, float size);\r
-void mgl_putsw(HMGL graph, float x, float y, float z,const wchar_t *text, const char *font, float size);\r
+void mgl_puts(HMGL graph, mreal x, mreal y, mreal z,const char *text, const char *font, mreal size);\r
+void mgl_putsw(HMGL graph, mreal x, mreal y, mreal z,const wchar_t *text, const char *font, mreal size);\r
/*****************************************************************************/\r
-void mgl_puts_dir(HMGL graph, float x, float y, float z, float dx, float dy, float dz, const char *text, const char *font, float size);\r
-void mgl_putsw_dir(HMGL graph, float x, float y, float z, float dx, float dy, float dz, const wchar_t *text, const char *font, float size);\r
+void mgl_puts_dir(HMGL graph, mreal x, mreal y, mreal z, mreal dx, mreal dy, mreal dz, const char *text, const char *font, mreal size);\r
+void mgl_putsw_dir(HMGL graph, mreal x, mreal y, mreal z, mreal dx, mreal dy, mreal dz, const wchar_t *text, const char *font, mreal size);\r
/*****************************************************************************/\r
void mgl_textmark_xyzr(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT r, const char *text, const char *fnt, const char *opt);\r
void mgl_textmark_xyr(HMGL graph, HCDT x, HCDT y, HCDT r, const char *text, const char *fnt, const char *opt);\r
void mgl_textmarkw_yr(HMGL graph, HCDT y, HCDT r, const wchar_t *text, const char *fnt, const char *opt);\r
void mgl_textmarkw(HMGL graph, HCDT y, const wchar_t *text, const char *fnt, const char *opt);\r
/*****************************************************************************/\r
-void mgl_puts_fit(HMGL gr, float x, float y, float z, const char *prefix, const char *font, float size);\r
-/*****************************************************************************/\r
void mgl_label_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, const char *text, const char *fnt, const char *opt);\r
void mgl_labelw_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, const wchar_t *text, const char *fnt, const char *opt);\r
void mgl_label_xy(HMGL graph, HCDT x, HCDT y, const char *text, const char *fnt, const char *opt);\r
void mgl_labelw_y(HMGL graph, HCDT y, const wchar_t *text, const char *fnt, const char *opt);\r
/*****************************************************************************/\r
/*****************************************************************************/\r
-void mgl_mark_(uintptr_t *gr, float *x,float *y,float *z,const char *mark,int);\r
-void mgl_ball_(uintptr_t *gr, float *x,float *y,float *z);\r
+void mgl_mark_(uintptr_t *gr, mreal *x,mreal *y,mreal *z,const char *mark,int);\r
+void mgl_ball_(uintptr_t *gr, mreal *x,mreal *y,mreal *z);\r
/*****************************************************************************/\r
-void mgl_line_(uintptr_t *gr, float *x1, float *y1, float *z1, float *x2, float *y2, float *z2, const char *pen,int *n,int);\r
-void mgl_curve_(uintptr_t* gr, float *x1, float *y1, float *z1, float *dx1, float *dy1, float *dz1, float *x2, float *y2, float *z2, float *dx2, float *dy2, float *dz2, const char *pen,int *n, int l);\r
+void mgl_line_(uintptr_t *gr, mreal *x1, mreal *y1, mreal *z1, mreal *x2, mreal *y2, mreal *z2, const char *pen,int *n,int);\r
+void mgl_curve_(uintptr_t* gr, mreal *x1, mreal *y1, mreal *z1, mreal *dx1, mreal *dy1, mreal *dz1, mreal *x2, mreal *y2, mreal *z2, mreal *dx2, mreal *dy2, mreal *dz2, const char *pen,int *n, int l);\r
/*****************************************************************************/\r
-void mgl_error_box_(uintptr_t* gr, float *x, float *y, float *z, float *ex, float *ey, float *ez, const char *pen, int);\r
+void mgl_error_box_(uintptr_t* gr, mreal *x, mreal *y, mreal *z, mreal *ex, mreal *ey, mreal *ez, const char *pen, int);\r
/*****************************************************************************/\r
-void mgl_face_(uintptr_t* gr, float *x0, float *y0, float *z0, float *x1, float *y1, float *z1, float *x2, float *y2, float *z2, float *x3, float *y3, float *z3, const char *stl, int);\r
-void mgl_facex_(uintptr_t* gr, float *x0, float *y0, float *z0, float *wy, float *wz, const char *stl, float *dx, float *dy, int l);\r
-void mgl_facey_(uintptr_t* gr, float *x0, float *y0, float *z0, float *wx, float *wz, const char *stl, float *dx, float *dy, int l);\r
-void mgl_facez_(uintptr_t* gr, float *x0, float *y0, float *z0, float *wx, float *wy, const char *stl, float *dx, float *dy, int l);\r
+void mgl_face_(uintptr_t* gr, mreal *x0, mreal *y0, mreal *z0, mreal *x1, mreal *y1, mreal *z1, mreal *x2, mreal *y2, mreal *z2, mreal *x3, mreal *y3, mreal *z3, const char *stl, int);\r
+void mgl_facex_(uintptr_t* gr, mreal *x0, mreal *y0, mreal *z0, mreal *wy, mreal *wz, const char *stl, mreal *dx, mreal *dy, int l);\r
+void mgl_facey_(uintptr_t* gr, mreal *x0, mreal *y0, mreal *z0, mreal *wx, mreal *wz, const char *stl, mreal *dx, mreal *dy, int l);\r
+void mgl_facez_(uintptr_t* gr, mreal *x0, mreal *y0, mreal *z0, mreal *wx, mreal *wy, const char *stl, mreal *dx, mreal *dy, int l);\r
/*****************************************************************************/\r
-void mgl_sphere_(uintptr_t* gr, float *x, float *y, float *z, float *r, const char *stl, int);\r
-void mgl_drop_(uintptr_t* gr, float *x1, float *y1, float *z1, float *x2, float *y2, float *z2, float *r, const char *stl, float *shift, float *ap, int);\r
-void mgl_cone_(uintptr_t* gr, float *x1, float *y1, float *z1, float *x2, float *y2, float *z2, float *r1, float *r2, const char *stl, int);\r
-void mgl_ellipse_(uintptr_t* gr, float *x1, float *y1, float *z1, float *x2, float *y2, float *z2, float *r, const char *stl, int);\r
-void mgl_rhomb_(uintptr_t* gr, float *x1, float *y1, float *z1, float *x2, float *y2, float *z2, float *r, const char *stl, int);\r
+void mgl_sphere_(uintptr_t* gr, mreal *x, mreal *y, mreal *z, mreal *r, const char *stl, int);\r
+void mgl_drop_(uintptr_t* gr, mreal *x1, mreal *y1, mreal *z1, mreal *x2, mreal *y2, mreal *z2, mreal *r, const char *stl, mreal *shift, mreal *ap, int);\r
+void mgl_cone_(uintptr_t* gr, mreal *x1, mreal *y1, mreal *z1, mreal *x2, mreal *y2, mreal *z2, mreal *r1, mreal *r2, const char *stl, int);\r
+void mgl_ellipse_(uintptr_t* gr, mreal *x1, mreal *y1, mreal *z1, mreal *x2, mreal *y2, mreal *z2, mreal *r, const char *stl, int);\r
+void mgl_rhomb_(uintptr_t* gr, mreal *x1, mreal *y1, mreal *z1, mreal *x2, mreal *y2, mreal *z2, mreal *r, const char *stl, int);\r
/*****************************************************************************/\r
void mgl_cones_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int,int);\r
void mgl_coners_xz_(uintptr_t *graph, uintptr_t *x, uintptr_t *z, const char *pen, const char *opt,int,int);\r
void mgl_cones_(uintptr_t *graph, uintptr_t *z, const char *pen, const char *opt,int,int);\r
/*****************************************************************************/\r
-void mgl_puts_(uintptr_t *graph, float *x, float *y, float *z,const char *text, const char *font, float *size, int, int);\r
-void mgl_puts_dir_(uintptr_t *graph, float *x, float *y, float *z, float *dx, float *dy, float *dz, const char *text, const char *font, float *size, int, int);\r
+void mgl_puts_(uintptr_t *graph, mreal *x, mreal *y, mreal *z,const char *text, const char *font, mreal *size, int, int);\r
+void mgl_puts_dir_(uintptr_t *graph, mreal *x, mreal *y, mreal *z, mreal *dx, mreal *dy, mreal *dz, const char *text, const char *font, mreal *size, int, int);\r
/*****************************************************************************/\r
void mgl_textmark_xyzr_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *r, const char *text, const char *fnt, const char *opt,int,int,int);\r
void mgl_textmark_xyr_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *r, const char *text, const char *fnt, const char *opt,int,int,int);\r
void mgl_textmark_yr_(uintptr_t *graph, uintptr_t *y, uintptr_t *r, const char *text, const char *fnt, const char *opt,int,int,int);\r
void mgl_textmark_(uintptr_t *graph, uintptr_t *y, const char *text, const char *fnt, const char *opt,int,int,int);\r
/*****************************************************************************/\r
-void mgl_puts_fit_(uintptr_t* gr, float *x, float *y, float *z, const char *prefix, const char *font, float *size, int l, int n);\r
-/*****************************************************************************/\r
void mgl_label_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *text, const char *fnt, const char *opt,int,int,int);\r
void mgl_label_xy_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, const char *text, const char *fnt, const char *opt,int,int,int);\r
void mgl_label_y_(uintptr_t *graph, uintptr_t *y, const char *text, const char *fnt, const char *opt,int,int,int);\r
{ draw = dr; }\r
inline void setDraw(int (*draw)(mglGraph *gr))\r
{ setDraw(mgl_draw_graph,(void*)draw); }\r
- inline void zoomRegion(float xx1,float xx2,float yy1, float yy2)\r
+ inline void zoomRegion(mreal xx1,mreal xx2,mreal yy1, mreal yy2)\r
{ x1=xx1; y1=yy1; x2=xx2; y2=yy2; }\r
\r
int getPer() {return int(per);}; ///< Get perspective value\r
void lightChanged(bool); ///< Lighting changed (by toolbar)\r
void zoomChanged(bool); ///< Zooming changed (by toolbar)\r
void rotateChanged(bool); ///< Rotation changed (by toolbar)\r
- void mouseClick(float,float,float); ///< Position of mouse click\r
+ void mouseClick(mreal,mreal,mreal); ///< Position of mouse click\r
void frameChanged(int); ///< Need another frame to show\r
void showWarn(QString); ///< Show warnings\r
void posChanged(QString message); ///< user click to show mouse position\r
bool zoom; ///< Mouse zoom state\r
bool grid; ///< Grid drawing state\r
bool rotate; ///< Mouse rotation state\r
- float x1,x2,y1,y2; ///< Zoom in region\r
+ mreal x1,x2,y1,y2; ///< Zoom in region\r
bool showMessage; ///< Flag for showing messages (enabled by each execute())\r
QMenu *popup; ///< Pointer to pop-up menu\r
QTimer *timer; ///< Timer for animation\r
***************************************************************************/
#ifndef _MGL_TYPE_H_
#define _MGL_TYPE_H_
-#include <math.h>
-#ifndef _MSC_VER
+#if !defined(_MSC_VER) && !defined(__BORLANDC__)
#include <stdint.h>
#endif
#include "mgl2/define.h"
const mreal Pi = M_PI;
const mreal NaN = NAN;
//-----------------------------------------------------------------------------
+#define MGL_SET_XYZ(p,xx,yy,zz) {p.x=(xx);p.y=(yy);p.z=(zz);}
+#define MGL_SET_XY(p,xx,yy) {p.x=(xx);p.y=(yy);p.z=0;}
+#define MGL_SET_RGBA(p,rr,gg,bb,aa) {p.r=(rr);p.g=(gg);p.b=(bb);p.a=(aa);}
+#define MGL_SET_RGB(p,rr,gg,bb) {p.r=(rr);p.g=(gg);p.b=(bb);}
+//-----------------------------------------------------------------------------
/// Class for incapsulating point in space
struct mglPoint
{
- float x,y,z,c;
- mglPoint(float X=0,float Y=0,float Z=0,float C=0){x=X;y=Y;z=Z;c=C;}
+ mreal x,y,z,c;
+ mglPoint(mreal X=0,mreal Y=0,mreal Z=0,mreal C=0){x=X;y=Y;z=Z;c=C;}
inline bool IsNAN() { return (x!=x || y!=y || z!=z || c!=c); }
- inline float val(int i) { return (i<2 ? (i==0 ? x:y) : (i==2 ? z:c)); }
- inline float norm() { return sqrt(x*x+y*y+z*z); }
- inline void Normalize() { float v=norm(); x/=v; y/=v; z/=v; }
+ inline mreal val(int i) { return (i<2 ? (i==0 ? x:y) : (i==2 ? z:c)); }
+ inline mreal norm() { return sqrt(x*x+y*y+z*z); }
+ inline void Normalize() { mreal v=norm(); x/=v; y/=v; z/=v; }
inline void operator+=(const mglPoint &a) { x+=a.x; y+=a.y; z+=a.z; c+=a.c; }
inline void operator-=(const mglPoint &a) { x-=a.x; y-=a.y; z-=a.z; c-=a.c; }
- inline void operator+=(float a) { x+=a; y+=a; z+=a; }
- inline void operator-=(float a) { x-=a; y-=a; z-=a; }
- inline void operator*=(float a) { x*=a; y*=a; z*=a; }
- inline void operator/=(float a) { x/=a; y/=a; z/=a; }
+ inline void operator+=(mreal a) { x+=a; y+=a; z+=a; }
+ inline void operator-=(mreal a) { x-=a; y-=a; z-=a; }
+ inline void operator*=(mreal a) { x*=a; y*=a; z*=a; }
+ inline void operator/=(mreal 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)
{ return mglPoint(-a.x, -a.y, -a.z, -a.c); }
-inline mglPoint operator*(float b, const mglPoint &a)
+inline mglPoint operator*(mreal b, const mglPoint &a)
{ return mglPoint(a.x*b, a.y*b, a.z*b); }
-inline mglPoint operator*(const mglPoint &a, float b)
+inline mglPoint operator*(const mglPoint &a, mreal b)
{ return mglPoint(a.x*b, a.y*b, a.z*b); }
-inline mglPoint operator/(const mglPoint &a, float b)
+inline mglPoint operator/(const mglPoint &a, mreal b)
{ return mglPoint(a.x/b, a.y/b, a.z/b); }
-inline float operator*(const mglPoint &a, const mglPoint &b)
+inline mreal operator*(const mglPoint &a, const mglPoint &b)
{ return a.x*b.x+a.y*b.y+a.z*b.z; }
inline mglPoint operator/(const mglPoint &a, const mglPoint &b)
{ return mglPoint(a.x*b.x, a.y*b.y, a.z*b.z); }
inline mglPoint operator^(const mglPoint &a, const mglPoint &b)
{ return mglPoint(a.y*b.z-a.z*b.y, a.z*b.x-a.x*b.z, a.x*b.y-a.y*b.x); }
inline mglPoint operator!(const mglPoint &a)
-{ float f=hypot(a.x,a.y); return f==0?mglPoint(0,1,0):mglPoint(-a.y/f, a.x/f, 0); }
+{ mreal f=hypot(a.x,a.y); return f==0?mglPoint(0.,1.,0.):mglPoint(-a.y/f, a.x/f, 0); }
inline bool operator==(const mglPoint &a, const mglPoint &b)
{ return !memcmp(&a, &b, sizeof(mglPoint)); }
inline bool operator!=(const mglPoint &a, const mglPoint &b)
{ return memcmp(&a, &b, sizeof(mglPoint)); }
-inline float mgl_norm(const mglPoint &p)
+inline bool operator<(const mglPoint &a, const mglPoint &b)
+{ return a.x<=b.x && a.y<=b.y && a.z<=b.z; }
+inline bool operator>(const mglPoint &a, const mglPoint &b)
+{ return a.x>=b.x && a.y>=b.y && a.z>=b.z; }
+inline mreal mgl_norm(const mglPoint &p)
{ return sqrt(p.x*p.x+p.y*p.y+p.z*p.z); }
#endif
//-----------------------------------------------------------------------------
* vect.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 *
- * 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. *
- ***************************************************************************/
+ * 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_VECT_H_\r
-#define _MGL_VECT_H_
+#define _MGL_VECT_H_\r
#include "mgl2/base.h"\r
/*****************************************************************************/\r
-#ifdef __cplusplus
+#ifdef __cplusplus\r
extern "C" {\r
#endif\r
/*****************************************************************************/\r
void mgl_traj_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt);\r
void mgl_traj_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt);\r
-
+\r
void mgl_vect_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt);\r
void mgl_vect_2d(HMGL gr, HCDT ax, HCDT ay, const char *sch, const char *opt);\r
void mgl_vect_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt);\r
void mgl_vect_3d(HMGL gr, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt);\r
-
+\r
void mgl_flow_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt);\r
void mgl_flow_2d(HMGL gr, HCDT ax, HCDT ay, const char *sch, const char *opt);\r
void mgl_flow_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt);\r
void mgl_flow_3d(HMGL gr, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt);\r
\r
-void mgl_flowp_xy(HMGL gr, float x0, float y0, float z0, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt);\r
-void mgl_flowp_2d(HMGL gr, float x0, float y0, float z0, HCDT ax, HCDT ay, const char *sch, const char *opt);\r
-void mgl_flowp_xyz(HMGL gr, float x0, float y0, float z0, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt);\r
-void mgl_flowp_3d(HMGL gr, float x0, float y0, float z0, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt);\r
+void mgl_flowp_xy(HMGL gr, mreal x0, mreal y0, mreal z0, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt);\r
+void mgl_flowp_2d(HMGL gr, mreal x0, mreal y0, mreal z0, HCDT ax, HCDT ay, const char *sch, const char *opt);\r
+void mgl_flowp_xyz(HMGL gr, mreal x0, mreal y0, mreal z0, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt);\r
+void mgl_flowp_3d(HMGL gr, mreal x0, mreal y0, mreal z0, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt);\r
+\r
+void mgl_pipe_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, mreal r0, const char *opt);\r
+void mgl_pipe_2d(HMGL gr, HCDT ax, HCDT ay, const char *sch, mreal r0, const char *opt);\r
+void mgl_pipe_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, mreal r0, const char *opt);\r
+void mgl_pipe_3d(HMGL gr, HCDT ax, HCDT ay, HCDT az, const char *sch, mreal r0, const char *opt);\r
\r
-void mgl_pipe_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, float r0, const char *opt);\r
-void mgl_pipe_2d(HMGL gr, HCDT ax, HCDT ay, const char *sch, float r0, const char *opt);\r
-void mgl_pipe_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, float r0, const char *opt);\r
-void mgl_pipe_3d(HMGL gr, HCDT ax, HCDT ay, HCDT az, const char *sch, float r0, const char *opt);\r
-
void mgl_grad_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ph, const char *sch, const char *opt);\r
void mgl_grad_xy(HMGL gr, HCDT x, HCDT y, HCDT ph, const char *sch, const char *opt);\r
void mgl_grad(HMGL gr, HCDT ph, const char *sch, const char *opt);\r
-
+\r
/*****************************************************************************/\r
void mgl_traj_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int,int);\r
void mgl_traj_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int,int);\r
-
+\r
void mgl_vect_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int,int);\r
void mgl_vect_2d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int,int);\r
void mgl_vect_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int,int);\r
void mgl_vect_3d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int,int);\r
-
+\r
void mgl_flow_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int,int);\r
void mgl_flow_2d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int,int);\r
void mgl_flow_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int,int);\r
void mgl_flow_3d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int,int);\r
\r
-void mgl_flowp_xy_(uintptr_t *gr, float *x0, float *y0, float *z0, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int, int);\r
-void mgl_flowp_2d_(uintptr_t *gr, float *x0, float *y0, float *z0, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int, int);\r
-void mgl_flowp_xyz_(uintptr_t *gr, float *x0, float *y0, float *z0, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int, int);\r
-void mgl_flowp_3d_(uintptr_t *gr, float *x0, float *y0, float *z0, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int,int);\r
+void mgl_flowp_xy_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int, int);\r
+void mgl_flowp_2d_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int, int);\r
+void mgl_flowp_xyz_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int, int);\r
+void mgl_flowp_3d_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int,int);\r
+\r
+void mgl_pipe_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, mreal *r0, const char *opt,int,int);\r
+void mgl_pipe_2d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, const char *sch, mreal *r0, const char *opt,int,int);\r
+void mgl_pipe_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, mreal *r0, const char *opt,int,int);\r
+void mgl_pipe_3d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, mreal *r0, const char *opt,int,int);\r
\r
-void mgl_pipe_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, float *r0, const char *opt,int,int);\r
-void mgl_pipe_2d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, const char *sch, float *r0, const char *opt,int,int);\r
-void mgl_pipe_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, float *r0, const char *opt,int,int);\r
-void mgl_pipe_3d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, float *r0, const char *opt,int,int);\r
-
void mgl_grad_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ph, const char *sch, const char *opt,int, int);\r
void mgl_grad_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ph, const char *sch, const char *opt,int,int);\r
void mgl_grad_(uintptr_t *gr, uintptr_t *ph, const char *sch, const char *opt,int,int);\r
-
+\r
/*****************************************************************************/\r
#ifdef __cplusplus\r
}\r
-#endif
+#endif\r
/*****************************************************************************/\r
-#endif
+#endif\r
* volume.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 *
- * 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. *
- ***************************************************************************/
+ * 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_VOL_H_\r
-#define _MGL_VOL_H_
+#define _MGL_VOL_H_\r
#include "mgl2/base.h"\r
/*****************************************************************************/\r
-#ifdef __cplusplus
+#ifdef __cplusplus\r
extern "C" {\r
#endif\r
/*****************************************************************************/\r
-void mgl_surf3_xyz_val(HMGL graph, float Val, HCDT x, HCDT y, HCDT z, HCDT a, const char *stl, const char *opt);\r
-void mgl_surf3_val(HMGL graph, float Val, HCDT a, const char *stl, const char *opt);\r
+void mgl_surf3_xyz_val(HMGL graph, mreal Val, HCDT x, HCDT y, HCDT z, HCDT a, const char *stl, const char *opt);\r
+void mgl_surf3_val(HMGL graph, mreal Val, HCDT a, const char *stl, const char *opt);\r
void mgl_surf3_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, const char *stl, const char *opt);\r
void mgl_surf3(HMGL graph, HCDT a, const char *stl, const char *opt);\r
-
-void mgl_surf3a_xyz_val(HMGL graph, float Val, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *stl, const char *opt);\r
-void mgl_surf3a_val(HMGL graph, float Val, HCDT a, HCDT b, const char *stl, const char *opt);\r
+\r
+void mgl_surf3a_xyz_val(HMGL graph, mreal Val, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *stl, const char *opt);\r
+void mgl_surf3a_val(HMGL graph, mreal Val, HCDT a, HCDT b, const char *stl, const char *opt);\r
void mgl_surf3a_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *stl, const char *opt);\r
void mgl_surf3a(HMGL graph, HCDT a, HCDT b, const char *stl, const char *opt);\r
-
-void mgl_surf3c_xyz_val(HMGL graph, float Val, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *stl, const char *opt);\r
-void mgl_surf3c_val(HMGL graph, float Val, HCDT a, HCDT b, const char *stl, const char *opt);\r
+\r
+void mgl_surf3c_xyz_val(HMGL graph, mreal Val, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *stl, const char *opt);\r
+void mgl_surf3c_val(HMGL graph, mreal Val, HCDT a, HCDT b, const char *stl, const char *opt);\r
void mgl_surf3c_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *stl, const char *opt);\r
void mgl_surf3c(HMGL graph, HCDT a, HCDT b, const char *stl, const char *opt);\r
-
-// NOTE: now style '.' draws dots instead of faces
+\r
+// NOTE: now style '.' draws dots instead of faces\r
void mgl_cloud_xyz(HMGL graph, HCDT x, HCDT y, HCDT z, HCDT a, const char *stl, const char *opt);\r
void mgl_cloud(HMGL graph, HCDT a, const char *stl, const char *opt);\r
-
-void mgl_beam_val(HMGL graph, float Val, HCDT tr, HCDT g1, HCDT g2, HCDT a, float r, const char *stl, int norm);\r
-void mgl_beam(HMGL graph, HCDT tr, HCDT g1, HCDT g2, HCDT a, float r, const char *stl, int norm, int num);\r
-
+\r
+void mgl_beam_val(HMGL graph, mreal Val, HCDT tr, HCDT g1, HCDT g2, HCDT a, mreal r, const char *stl, int norm);\r
+void mgl_beam(HMGL graph, HCDT tr, HCDT g1, HCDT g2, HCDT a, mreal r, const char *stl, int norm, int num);\r
+\r
/*****************************************************************************/\r
-void mgl_surf3_xyz_val_(uintptr_t *graph, float *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *stl, const char *opt,int,int);\r
-void mgl_surf3_val_(uintptr_t *graph, float *Val, uintptr_t *a, const char *stl, const char *opt,int,int);\r
+void mgl_surf3_xyz_val_(uintptr_t *graph, mreal *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *stl, const char *opt,int,int);\r
+void mgl_surf3_val_(uintptr_t *graph, mreal *Val, uintptr_t *a, const char *stl, const char *opt,int,int);\r
void mgl_surf3_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *stl, const char *opt,int,int);\r
void mgl_surf3_(uintptr_t *graph, uintptr_t *a, const char *stl, const char *opt,int,int);\r
-
-void mgl_surf3a_xyz_val_(uintptr_t *graph, float *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
-void mgl_surf3a_val_(uintptr_t *graph, float *Val, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
+\r
+void mgl_surf3a_xyz_val_(uintptr_t *graph, mreal *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
+void mgl_surf3a_val_(uintptr_t *graph, mreal *Val, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
void mgl_surf3a_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
void mgl_surf3a_(uintptr_t *graph, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
-
-void mgl_surf3c_xyz_val_(uintptr_t *graph, float *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
-void mgl_surf3c_val_(uintptr_t *graph, float *Val, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
+\r
+void mgl_surf3c_xyz_val_(uintptr_t *graph, mreal *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
+void mgl_surf3c_val_(uintptr_t *graph, mreal *Val, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
void mgl_surf3c_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
void mgl_surf3c_(uintptr_t *graph, uintptr_t *a, uintptr_t *b, const char *stl, const char *opt,int,int);\r
-
+\r
void mgl_cloudp_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *stl, const char *opt,int,int);\r
void mgl_cloudp_(uintptr_t *graph, uintptr_t *a, const char *stl, const char *opt,int,int);\r
void mgl_cloud_xyz_(uintptr_t *graph, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *stl, const char *opt,int,int);\r
void mgl_cloud_(uintptr_t *graph, uintptr_t *a, const char *stl, const char *opt,int,int);\r
-
-void mgl_beam_val_(uintptr_t *gr, float *val, uintptr_t *tr, uintptr_t *g1, uintptr_t *g2, uintptr_t *a, float *r, const char *sch, int *norm,int l);\r
-void mgl_beam_(uintptr_t *gr, uintptr_t *tr, uintptr_t *g1, uintptr_t *g2, uintptr_t *a, float *r, const char *sch, int *norm, int *num,int l);\r
-
+\r
+void mgl_beam_val_(uintptr_t *gr, mreal *val, uintptr_t *tr, uintptr_t *g1, uintptr_t *g2, uintptr_t *a, mreal *r, const char *sch, int *norm,int l);\r
+void mgl_beam_(uintptr_t *gr, uintptr_t *tr, uintptr_t *g1, uintptr_t *g2, uintptr_t *a, mreal *r, const char *sch, int *norm, int *num,int l);\r
+\r
/*****************************************************************************/\r
#ifdef __cplusplus\r
}\r
-#endif
+#endif\r
/*****************************************************************************/\r
-#endif
+#endif\r
{ mgl_draw_thr(this); }\r
#endif\r
};\r
-typedef int (*draw_func)(mglGraph *gr);\r
-int mgl_draw_graph(mglBase *gr, void *p);\r
+//-----------------------------------------------------------------------------\r
+extern "C" {\r
+int mgl_draw_graph(HMGL gr, void *p);\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
+int mgl_draw_class(HMGL gr, void *p);\r
void mgl_click_class(void *p);\r
void mgl_reload_class(void *p);\r
+}\r
//-----------------------------------------------------------------------------\r
#if MGL_HAVE_QT\r
#define MGL_WND_KIND 1\r
#else\r
#define MGL_WND_KIND 0\r
#endif\r
+//-----------------------------------------------------------------------------\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 int mgl_draw_class(HMGL gr, void *p);\r
friend void mgl_click_class(void *p);\r
friend void mgl_reload_class(void *p);\r
protected:\r
int wnd; ///< Type of window\r
public:\r
mglWindow(const char *title="MathGL") : mglGraph(-1)\r
- { wnd=0; dr=0; gr = mgl_create_graph_fltk(0,title,0,0); }\r
+ { wnd=0; dr=0; gr = mgl_create_graph_fltk(0,title,0,0); mgl_use_graph(gr,1); }\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
wnd=kind; dr=0;\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
+ mgl_use_graph(gr,1);\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,0);\r
else gr = mgl_create_graph_fltk(mgl_draw_graph,title,(void*)draw,0);\r
+ mgl_use_graph(gr,1);\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,mgl_reload_class);\r
else gr = mgl_create_graph_fltk(mgl_draw_class,title,this,mgl_reload_class);\r
+ mgl_use_graph(gr,1);\r
mgl_set_click_func(gr, mgl_click_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
+ inline void ToggleAlpha() ///< Switch on/off transparency (do not overwrite user settings)\r
{ mgl_wnd_toggle_alpha(gr); }\r
inline void ToggleLight() ///< Switch on/off lighting (do not overwrite user settings)\r
{ mgl_wnd_toggle_light(gr); }\r
void SetClickFunc(void (*func)(void *p))\r
{ if(!dr) mgl_set_click_func(gr,func); }\r
\r
- inline void SetDelay(float dt) ///< Delay for animation in seconds\r
+ inline void SetDelay(mreal dt) ///< Delay for animation in seconds\r
{ mgl_wnd_set_delay(gr, dt); }\r
inline void Setup(bool clf_upd=true, bool showpos=false)\r
{ mgl_setup_window(gr, clf_upd, showpos); }\r
inline mglPoint LastMousePos() ///< Last mouse position\r
- { mglPoint p; mgl_get_last_mouse_pos(gr,&p.x,&p.y,&p.z); return p; }\r
+ { mreal x,y,z; mgl_get_last_mouse_pos(gr,&x,&y,&z); return mglPoint(x,y,z); }\r
};\r
//-----------------------------------------------------------------------------\r
#endif\r
)
# -L$<TARGET_LINKER_FILE_DIR:mgl> #commented out for compatibilty reason with old cmake
# -L$<TARGET_LINKER_FILE_DIR:mgl-wnd> #commented out for compatibilty reason with old cmake
- add_custom_command(OUTPUT ${pkg_name}/inst/${oct_arch}/mathgl.oct
- COMMAND ${oct_mk} ${MGL_DEF}
+ add_custom_command(OUTPUT mgl_octave.o
+ COMMAND ${oct_mk} -c ${MGL_DEF}
-I${oct_inc} -I${BIN_INC} -I${SRC_INC}
+ -o mgl_octave.o mgl_octave.cpp
+ DEPENDS ${src_dep} mgl_octave.cpp
+ IMPLICIT_DEPENDS CXX ${src_imp_dep}
+ )
+ add_custom_command(OUTPUT ${pkg_name}/inst/${oct_arch}/mathgl.oct
+ COMMAND ${oct_mk}
-L${MGL_LINK_DIR}
-L${MGL_WND_LINK_DIR}
-lmgl-wnd -lmgl
- -o ${pkg_name}/inst/${oct_arch}/mathgl.oct mgl_octave.cpp
- DEPENDS ${dep_libs} ${src_dep} mgl_octave.cpp
- IMPLICIT_DEPENDS CXX ${src_imp_dep}
+ -o ${pkg_name}/inst/${oct_arch}/mathgl.oct mgl_octave.o
+ DEPENDS ${dep_libs} mgl_octave.o
)
+# add_custom_command(OUTPUT ${pkg_name}/inst/${oct_arch}/mathgl.oct
+# COMMAND ${oct_mk} ${MGL_DEF}
+# -I${oct_inc} -I${BIN_INC} -I${SRC_INC}
+# -L${MGL_LINK_DIR}
+# -L${MGL_WND_LINK_DIR}
+# -lmgl-wnd -lmgl
+# -o ${pkg_name}/inst/${oct_arch}/mathgl.oct mgl_octave.cpp
+# DEPENDS ${dep_libs} ${src_dep} mgl_octave.cpp
+# )
add_custom_command(OUTPUT mathgl.tar.gz
COMMAND ${oct_tar} cpzvf mathgl.tar.gz ${pkg_name}
DEPENDS ${pkg_name}/inst/${oct_arch}/mathgl.oct
)
add_custom_target(mgl_octave_module ALL DEPENDS mathgl.tar.gz)
+ install(CODE "execute_process(COMMAND ${oct_exec} ${CMAKE_SOURCE_DIR}/lang/install.m WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/lang )")
+
endif(MGL_HAVE_OCTAVE)
--- /dev/null
+pkg install mathgl.tar.gz
%rename(__div) operator/;
%rename(__eq) operator==;
%rename(__ne) operator!=;
-//%typemap(in,noblock=1) (double* d, int rows, int cols) (Matrix tmp) {
-// if (!$input.is_matrix_type()) {
-// error("A must be a matrix");
-// SWIG_fail;
-// }
-// tmp=$input.matrix_value();
-// $1=tmp.data();
-// $2=tmp.rows();
-// $3=tmp.columns();
-//}
+%typemap(in,noblock=1) (double* d, int rows, int cols) (Matrix tmp) {
+ if (!$input.is_matrix_type()) { error("A must be a matrix"); SWIG_fail; }
+ tmp=$input.matrix_value();
+ $1=tmp.data();
+ $2=tmp.rows();
+ $3=tmp.columns();
+}
#endif
#ifdef SWIGPYTHON
if(MGL_HAVE_FLTK)
include_directories(${FLTK_INCLUDE_DIR})
- set(mgl_lab_src animate.cpp editor.cpp help.cpp mathgl.cpp setup.cpp write.cpp data.cpp grid.cpp main.cpp option.cpp table.cpp ../widgets/fltk.cpp ../widgets/window.cpp)
+ set(mgl_lab_src animate.cpp editor.cpp help.cpp mathgl.cpp setup.cpp write.cpp data.cpp grid.cpp main.cpp option.cpp table.cpp)
add_executable(mgllab ${mgl_lab_src})
- target_link_libraries(mgllab mgl ${FLTK_LIBRARIES})
+ target_link_libraries(mgllab mgl mgl-wnd ${FLTK_LIBRARIES})
install(
TARGETS mgllab
RUNTIME DESTINATION bin )
void AnimateDlg::FillResult(Fl_MGL* e)
{
e->NArgs = e->ArgCur = 0;
- if(e->ArgBuf) delete []e->ArgBuf; e->ArgBuf = 0;
+ if(e->ArgBuf) delete [](e->ArgBuf); e->ArgBuf = 0;
e->AnimDelay = atof(dt->value());
if(rt->value())
{
void cmd_dlg_cb(Fl_Widget *, void *v) // add variables checking\r
{ cmd_dlg.OK = true; ((Fl_Window *)v)->hide(); }\r
//-----------------------------------------------------------------------------\r
-void type_cmd_cb(Fl_Widget *w, void *v)\r
+void type_cmd_cb(Fl_Widget *, void *)\r
{\r
int val = cmd_dlg.type->value();\r
if(val>=0 && val<16)\r
cmd_dlg.cmd->value(0);\r
}\r
//-----------------------------------------------------------------------------\r
-void desc_cmd_cb(Fl_Widget *w, void *v)\r
+void desc_cmd_cb(Fl_Widget *, void *)\r
{\r
const char *name = cmd_dlg.cmd->mvalue()->text;\r
cmd_dlg.dsc->copy_label(Parse->CmdDesc(name));\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-void plot_dat_cb(Fl_Widget *, void *v)\r
+void plot_dat_cb(Fl_Widget *, void *)\r
{\r
CmdDlg *s = &cmd_dlg;\r
s->OK = false;\r
* along with this program; if not, write to the Free Software\r
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
*/\r
-#include <stdio.h>\r
-#include <stdlib.h>\r
-#include <string.h>\r
#include <ctype.h>\r
#include <errno.h>\r
#ifdef __MWERKS__\r
// Syntax highlighting stuff...\r
Fl_Text_Buffer *stylebuf = 0;\r
Fl_Text_Display::Style_Table_Entry styletable[] = { // Style table\r
- { FL_BLACK, FL_COURIER, 14 }, // A - Plain\r
- { FL_DARK_GREEN,FL_COURIER_ITALIC, 14 }, // B - Line comments\r
- { FL_BLUE, FL_COURIER, 14 }, // C - Number\r
- { FL_RED, FL_COURIER, 14 }, // D - Strings\r
- { FL_DARK_BLUE, FL_COURIER_BOLD, 14 }, // E - Usual ommand\r
- { FL_DARK_CYAN, FL_COURIER_BOLD, 14 }, // F - Flow command\r
- { FL_DARK_MAGENTA, FL_COURIER_BOLD,14 }, // G - New-data command\r
- { FL_DARK_RED, FL_COURIER_BOLD, 14 }, // H - Option\r
- { FL_DARK_GREEN,FL_COURIER_BOLD, 14 }}; // I - Inactive command\r
+ { FL_BLACK, FL_COURIER, 14, 0 }, // A - Plain\r
+ { FL_DARK_GREEN,FL_COURIER_ITALIC, 14, 0 }, // B - Line comments\r
+ { FL_BLUE, FL_COURIER, 14, 0 }, // C - Number\r
+ { FL_RED, FL_COURIER, 14, 0 }, // D - Strings\r
+ { FL_DARK_BLUE, FL_COURIER_BOLD, 14, 0 }, // E - Usual ommand\r
+ { FL_DARK_CYAN, FL_COURIER_BOLD, 14, 0 }, // F - Flow command\r
+ { FL_DARK_MAGENTA, FL_COURIER_BOLD,14, 0 }, // G - New-data command\r
+ { FL_DARK_RED, FL_COURIER_BOLD, 14, 0 }, // H - Option\r
+ { FL_DARK_GREEN,FL_COURIER_BOLD, 14, 0 }}; // I - Inactive command\r
//-----------------------------------------------------------------------------\r
bool is_sfx(const char *s) // suffix\r
{\r
}\r
//-----------------------------------------------------------------------------\r
// Parse text and produce style data.\r
-void style_parse(const char *text, char *style, int length)\r
+void style_parse(const char *text, char *style, int /*length*/)\r
{\r
register long i;\r
long n=strlen(text);\r
#include <FL/Fl_Int_Input.H>
#include <FL/Fl_Value_Slider.H>
#include <FL/fl_draw.H>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <math.h>
#include "udav.h"
//-----------------------------------------------------------------------------
Fl_Callback input_cb;
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
*/\r
#include "udav.h"\r
-#include <stdlib.h>\r
-#include <string.h>\r
-#include <stdio.h>\r
#include <ctype.h>\r
#include <FL/Fl_Select_Browser.H>\r
//-----------------------------------------------------------------------------\r
* along with this program; if not, write to the Free Software\r
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
*/\r
-#include <stdlib.h>\r
-#include <string.h>\r
-#include <stdio.h>\r
#include <ctype.h>\r
#include <errno.h>\r
#include <locale.h>\r
* along with this program; if not, write to the Free Software\r
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r
*/\r
-#include <stdio.h>\r
#include "mgl2/mgl.h"\r
#include "udav.h"\r
//-----------------------------------------------------------------------------\r
//-----------------------------------------------------------------------------\r
void udav_error(const char *Message, void *v)\r
{ ((Fl_MGL*)v)->status->label(Message); }\r
-float udav_delay(void *v)\r
+mreal udav_delay(void *v)\r
{ return ((Fl_MGL*)v)->AnimDelay; }\r
void udav_reload(void *v)\r
{ Parse->RestoreOnce(); ((Fl_MGL*)v)->update(); }\r
script = script_pre = 0; par = this;\r
next = udav_next; delay = udav_delay;\r
prev = udav_prev; reload = udav_reload;\r
-#ifdef WIN32\r
+/*#ifdef WIN32\r
// setlocale(LC_TYPE,"russian_Russia.CP1251");\r
char *path;\r
get_doc_dir(path);\r
- if(!graph->LoadFont("STIX",path && path[0] ? path : ".")) graph->RestoreFont();\r
+ if(!FMGL->GetFont()->Load("STIX",path && path[0] ? path : ".")) FMGL->GetFont()->Restore();\r
free(path);\r
-#endif\r
+#endif*/\r
}\r
//-----------------------------------------------------------------------------\r
Fl_MGL::~Fl_MGL() { clear_scripts(); if(ArgBuf) delete []ArgBuf; }\r
//-----------------------------------------------------------------------------\r
int Fl_MGL::Draw(mglGraph *gr)\r
{\r
- Parse->Execute(gr,script_pre,udav_error);\r
- Parse->Execute(gr,script,udav_error);\r
+ Parse->Execute(gr,script_pre);\r
+ Parse->Execute(gr,script);\r
+ status->label(gr->Message());\r
return 0;\r
}\r
//-----------------------------------------------------------------------------\r
}\r
//-----------------------------------------------------------------------------\r
Fl_Menu_Item colors[] = {\r
- {"-----"}, //\r
+ {"-----", 0,0,0,0,0,0,0, 0}, //\r
{("white"), 0,0,0,0,0,0,0, fl_rgb_color(0,0,0)}, //w\r
{("blue"), 0,0,0,0,0,0,0, fl_rgb_color(0,0,255)}, //b\r
{("lime"), 0,0,0,0,0,0,0, fl_rgb_color(0,255,0)}, //g\r
{("brown"), 0,0,0,0,0,0,0, fl_rgb_color(127,77,0)}, //Q\r
{("darkpink"), 0,0,0,0,0,0,0, fl_rgb_color(127,0,77)}, //P\r
{("darkgray"), 0,0,0,0,0,0,0, fl_rgb_color(77,77,77)}, //H\r
-{0}};\r
+{0, 0,0,0,0,0,0,0, 0}};\r
//-----------------------------------------------------------------------------\r
struct PropDlg\r
{\r
const char *AnimBuf; ///< buffer for animation\r
const char **AnimS0;\r
int AnimNum;\r
- float AnimDelay;\r
+ mreal AnimDelay;\r
\r
Fl_MGL(int x, int y, int w, int h, char *label=0);\r
~Fl_MGL();\r
set(mgl_src
-addon.cpp axis.cpp base_cf.cpp base.cpp canvas_cf.cpp canvas.cpp cont.cpp crust.cpp
-data.cpp data_io.cpp data_new.cpp data_op.cpp data_png.cpp def_font.cpp
-export_2d.cpp export_3d.cpp eval.cpp evalp.cpp exec.cpp export.cpp
-fit.cpp font.cpp other.cpp parser.cpp pde.cpp pixel.cpp
-plot.cpp prim.cpp surf.cpp tex_table.cpp vect.cpp volume.cpp evalc.cpp #window.cpp
+ addon.cpp axis.cpp base_cf.cpp base.cpp canvas_cf.cpp canvas.cpp cont.cpp crust.cpp
+ data.cpp data_io.cpp data_new.cpp data_png.cpp def_font.cpp
+ export_2d.cpp export_3d.cpp eval.cpp evalp.cpp exec.cpp export.cpp
+ fit.cpp font.cpp other.cpp parser.cpp pde.cpp pixel.cpp
+ plot.cpp prim.cpp surf.cpp tex_table.cpp vect.cpp volume.cpp evalc.cpp
+ s_hull/s_hull_pro.cpp
)
set(mgl_hdr
-../include/mgl2/base_cf.h ../include/mgl2/fit.h ../include/mgl2/plot.h
-../include/mgl2/base.h ../include/mgl2/prim.h ../include/mgl2/canvas_cf.h
-../include/mgl2/font.h ../include/mgl2/canvas.h ../include/mgl2/surf.h
-../include/mgl2/mgl_cf.h ../include/mgl2/type.h ${MathGL_BINARY_DIR}/include/mgl2/config.h
-../include/mgl2/cont.h ../include/mgl2/mgl.h ../include/mgl2/vect.h
-../include/mgl2/data.h ../include/mgl2/volume.h ../include/mgl2/data_cf.h
-../include/mgl2/define.h ../include/mgl2/other.h ../include/mgl2/eval.h
-../include/mgl2/parser.h ../include/mgl2/addon.h ../include/mgl2/evalc.h )
-
-set(prc_src
-prc/PRCbitStream.cc prc/PRCdouble.cc prc/oPRCFile.cc prc/writePRC.cc prc.cpp
+ ../include/mgl2/base_cf.h ../include/mgl2/fit.h ../include/mgl2/plot.h
+ ../include/mgl2/base.h ../include/mgl2/prim.h ../include/mgl2/canvas_cf.h
+ ../include/mgl2/font.h ../include/mgl2/canvas.h ../include/mgl2/surf.h
+ ../include/mgl2/mgl_cf.h ../include/mgl2/type.h ${MathGL_BINARY_DIR}/include/mgl2/config.h
+ ../include/mgl2/cont.h ../include/mgl2/mgl.h ../include/mgl2/vect.h
+ ../include/mgl2/data.h ../include/mgl2/volume.h ../include/mgl2/data_cf.h
+ ../include/mgl2/define.h ../include/mgl2/other.h ../include/mgl2/eval.h
+ ../include/mgl2/parser.h ../include/mgl2/addon.h ../include/mgl2/evalc.h
+ s_hull/s_hull_pro.h
)
-set(prc_hdr
-prc/PRC.h prc/PRCbitStream.h prc/PRCdouble.h prc/oPRCFile.h prc/writePRC.h
-)
+add_definitions(-DMGL_SRC)
+
+if(MGL_HAVE_PNG)
+ set(prc_src prc/PRCbitStream.cc prc/PRCdouble.cc prc/oPRCFile.cc prc/writePRC.cc prc.cpp )
+ set(prc_hdr prc/PRC.h prc/PRCbitStream.h prc/PRCdouble.h prc/oPRCFile.h prc/writePRC.h )
-set(mgl_src ${mgl_src} ${prc_src} )
-set(mgl_hdr ${mgl_hdr} ${prc_hdr} )
-include_directories(prc)
+ set(mgl_src ${mgl_src} ${prc_src} )
+ set(mgl_hdr ${mgl_hdr} ${prc_hdr} )
+ include_directories(prc)
+endif(MGL_HAVE_PNG)
if(MGL_HAVE_OPENGL)
set(mgl_src ${mgl_src} opengl.cpp )
include_directories(${OPENGL_INCLUDE_DIR} )
endif(MGL_HAVE_OPENGL)
-target_link_libraries(mgl ${PNG_LIBRARIES} ${ZLIB_LIBRARIES} m)
-include_directories(${PNG_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR})
+if(MGL_HAVE_PNG)
+ target_link_libraries(mgl ${PNG_LIBRARIES} )
+ include_directories(${PNG_INCLUDE_DIR})
+endif(MGL_HAVE_PNG)
+
+if(MGL_HAVE_ZLIB)
+ target_link_libraries(mgl ${ZLIB_LIBRARIES} )
+ include_directories(${ZLIB_INCLUDE_DIR})
+endif(MGL_HAVE_ZLIB)
+
+if(MGL_HAVE_MPI)
+ target_link_libraries(mgl ${MPI_LIBRARIES} )
+# include_directories(${MPI_C_INCLUDE_PATH})
+ include_directories(${MPI_CXX_INCLUDE_PATH})
+endif(MGL_HAVE_MPI)
+
+target_link_libraries(mgl ${M_LIB})
file(TO_NATIVE_PATH $(MGL_FONT_PATH) MGL_FONT_PATH_SYS)
#add_definitions(-DMGL_FONT_PATH="${MGL_FONT_PATH_SYS}")
return s;
}
//---------------------------------------------------------------------------
-bool mgl_istrue(char ch)
+int mgl_istrue(char ch)
{ return (ch=='1' || ch=='t' || ch=='+' || ch=='v'); }
//---------------------------------------------------------------------------
void mgl_test(const char *str, ...)
return fp;
}
//---------------------------------------------------------------------------
-bool mglDifrGrid(dual *a,int n,dual q,int Border,dual *b,dual *d,int kk)
+bool mgl_difr_grid(dual *a,int n,dual q,int Border,dual *b,dual *d,int kk)
{
register int i,k;
// if(n<=0 || q>=0.5) return false;
return true;
}
//----------------------------------------------------------------------------
-bool mglDifrAxial(dual *a, int n, dual q, int Border,dual *b, dual *d, int kk, double di)
+bool mgl_difr_axial(dual *a, int n, dual q, int Border,dual *b, dual *d, int kk, double di)
{
register int i,k,ii = di<0 ? -int(floor(di)) : 0;
dual adt = dual(0.,1.)*q;
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <time.h>
-#include <wchar.h>
#include <ctype.h>
-#include <stdlib.h>
#include "mgl2/data.h"
#include "mgl2/canvas.h"
#include "mgl2/prim.h"
#define islog(a, b) (((a)>0 && (b)>10*(a)) || ((b)<0 && (a)<10*(b)))
#define sign(a) ((a)<0 ? -1:1)
//-----------------------------------------------------------------------------
-inline struct tm* mgl_localtime_r (const time_t *clock, struct tm *result)
+inline struct tm* mgl_localtime (const time_t *clock, struct tm *result, bool use_utc)
{ if (!clock || !result) return NULL;
- memcpy(result,localtime(clock),sizeof(*result));
+memcpy(result,use_utc?gmtime(clock):localtime(clock),sizeof(*result));
return result; }
//-----------------------------------------------------------------------------
long mgl_have_color(const char *stl)
wchar_t *c = mgl_wcsdup(str);
unsigned long n=wcslen(str);
long k;
- for(k=0;k<long(wcslen(str));k++) if(str[k]>' ') break;
- wcscpy(c,&(str[k]));
- n = wcslen(c);
+ for(k=0;k<n;k++) if(str[k]>' ') break;
+ wcscpy(c,str+k); n = wcslen(c);
for(k=n-1;k>=0;k--) if(c[k]>' ') break;
c[k+1] = 0;
wcscpy(str,c); free(c);
else if(strlen(sub)<32) strcpy(SubTStl,sub);
}
//-----------------------------------------------------------------------------
-void mglCanvas::SetTickLen(float tlen, float stt)
+void mglCanvas::SetTickLen(mreal tlen, mreal stt)
{ TickLen = tlen?tlen:0.02; st_t=stt>0?stt:1; }
//-----------------------------------------------------------------------------
-void mglCanvas::SetTicks(char dir, float d, int ns, float org)
+void mglCanvas::SetTicks(char dir, mreal d, int ns, mreal org)
{
if(!strchr("xyzca",dir)) return;
mglAxis &aa = (dir=='x' ? ax : (dir=='y' ? ay : (dir=='z' ? az : ac)));
else if(strlen(t)<255) mbstowcs(aa.t,t,strlen(t)+1);
}
//-----------------------------------------------------------------------------
-double mgl_adj_val(double v,float *ds=0)
+double mgl_adj_val(double v,mreal *ds=0)
{
- float n = floor(log10(v)), s;
+ double n = floor(log10(v)), s;
v = floor(v*pow(10.,-n)); n = pow(10.,n);
if(v==1) { v = n/5; s=n/10; }
return v;
}
//-----------------------------------------------------------------------------
-void mglCanvas::SetTickTime(char dir, float d, const char *t)
+void mglCanvas::SetTickTime(char dir, mreal d, const char *t)
{
if(!strchr("xyzca",dir)) return;
mglAxis &aa = (dir=='x' ? ax : (dir=='y' ? ay : (dir=='z' ? az : ac)));
UpdateAxis();
time_t tt; tm t1,t2;
- tt=aa.v1; mgl_localtime_r(&tt,&t1);
- tt=aa.v2; mgl_localtime_r(&tt,&t2);
+ tt=aa.v1; mgl_localtime(&tt, &t1, get(MGL_USE_GMTIME));
+ tt=aa.v2; mgl_localtime(&tt, &t2, get(MGL_USE_GMTIME));
if(aa.v1<aa.v2) // adjust periodic values
{
if(abs(t1.tm_year-t2.tm_year)==1) t2.tm_yday += 365;
}
if(!t || !t[0]) // adjust template
{
- t = fabs(t1.tm_yday-t2.tm_yday)>1 ? "%x" : "%X";
- if(fabs(t1.tm_year-t2.tm_year)>3) t = "%Y";
+ t = abs(t1.tm_yday-t2.tm_yday)>1 ? "%x" : "%X";
+ if(abs(t1.tm_year-t2.tm_year)>3) t = "%Y";
}
if(d==0) // try to select opimal step
{
- if(fabs(t1.tm_year-t2.tm_year)>1)
- d = 365.25*24*3600*mgl_adj_val(fabs(t1.tm_year-t2.tm_year)); // number of second in year NOTE: improve it
+ if(abs(t1.tm_year-t2.tm_year)>1)
+ d = 365.25*24*3600*mgl_adj_val(abs(t1.tm_year-t2.tm_year)); // number of second in year NOTE: improve it
// NOTE here should be months ... but it is too unregular ... so omit it now
// else if(t1.tm_mon!=t2.tm_mon) d = 30*24*3600; // number of second in month
- else if(fabs(t1.tm_yday-t2.tm_yday)>1) // localtime("%x") cannot print time < 1 day
- { d = 24*3600*mgl_adj_val(fabs(t1.tm_yday-t2.tm_yday)); d = d>24*3600?d:24*3600; }
- else if(fabs(t1.tm_hour-t2.tm_hour)>1)
- d = 3600*mgl_adj_val(fabs(t1.tm_hour-t2.tm_hour));
- else if(fabs(t1.tm_min-t2.tm_min)>1)
- d = 60*mgl_adj_val(fabs(t1.tm_min-t2.tm_min));
- else if(fabs(t1.tm_sec-t2.tm_sec)>1) // localtime("%X") cannot print time < 1 sec
- { d = mgl_adj_val(fabs(t1.tm_sec-t2.tm_sec)); d = d>1?d:1; }
+ else if(abs(t1.tm_yday-t2.tm_yday)>1) // localtime("%x") cannot print time < 1 day
+ { d = 24*3600.*mgl_adj_val(abs(t1.tm_yday-t2.tm_yday)); d = d>24*3600?d:24*3600; }
+ else if(abs(t1.tm_hour-t2.tm_hour)>1)
+ d = 3600.*mgl_adj_val(abs(t1.tm_hour-t2.tm_hour));
+ else if(abs(t1.tm_min-t2.tm_min)>1)
+ d = 60*mgl_adj_val(abs(t1.tm_min-t2.tm_min));
+ else if(abs(t1.tm_sec-t2.tm_sec)>1) // localtime("%X") cannot print time < 1 sec
+ { d = mgl_adj_val(abs(t1.tm_sec-t2.tm_sec)); d = d>1?d:1; }
else // adjust msec. NOTE: this is not supported by localtime() !!!
d = mgl_adj_val(fabs(aa.v2-aa.v1));
+ aa.ds = 0;
}
aa.dv = d; aa.f = 1; aa.txt.clear();
if(aa.ch=='z') aa.v0 = aa.org.z;
wchar_t buf[64];
- float v, v0 = mgl_isnan(aa.o) ? aa.v0 : aa.o, v1;
+ mreal v, v0 = mgl_isnan(aa.o) ? aa.v0 : aa.o, v1;
if(aa.v2>aa.v1)
{ v1 = aa.v2; v0 = v0 - aa.dv*floor((v0-aa.v1)/aa.dv+1e-3); }
else
{ v1 = aa.v1; v0 = v0 - aa.dv*floor((v0-aa.v2)/aa.dv+1e-3); }
if(v0+aa.dv!=v0 && v1+aa.dv!=v1) for(v=v0;v<=v1;v+=aa.dv)
{
- tt = v; tm tp; mgl_localtime_r(&tt,&tp);
+ tt = v; tm tp; mgl_localtime(&tt, &tp, get(MGL_USE_GMTIME));
wcsftime(buf,64,aa.t,&tp); aa.AddLabel(buf,v);
}
}
//-----------------------------------------------------------------------------
void mglCanvas::AdjustTicks(mglAxis &aa, bool ff)
{
- float d = fabs(aa.v2-aa.v1), n;
+ double d = fabs(aa.v2-aa.v1), n;
if(aa.f>0) return;
if(ff && islog(aa.v1,aa.v2))
{ aa.dv = 0; aa.ds=0; }
else if(aa.d>0)
- { aa.dv = aa.d; aa.ds = aa.d/(fabs(aa.ns)+1); }
+ { aa.dv = aa.d; aa.ds = aa.d/(abs(aa.ns)+1); }
else if(aa.d>-1.5) // like =0 or =-1
{ aa.dv = mgl_adj_val(d,&aa.ds); aa.o=0; }
else
LabelTicks(aa);
}
//-----------------------------------------------------------------------------
-int mgl_tick_ext(float a, float b, wchar_t s[32], float &v)
+int mgl_tick_ext(mreal a, mreal b, wchar_t s[32], mreal &v)
{
int kind = 0;
if(fabs(a-b)<=0.001*fabs(a))
return kind;
}
//-----------------------------------------------------------------------------
-void mgl_tick_text(float z, float z0, float d, float v, int kind, wchar_t str[64], bool tune)
+void mgl_tick_text(mreal z, mreal z0, mreal d, mreal v, int kind, wchar_t str[64], bool tune)
{
- float u = fabs(z)<d ? 0:z;
+ mreal u = fabs(z)<d ? 0:z;
if((kind&1) && z>z0) u = fabs(z-z0)<d ? 0:(z-z0);
if(kind==2 || (kind==3 && z>z0)) u /= v;
if((kind&1) && z>z0)
if(aa.ch=='y') aa.v0 = aa.org.y;
if(aa.ch=='z') aa.v0 = aa.org.z;
- wchar_t buf[64];
- float v,v0,v1,w;
+ wchar_t buf[64]=L"";
+ mreal v,v0,v1,w;
int d,ds;
if(aa.f) return;
aa.txt.clear();
{
v0 = exp(M_LN10*floor(0.1+log10(aa.v1)));
ds = int(floor(0.1+log10(aa.v2/v0))/7)+1;
- for(v=v0;v<=aa.v2*MGL_FLT_EPS;v*=10) if(v*MGL_FLT_EPS>=aa.v1)
+ for(v=v0;v<=aa.v2*MGL_EPSILON;v*=10) if(v*MGL_EPSILON>=aa.v1)
{
d = int(floor(0.1+log10(v)));
if(d==0) wcscpy(buf,L"1");
{
v0 = -exp(M_LN10*floor(0.1+log10(-aa.v2)));
ds = int(floor(0.1+log10(aa.v1/v0))/7)+1;
- for(v=v0;v>=aa.v1*MGL_FLT_EPS;v*=10) if(v*MGL_FLT_EPS<=aa.v2)
+ for(v=v0;v>=aa.v1*MGL_EPSILON;v*=10) if(v*MGL_EPSILON<=aa.v2)
{
d = int(floor(0.1+log10(-v)));
if(d==0) wcscpy(buf,L"-1");
if(strchr(dir,ar[i])) { arr=ar[i]; break; }
bool adjust = stl && strchr(stl,'a');
+ bool ret = get(MGL_ENABLE_RTEXT);
+ if(dir && strchr(dir,'U')) clr(MGL_ENABLE_RTEXT);
AdjustTicks(dir,adjust);
// TODO: Ternary axis labeling ...
if(strchr(dir,'x')) DrawAxis(ax, text, arr, stl);
DrawAxis(ty, text, arr, stl);
}
else if(strchr(dir,'y')) DrawAxis(ay, text, arr, stl);
+ set(ret, MGL_ENABLE_RTEXT);
}
//-----------------------------------------------------------------------------
void mglCanvas::DrawAxis(mglAxis &aa, bool text, char arr,const char *stl)
}
k2 = aa.txt.size();
- float v, u, v0 = mgl_isnan(aa.o) ? aa.v0 : aa.o;
+ mreal v, u, v0 = mgl_isnan(aa.o) ? aa.v0 : aa.o;
if(k2>0) for(i=0;i<k2;i++)
{
v = aa.txt[i].val; u = fabs(v);
if(aa.dv==0 && fabs(u-exp(M_LN10*floor(0.1+log10(u))))<0.01*u)
for(j=2;j<10 && v*j<aa.v2;j++) tick_draw(o+d*(v*j),da,db,1,stl);
}
- if(aa.ds>0)
+ if(aa.ds>0 && !get(MGL_NOSUBTICKS))
{
if(aa.v2>aa.v1) v0 = v0 - aa.ds*floor((v0-aa.v1)/aa.ds+1e-3);
else v0 = v0 - aa.ds*floor((v0-aa.v2)/aa.ds+1e-3);
// if(get(MGL_DISABLE_SCALE) && ((aa.dir.x==0 && aa.org.x<0) || (aa.dir.y==0 && aa.org.y>0))) pos[0]='T';
if(aa.ch=='c') pos[0]=(aa.ns==0 || aa.ns==3)?'t':'T';
if(aa.ch=='T') pos[0]='T';
- float *w=new float[n], h = TextHeight(FontDef,-1)/4, c=NAN, l=NAN, tet=0, v, vv; // find sizes
+ mreal *w=new mreal[n], h = TextHeight(FontDef,-1)/3, c=NAN, l=NAN, tet=0, v, vv; // find sizes
long *kk=new long[n];
for(i=0;i<n;i++)
{
if(c>aa.v1 && c<aa.v2 && i%k!=0) continue;
p = o+d*c; nn = s-o; ScalePoint(p,nn);
mglPnt &qq = Pnt[kk[i]];
- float ux=qq.u*cos(tet) + qq.v*sin(tet), uy=qq.v*cos(tet) - qq.u*sin(tet);
+ mreal ux=qq.u*cos(tet) + qq.v*sin(tet), uy=qq.v*cos(tet) - qq.u*sin(tet);
if(qq.u*nn.x+qq.v*nn.y < ux*nn.x+uy*nn.y)
{ ux=qq.u*cos(tet) - qq.v*sin(tet); uy=qq.v*cos(tet) + qq.u*sin(tet); }
qq.u = ux; qq.v = uy;
- if(!get(MGL_ENABLE_RTEXT)) pos[2] = nn.x<0 || (nn.x==0 && nn.y<0) ? 'L':'R';
-
+ if(!get(MGL_ENABLE_RTEXT) && nn.x!=0) pos[2] = nn.x<0 ? 'L':'R';
if(aa.ch=='c' && aa.txt[i].text[0]==' ') qq.u = qq.v = NAN;
if(!get(MGL_DISABLE_SCALE)) pos[0]=(qq.u*nn.y-qq.v*nn.x>0) ? 'T':'t';
if(aa.ch=='T' && pos[0]=='T') pos[0]='t';
if(aa.ch=='T' && pos[0]=='t') pos[0]='T';
- text_plot(kk[i], aa.txt[i].text.c_str(), pos, -1, 0.07,CDef,tet?false:true);
+ text_plot(kk[i], aa.txt[i].text.c_str(), pos, -1, aa.sh+0.07,CDef,tet?false:true);
}
delete []w; delete []kk;
}
// try to exclude ticks out of axis range
if(f && ((o.x-Min.x)*(o.x-Max.x)>0 || (o.y-Min.y)*(o.y-Max.y)>0 || (o.z-Min.z)*(o.z-Max.z)>0))
return;
- float v = font_factor*TickLen/sqrt(1+f*st_t);
+ mreal v = font_factor*TickLen/sqrt(1.f+f*st_t);
mglPoint p=o;
long k1,k2,k3=mgl_have_color(stl);
oa = aa.b*(aa.b*aa.org); ob = aa.a*(aa.a*aa.org);
register long i,j,n=aa.txt.size(),k1,k2;
- float v;
+ mreal v;
Reserve(62*n);
if(n>0) for(i=0;i<n;i++)
}
}
//-----------------------------------------------------------------------------
-void mglCanvas::Label(char dir, const char *str, float pos, float shift)
+void mglCanvas::Label(char dir, const char *str, mreal pos, mreal shift)
{
unsigned s = strlen(str)+1;
wchar_t *wcs = new wchar_t[s];
delete []wcs;
}
//-----------------------------------------------------------------------------
-void mglCanvas::Labelw(char dir, const wchar_t *text, float pos, float shift)
+void mglCanvas::Labelw(char dir, const wchar_t *text, mreal pos, mreal shift)
{
- float t, x0, y0, z0;
+ mreal t, x0, y0, z0;
x0 = GetOrgX(dir); y0 = GetOrgY(dir); z0 = GetOrgZ(dir);
mglPoint p,ss=(Min+Max)/2,q,qq,nn;
if(ax.dv) t = (Min.x+Max.x+pos*(Max.x-Min.x))/2;
else t = Min.x*pow(Max.x/Min.x, (pos+1)/2);
nn = mglPoint(0,ss.y-y0,ss.z-z0);
- p = mglPoint(t,y0,z0); q = mglPoint(1,0,0);
+ p = mglPoint(t,y0,z0); q = mglPoint(1,0,0); shift += ax.sh;
}
if(dir=='y')
{
if(ay.dv) t = (Min.y+Max.y+pos*(Max.y-Min.y))/2;
else t = Min.y*pow(Max.y/Min.y, (pos+1)/2);
nn = mglPoint(ss.x-x0,0,ss.z-z0);
- p = mglPoint(x0,t,z0); q = mglPoint(0,1,0);
+ p = mglPoint(x0,t,z0); q = mglPoint(0,1,0); shift += ay.sh;
if(TernAxis&3)
{
q = mglPoint(-1,1,0); pos=-pos;
if(ay.dv) t = (Min.y+Max.y+pos*(Max.y-Min.y))/2;
else t = Min.y*pow(Max.y/Min.y, (pos+1)/2);
nn = mglPoint(ss.x-x0,0,ss.z-z0);
- p = mglPoint(x0,t,z0); q = mglPoint(0,1,0);
+ p = mglPoint(x0,t,z0); q = mglPoint(0,1,0); shift += ay.sh;
}
if(dir=='z')
{
if(az.dv) t = (Min.z+Max.z+pos*(Max.z-Min.z))/2;
else t = Min.z*pow(Max.z/Min.z, (pos+1)/2);
nn = mglPoint(ss.x-x0,ss.y-y0,0);
- p = mglPoint(x0,y0,t); q = mglPoint(0,0,1);
+ p = mglPoint(x0,y0,t); q = mglPoint(0,0,1); shift += az.sh;
}
ss = p; ScalePoint(ss,nn,false);
char font[33],ff[3]=":C";
text_plot(AddPnt(p,-1,q,0,7),text,font,-1.4,0.35+shift);
}
//-----------------------------------------------------------------------------
-void mglCanvas::Label(float x, float y, const char *str, const char *font, bool rel)
-{
- unsigned s = strlen(str)+1;
- wchar_t *wcs = new wchar_t[s];
- mbstowcs(wcs,str,s);
- Labelw(x,y,wcs, font, rel);
- delete []wcs;
-}
-//-----------------------------------------------------------------------------
-void mglCanvas::Labelw(float x, float y, const wchar_t *text, const char *font, bool rel)
-{
- Push(); Identity(rel);
- mglFormula *ox=fx, *oy=fy, *oz=fz;
- fx = fy = fz = NULL;
- char *f = new char[strlen(font)+1]; memset(f,0,strlen(font)+1);
- strcpy(f,font);
- for(int i=0;f[i];i++) if(f[i]=='a' || f[i]=='A') f[i]=' ';
- mglPoint p((Min.x+Max.x)/2+B.pf*(Max.x-Min.x)*(x-0.5),
- (Min.y+Max.y)/2+B.pf*(Max.y-Min.y)*(y-0.5), Max.z);
- text_plot(AddPnt(p,-1,mglPoint(NAN),0,7),text,f,-1.4,1);
- delete []f; fx=ox; fy=oy; fz=oz; Pop();
-}
-//-----------------------------------------------------------------------------
void mglCanvas::Box(const char *col, bool ticks)
{
mglPoint o = Org;
- float tl=TickLen;
+ mreal tl=TickLen;
if(!ticks) TickLen=0;
- Org = Min; Axis("xyz_",col);
+ set(MGL_NOSUBTICKS); Org = Min;
+ Axis("xyz_",col);
if(TernAxis&1)
{
Org.z=Max.z; Org.x=Max.x; Axis("xz_",col);
mglPoint p[8]={Min,Min,Min,Min,Max,Max,Max,Max},nan=mglPoint(NAN),oo[8];
p[1].x=Max.x; p[2].y=Max.y; p[3].z=Max.z;
p[4].x=Min.x; p[5].y=Min.y; p[6].z=Min.z;
- float zm=1e5; int im=0;
+ mreal zm=1e5; int im=0;
memcpy(oo,p,8*sizeof(mglPoint));
for(int i=0;i<8;i++) // find deepest point
{
mgl_facez(this, Min.x, Min.y, oo[im].z, Max.x-Min.x, Max.y-Min.y, color,0,0);
}
}
- Org=o; TickLen=tl;
+ clr(MGL_NOSUBTICKS); Org=o; TickLen=tl;
}
//-----------------------------------------------------------------------------
void mglCanvas::Colorbar(const char *sch)
{
bool in = sch && strchr(sch,'I');
- float s=1/B.pf, x=1, y=0;
+ mreal s=1/B.pf, x=1, y=0;
if(sch && strchr(sch,'>')) { x=in?(1+s)/2:1; y=0; }
if(sch && strchr(sch,'<')) { x=in?(1-s)/2:0; y=0; }
if(sch && strchr(sch,'^')) { x=0; y=in?(1+s)/2:1; }
Colorbar(sch, x, y, 1, 1);
}
//-----------------------------------------------------------------------------
-void mglCanvas::Colorbar(const char *sch, float x, float y, float w, float h)
+void mglCanvas::Colorbar(const char *sch, mreal x, mreal y, mreal w, mreal h)
{
bool in = sch && strchr(sch,'I');
int where = 0; // ‘0’ - right, ‘1’ - left, ‘2’ - above, ‘3’ - under
{ v.Fill(log(Min.c), log(Max.c)); v.Modify("exp(u)"); }
else if(Min.c<Max.c && Max.c<0)
{ v.Fill(log(-Min.c), log(-Max.c)); v.Modify("-exp(u)"); }
- float *c=new float[n];
+ mreal *c=new mreal[n];
for(long i=0;i<n;i++) c[i] = GetC(s,v.a[i]);
colorbar(&v, c, where, x, y, w, h);
delete []c;
void mglCanvas::Colorbar(HCDT v, const char *sch)
{
bool in = sch && strchr(sch,'I');
- float s=1/B.pf, x=1, y=0;
+ mreal s=1/B.pf, x=1, y=0;
if(sch && strchr(sch,'>')) { x=in?(1+s)/2:1; y=0; }
if(sch && strchr(sch,'<')) { x=in?(1-s)/2:0; y=0; }
if(sch && strchr(sch,'^')) { x=0; y=in?(1+s)/2:1; }
Colorbar(v, sch, x, y, 1, 1);
}
//-----------------------------------------------------------------------------
-void mglCanvas::Colorbar(HCDT v, const char *sch, float x, float y, float w, float h)
+void mglCanvas::Colorbar(HCDT v, const char *sch, mreal x, mreal y, mreal w, mreal h)
{
bool in = sch && strchr(sch,'I');
int where = 0;
if(sch && strchr(sch,'_')) where = in?2:3;
if(sch && strchr(sch,'A')) { Push(); Identity(); }
- float *c=new float[v->GetNx()];
+ mreal *c=new mreal[v->GetNx()];
if(!mgl_have_color(sch)) sch = MGL_DEF_PAL;
long s = AddTexture(sch);
int nc = GetNumPal(s*256);
- float dc = nc>1 ? 1/(MGL_FLT_EPS*(nc-1)):0;
+ mreal dc = nc>1 ? 1/(MGL_EPSILON*(nc-1)):0;
for(long i=0;i<v->GetNx();i++) c[i] = s+i*dc;
colorbar(v, c, where, x, y, w, h);
delete []c;
if(sch && strchr(sch,'A')) Pop();
}
//-----------------------------------------------------------------------------
-void mglCanvas::colorbar(HCDT vv, const float *c, int where, float x, float y, float w, float h)
+void mglCanvas::colorbar(HCDT vv, const mreal *c, int where, mreal x, mreal y, mreal w, mreal h)
{
static int cgid=1; StartGroup("Colorbar",cgid++);
register unsigned long i,n=vv->GetNx();
long n1,n2,n3,n4;
- float d,s3=B.pf,ss=1/s3; // NOTE: colorbar was wider ss=0.9;
+ mreal d,s3=B.pf,ss=1/s3; // NOTE: colorbar was wider ss=0.9;
mglPoint p1,p2;
Push(); set(MGL_DISABLE_SCALE); B=B1; B.pf=s3;
}
else { UpdateAxis(); AdjustTicks(ac,fa); }
// hint for using standard label drawing function
- float cc=AddTexture('k');
+ mreal cc=AddTexture('k');
for(i=0;i<ac.txt.size();i++)
{
d = ac.txt[i].val = GetA(ac.txt[i].val)*2-1;
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdlib.h>\r
#include "mgl2/base.h"\r
#include "mgl2/define.h"\r
//-----------------------------------------------------------------------------\r
fnt=0; *FontDef=0;\r
fx=fy=fz=fa=fc=0;\r
\r
- InUse = 1;\r
+ InUse = 1; SetQuality();\r
// Always create default palette txt[0] and default scheme txt[1]\r
Txt.reserve(3);\r
Txt.push_back(mglTexture(MGL_DEF_PAL,-1));\r
}\r
mglBase::~mglBase() { ClearEq(); }\r
//-----------------------------------------------------------------------------\r
-float mglBase::GetRatio() const { return 1; }\r
+mreal mglBase::GetRatio() const { return 1; }\r
//-----------------------------------------------------------------------------\r
void mglBase::StartGroup(const char *name, int id)\r
{\r
WarnCode = code>0 ? code:0;\r
if(code>0 && code<mglWarnEnd)\r
{\r
- if(who) Mess = Mess+"\n"+who+": ";\r
+ if(who && *who) Mess = Mess+"\n"+who+": ";\r
else Mess += "\n";\r
Mess = Mess+mglWarn[code-1];\r
}\r
else if(!code) Mess="";\r
- else if(who) Mess = Mess+(code==-2?"":"\n")+who;\r
+ else if(who && *who) Mess = Mess+(code==-2?"":"\n")+who;\r
LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
// Add points to the buffer\r
//-----------------------------------------------------------------------------\r
-long mglBase::AddPnt(mglPoint p, float c, mglPoint n, float a, int scl)\r
+long mglBase::AddPnt(mglPoint p, mreal c, mglPoint n, mreal a, int scl)\r
{\r
+ if(mgl_isnan(c) || mgl_isnan(a)) return -1;\r
if(scl>0) ScalePoint(p,n,!(scl&2));\r
if(mgl_isnan(p.x)) return -1;\r
a = (a>=0 && a<=1) ? a : AlphaDef;\r
q.x=q.xx=p.x; q.y=q.yy=p.y; q.z=q.zz=p.z;\r
q.c=c; q.t=q.ta=a; q.u=n.x; q.v=n.y; q.w=n.z;\r
}\r
-// q.x=q.xx=int(p.x*100)*0.01; q.y=q.yy=p.y; q.z=q.zz=p.z;\r
-// q.c=c; q.t=q.ta=a; q.u=n.x; q.v=n.y; q.w=n.z;\r
- const mglTexture &txt=Txt[long(c)];\r
+ register long ci=long(c);\r
+ if(ci<0 || ci>=Txt.size()) ci=0; // NOTE never should be here!!!\r
+ const mglTexture &txt=Txt[ci];\r
txt.GetC(c,a,q); // RGBA color\r
\r
- if(!get(MGL_ENABLE_ALPHA)) { q.a=1; if(txt.Smooth!=2) q.ta=1; }\r
- if(q.ta<0.005) q.ta = 0.005; // bypass OpenGL/OBJ/PRC bug\r
+ // add gap for texture coordinates for compatibility with OpenGL\r
+ const mreal gap = 1./512;\r
+ q.c = ci+(q.c-ci)*(1-2*gap)+gap;\r
+ q.t = q.t*(1-2*gap)+gap;\r
+ q.ta = q.t;\r
+ \r
+ if(!get(MGL_ENABLE_ALPHA)) { q.a=1; if(txt.Smooth!=2) q.ta=1-gap; }\r
+// if(q.ta<0.005) q.ta = 0.005; // bypass OpenGL/OBJ/PRC bug\r
if(scl&8 && scl>0) q.a=a; // bypass palette for enabling alpha in Error()\r
if(!get(MGL_ENABLE_LIGHT) && !(scl&4)) q.u=q.v=NAN;\r
MGL_PUSH(Pnt,q,mutexPnt); return Pnt.size()-1;\r
}\r
//-----------------------------------------------------------------------------\r
-long mglBase::CopyNtoC(long from, float c)\r
+long mglBase::CopyNtoC(long from, mreal c)\r
{\r
if(from<0) return -1;\r
mglPnt p=Pnt[from];\r
{\r
FMin.c = 1e30; FMax.c = -1e30;\r
register int i;\r
- float a;\r
+ mreal a;\r
int n=30;\r
for(i=0;i<=n;i++)\r
{\r
//-----------------------------------------------------------------------------\r
void mglBase::RecalcBorder()\r
{\r
- if(!fx && !fy && !fz)\r
+ ZMin = 1.;\r
+ if(!fx && !fy && !fz)\r
{ FMin = Min; FMax = Max; }\r
else\r
{\r
SetFBord(Min.x+i*(Max.x-Min.x)/n, Min.y+j*(Max.y-Min.y)/n, Min.x);\r
SetFBord(Min.x+i*(Max.x-Min.x)/n, Min.y+j*(Max.y-Min.y)/n, Max.z);\r
}\r
- float d;\r
+ mreal d;\r
if(!fx) { FMin.x = Min.x; FMax.x = Max.x; }\r
else { d=0.01*(FMax.x-FMin.x); FMin.x-=d; FMax.x+=d; }\r
if(!fy) { FMin.y = Min.y; FMax.y = Max.y; }\r
RecalcCRange();\r
}\r
//-----------------------------------------------------------------------------\r
-void mglBase::SetFBord(float x,float y,float z)\r
+void mglBase::SetFBord(mreal x,mreal y,mreal z)\r
{\r
if(fx)\r
{\r
- float v = fx->Calc(x,y,z);\r
+ mreal v = fx->Calc(x,y,z);\r
if(FMax.x < v) FMax.x = v;\r
if(FMin.x > v) FMin.x = v;\r
}\r
if(fy)\r
{\r
- float v = fy->Calc(x,y,z);\r
+ mreal v = fy->Calc(x,y,z);\r
if(FMax.y < v) FMax.y = v;\r
if(FMin.y > v) FMin.y = v;\r
}\r
if(fz)\r
{\r
- float v = fz->Calc(x,y,z);\r
+ mreal v = fz->Calc(x,y,z);\r
if(FMax.z < v) FMax.z = v;\r
if(FMin.z > v) FMin.z = v;\r
}\r
//-----------------------------------------------------------------------------\r
bool mglBase::ScalePoint(mglPoint &p, mglPoint &n, bool use_nan) const\r
{\r
- float &x=p.x, &y=p.y, &z=p.z;\r
+ mreal &x=p.x, &y=p.y, &z=p.z;\r
if(mgl_isnan(x) || mgl_isnan(y) || mgl_isnan(z)) { x=NAN; return false; }\r
- float x1,y1,z1,x2,y2,z2;\r
- x1 = x>0?x*MGL_FLT_EPS:x/MGL_FLT_EPS; x2 = x<0?x*MGL_FLT_EPS:x/MGL_FLT_EPS;\r
- y1 = y>0?y*MGL_FLT_EPS:y/MGL_FLT_EPS; y2 = y<0?y*MGL_FLT_EPS:y/MGL_FLT_EPS;\r
- z1 = z>0?z*MGL_FLT_EPS:z/MGL_FLT_EPS; z2 = z<0?z*MGL_FLT_EPS:z/MGL_FLT_EPS;\r
+ mreal x1,y1,z1,x2,y2,z2;\r
+ x1 = x>0?x*MGL_EPSILON:x/MGL_EPSILON; x2 = x<0?x*MGL_EPSILON:x/MGL_EPSILON;\r
+ y1 = y>0?y*MGL_EPSILON:y/MGL_EPSILON; y2 = y<0?y*MGL_EPSILON:y/MGL_EPSILON;\r
+ z1 = z>0?z*MGL_EPSILON:z/MGL_EPSILON; z2 = z<0?z*MGL_EPSILON:z/MGL_EPSILON;\r
bool res = true;\r
if(x2>CutMin.x && x1<CutMax.x && y2>CutMin.y && y1<CutMax.y &&\r
z2>CutMin.z && z1<CutMax.z) res = false;\r
if(z2>Max.z) {z=Max.z; n=mglPoint(0,0,1);}\r
}\r
\r
- x1=x; y1=y; z1=z;\r
- if(fx) { x1 = fx->Calc(x,y,z); n.x *= fx->CalcD('x',x,y,z); }\r
- if(fy) { y1 = fy->Calc(x,y,z); n.y *= fy->CalcD('y',x,y,z); }\r
- if(fz) { z1 = fz->Calc(x,y,z); n.z *= fz->CalcD('z',x,y,z); }\r
- if(mgl_isnan(x1) || mgl_isnan(y1) || mgl_isnan(z1)) { x=NAN; return false; }\r
+ x1=x; y1=y; z1=z; x2=y2=z2=1;\r
+ if(fx) { x1 = fx->Calc(x,y,z); x2 = fx->CalcD('x',x,y,z); }\r
+ if(fy) { y1 = fy->Calc(x,y,z); y2 = fy->CalcD('y',x,y,z); }\r
+ if(fz) { z1 = fz->Calc(x,y,z); z2 = fz->CalcD('z',x,y,z); }\r
+ if(mgl_isnan(x1) || mgl_isnan(y1) || mgl_isnan(z1)) { x=NAN; return false; }\r
\r
- x = (2*x1 - FMin.x - FMax.x)/(FMax.x - FMin.x);\r
- y = (2*y1 - FMin.y - FMax.y)/(FMax.y - FMin.y);\r
- z = (2*z1 - FMin.z - FMax.z)/(FMax.z - FMin.z);\r
- n.x *= 2/(FMax.x - FMin.x);\r
- n.y *= 2/(FMax.y - FMin.y);\r
- n.z *= 2/(FMax.z - FMin.z);\r
- if((TernAxis&3)==1) // usual ternary axis\r
- {\r
- if(x+y>0)\r
- {\r
- if(get(MGL_ENABLE_CUT)) res = false;\r
- else y = -x;\r
- }\r
- x += (y+1)/2; n.x += n.y/2;\r
- }\r
- else if((TernAxis&3)==2) // quaternary axis\r
- {\r
- if(x+y+z>-1)\r
- {\r
- if(get(MGL_ENABLE_CUT)) res = false;\r
- else z = -1-y-x;\r
- }\r
- x += 1+(y+z)/2; y += (z+1)/3;\r
- n.x += (n.y+n.z)/2; n.y += n.z/3;\r
- }\r
- if(fabs(x)>MGL_FLT_EPS) res = false;\r
- if(fabs(y)>MGL_FLT_EPS) res = false;\r
- if(fabs(z)>MGL_FLT_EPS) res = false;\r
+ register mreal d; // TODO: should I update normale for infinite light source (x=NAN)?!?\r
+ d = 1/(FMax.x - FMin.x); x = (2*x1 - FMin.x - FMax.x)*d; x2 *= 2*d;\r
+ d = 1/(FMax.y - FMin.y); y = (2*y1 - FMin.y - FMax.y)*d; y2 *= 2*d;\r
+ d = 1/(FMax.z - FMin.z); z = (2*z1 - FMin.z - FMax.z)*d; z2 *= 2*d;\r
+ n.x *= y2*z2; n.y *= x2*z2; n.z *= x2*y2;\r
+ if((TernAxis&3)==1) // usual ternary axis\r
+ {\r
+ if(x+y>0)\r
+ {\r
+ if(get(MGL_ENABLE_CUT)) res = false;\r
+ else y = -x;\r
+ }\r
+ x += (y+1)/2; n.x += n.y/2;\r
+ }\r
+ else if((TernAxis&3)==2) // quaternary axis\r
+ {\r
+ if(x+y+z>-1)\r
+ {\r
+ if(get(MGL_ENABLE_CUT)) res = false;\r
+ else z = -1-y-x;\r
+ }\r
+ x += 1+(y+z)/2; y += (z+1)/3;\r
+ n.x += (n.y+n.z)/2; n.y += n.z/3;\r
+ }\r
+ if(fabs(x)>MGL_EPSILON || fabs(y)>MGL_EPSILON || fabs(z)>MGL_EPSILON) res = false;\r
\r
if(!res && use_nan) x = NAN; // extra sign that point shouldn't be plotted\r
return res;\r
RecalcBorder();\r
}\r
//-----------------------------------------------------------------------------\r
-void mglBase::CRange(const mglDataA &a,bool add, float fact)\r
+void mglBase::CRange(HCDT a,bool add, mreal fact)\r
{\r
- float v1=a.Minimal(), v2=a.Maximal(), dv;\r
+ mreal v1=a->Minimal(), v2=a->Maximal(), dv;\r
dv=(v2-v1)*fact; v1 -= dv; v2 += dv;\r
if(v1==v2) return;\r
if(!add) { Min.c = v1; Max.c = v2; }\r
RecalcCRange();\r
}\r
//-----------------------------------------------------------------------------\r
-void mglBase::XRange(const mglDataA &a,bool add,float fact)\r
+void mglBase::XRange(HCDT a,bool add,mreal fact)\r
{\r
- float v1=a.Minimal(), v2=a.Maximal(), dv;\r
+ mreal v1=a->Minimal(), v2=a->Maximal(), dv;\r
dv=(v2-v1)*fact; v1 -= dv; v2 += dv;\r
if(v1==v2) return;\r
if(!add) { Min.x = v1; Max.x = v2; }\r
RecalcBorder();\r
}\r
//-----------------------------------------------------------------------------\r
-void mglBase::YRange(const mglDataA &a,bool add,float fact)\r
+void mglBase::YRange(HCDT a,bool add,mreal fact)\r
{\r
- float v1=a.Minimal(), v2=a.Maximal(), dv;\r
+ mreal v1=a->Minimal(), v2=a->Maximal(), dv;\r
dv=(v2-v1)*fact; v1 -= dv; v2 += dv;\r
if(v1==v2) return;\r
if(!add) { Min.y = v1; Max.y = v2; }\r
RecalcBorder();\r
}\r
//-----------------------------------------------------------------------------\r
-void mglBase::ZRange(const mglDataA &a,bool add,float fact)\r
+void mglBase::ZRange(HCDT a,bool add,mreal fact)\r
{\r
- float v1=a.Minimal(), v2=a.Maximal(), dv;\r
+ mreal v1=a->Minimal(), v2=a->Maximal(), dv;\r
dv=(v2-v1)*fact; v1 -= dv; v2 += dv;\r
if(v1==v2) return;\r
if(!add) { Min.z = v1; Max.z = v2; }\r
RecalcBorder();\r
}\r
//-----------------------------------------------------------------------------\r
-void mglBase::SetAutoRanges(float x1, float x2, float y1, float y2, float z1, float z2, float c1, float c2)\r
+void mglBase::SetAutoRanges(mreal x1, mreal x2, mreal y1, mreal y2, mreal z1, mreal z2, mreal c1, mreal c2)\r
{\r
if(x1!=x2) { Min.x = x1; Max.x = x2; }\r
if(y1!=y2) { Min.y = y1; Max.y = y2; }\r
{ Set(mglColorIds[i].col, bright); break; }\r
}\r
//-----------------------------------------------------------------------------\r
-void mglTexture::Set(const char *s, int smooth, float alpha)\r
+void mglTexture::Set(const char *s, int smooth, mreal alpha)\r
{\r
// NOTE: New syntax -- colors are CCCCC or {CNCNCCCN}; options inside []\r
if(!s || !s[0]) return;\r
{ alpha = 0.1*(s[i+1]-'0'); i++; }\r
}\r
for(i=0;i<n;i++) // default texture\r
- { c[2*i+1]=c[2*i]; c[2*i].a=alpha; c[2*i+1].a=sm?0:alpha; }\r
+ { c[2*i+1]=c[2*i]; c[2*i].a=sm?0:alpha; c[2*i+1].a=alpha; }\r
if(map && sm) // map texture\r
{\r
if(n==2)\r
else\r
{ c[1]=c[4]; c[3]=c[6]; n=2; }\r
}\r
- register float u,v=sm?(n-1)/255.:n/256.;\r
- for(i=0;i<255;i++)\r
+ register mreal u,v=sm?(n-1)/255.:n/256.;\r
+ for(i=0;i<256;i++)\r
{\r
u = v*i; j = long(u); u-=j;\r
if(!sm || j==n-1)\r
col[2*i+1]=c[2*j+1]*(1-u)+c[2*j+3]*u;\r
}\r
}\r
- col[510]=col[508]; col[511]=col[509];\r
+// col[510]=col[508]; col[511]=col[509]; col[0]=col[2]; col[1]=col[3];\r
delete []c;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglTexture::GetC(float u,float v,mglPnt &p) const\r
+void mglTexture::GetC(mreal u,mreal v,mglPnt &p) const\r
{\r
u -= long(u);\r
register long i=long(255*u); u = u*255-i;\r
p.r = (s[0].r*(1-u)+s[2].r*u)*(1-v) + (s[1].r*(1-u)+s[3].r*u)*v;\r
p.g = (s[0].g*(1-u)+s[2].g*u)*(1-v) + (s[1].g*(1-u)+s[3].g*u)*v;\r
p.b = (s[0].b*(1-u)+s[2].b*u)*(1-v) + (s[1].b*(1-u)+s[3].b*u)*v;\r
- p.a = (s[0].a*(1-u)+s[2].a*u)*v + (s[1].a*(1-u)+s[3].a*u)*(1-v); // for alpha use inverted\r
+ p.a = (s[0].a*(1-u)+s[2].a*u)*(1-v) + (s[1].a*(1-u)+s[3].a*u)*v;\r
+// p.a = (s[0].a*(1-u)+s[2].a*u)*v + (s[1].a*(1-u)+s[3].a*u)*(1-v); // for alpha use inverted\r
}\r
//-----------------------------------------------------------------------------\r
long mglBase::AddTexture(const char *cols, int smooth)\r
MGL_PUSH(Txt,t,mutexTxt); return Txt.size()-1;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglBase::AddTexture(mglColor c)\r
+mreal mglBase::AddTexture(mglColor c)\r
{\r
register unsigned long i,j;\r
if(!c.Valid()) return -1;\r
//-----------------------------------------------------------------------------\r
// Coloring and palette\r
//-----------------------------------------------------------------------------\r
-float mglBase::NextColor(long &id)\r
+mreal mglBase::NextColor(long &id)\r
{\r
long i=abs(id)/256, n=Txt[i].n, p=abs(id)&0xff;\r
if(id>=0) { p=(p+1)%n; id = 256*i+p; }\r
mglColor c = Txt[i].col[int(512*(p+0.5)/n)];\r
- float dif, dmin=1;\r
+ mreal dif, dmin=1;\r
// try to find closest color\r
for(long j=0;mglColorIds[j].id;j++) for(long k=1;k<10;k++)\r
{\r
return mk;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglBase::GetA(float a) const\r
+mreal mglBase::GetA(mreal a) const\r
{\r
if(fa) a = fa->Calc(0,0,0,a);\r
a = (a-FMin.c)/(FMax.c-FMin.c);\r
- a = (a<1?(a>0?a:0):1)/MGL_FLT_EPS; // for texture a must be <1 always!!!\r
+ a = (a<1?(a>0?a:0):1)/MGL_EPSILON; // for texture a must be <1 always!!!\r
return a;\r
}\r
//-----------------------------------------------------------------------------\r
-mglPoint GetX(const mglDataA *x, int i, int j, int k)\r
+mglPoint GetX(HCDT x, int i, int j, int k)\r
{\r
k = k<x->GetNz() ? k : 0;\r
if(x->GetNy()>1)\r
return mglPoint(x->v(i),x->dvx(i),0);\r
}\r
//-----------------------------------------------------------------------------\r
-mglPoint GetY(const mglDataA *y, int i, int j, int k)\r
+mglPoint GetY(HCDT y, int i, int j, int k)\r
{\r
k = k<y->GetNz() ? k : 0;\r
if(y->GetNy()>1)\r
return mglPoint(y->v(j),0,y->dvx(j));\r
}\r
//-----------------------------------------------------------------------------\r
-mglPoint GetZ(const mglDataA *z, int i, int j, int k)\r
+mglPoint GetZ(HCDT z, int i, int j, int k)\r
{\r
if(z->GetNy()>1)\r
return mglPoint(z->v(i,j,k),z->dvx(i,j,k),z->dvy(i,j,k));\r
return mglPoint(z->v(k),0,0);\r
}\r
//-----------------------------------------------------------------------------\r
-void mglBase::vect_plot(long p1, long p2, float s)\r
+void mglBase::vect_plot(long p1, long p2, mreal s)\r
{\r
if(p1<0 || p2<0) return;\r
const mglPnt &q1=Pnt[p1], &q2=Pnt[p2];\r
if(str[i]=='\'') l++;\r
if(str[i]=='{') k++;\r
if(str[i]=='}') k--;\r
- if(l%2==0 && k==0 && (str[i]=='#' || str[i]==';')) return -i;\r
- if(l%2==0 && k==0 && (str[i]<=' ')) return i;\r
+ if(l%2==0 && k==0)\r
+ {\r
+ if(str[i]=='#' || str[i]==';') return -i;\r
+ if(str[i]<=' ') return i;\r
+ }\r
}\r
return 0;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglBase::SetAmbient(float bright) { AmbBr = bright; }\r
+void mglBase::SetAmbient(mreal bright) { AmbBr = bright; }\r
//-----------------------------------------------------------------------------\r
-float mglBase::SaveState(const char *opt)\r
+mreal mglBase::SaveState(const char *opt)\r
{\r
if(!opt || !opt[0] || saved) return NAN;\r
MSS=MarkSize; ASS=ArrowSize;\r
MNS=MeshNum; CSS=Flag; LSS=AmbBr;\r
MinS=Min; MaxS=Max; saved=true;\r
// parse option\r
- char *q=mgl_strdup(opt),*s,*a,*b,*c;\r
+ char *qi=mgl_strdup(opt),*q=qi, *s,*a,*b,*c;\r
long n;\r
mgl_strtrim(q);\r
// NOTE: not consider '#' inside legend entry !!!\r
n=mglFindArg(s); if(n>0) { s[n]=0; s=s+n+1; }\r
mgl_strtrim(b);\r
\r
- float ff=atof(b),ss;\r
+ mreal ff=atof(b),ss;\r
if(!strcmp(b,"on")) ff=1;\r
if(!strcmp(a+1,"range"))\r
{\r
else if(!strcmp(a,"legend"))\r
{ if(*b=='\'') { b++; b[strlen(b)-1]=0; } leg_str = b; }\r
}\r
- free(q); return NAN;\r
+ free(qi); return NAN;\r
}\r
//-----------------------------------------------------------------------------\r
void mglBase::LoadState()\r
delete []wcs;\r
}\r
//-----------------------------------------------------------------------------\r
+bool mgl_check_dim2(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *name, bool less)\r
+{\r
+ register long n=z->GetNx(),m=z->GetNy();\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,name); return true; }\r
+ if(a && n*m*z->GetNz()!=a->GetNx()*a->GetNy()*a->GetNz())\r
+ { gr->SetWarn(mglWarnDim,name); return true; }\r
+ if(less)\r
+ {\r
+ if(x->GetNx()<n)\r
+ { gr->SetWarn(mglWarnDim,name); return true; }\r
+ if(y->GetNx()<m && (x->GetNy()<m || y->GetNx()<n || y->GetNy()<m))\r
+ { gr->SetWarn(mglWarnDim,name); return true; };\r
+ }\r
+ else\r
+ {\r
+ if(x->GetNx()!=n)\r
+ { gr->SetWarn(mglWarnDim,name); return true; }\r
+ if(y->GetNx()!=m && (x->GetNy()!=m || y->GetNx()!=n || y->GetNy()!=m))\r
+ { gr->SetWarn(mglWarnDim,name); return true; };\r
+ }\r
+ return false;\r
+}\r
+//-----------------------------------------------------------------------------\r
+bool mgl_check_dim1(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT r, const char *name, bool less)\r
+{\r
+ register long n=y->GetNx();\r
+ if(n<2) { gr->SetWarn(mglWarnLow,name); return true; }\r
+ if(less)\r
+ {\r
+ if(x->GetNx()<n) { gr->SetWarn(mglWarnDim,name); return true; }\r
+ if(z && z->GetNx()<n) { gr->SetWarn(mglWarnDim,name); return true; }\r
+ if(r && r->GetNx()<n) { gr->SetWarn(mglWarnDim,name); return true; }\r
+ }\r
+ else\r
+ {\r
+ if(x->GetNx()!=n) { gr->SetWarn(mglWarnDim,name); return true; }\r
+ if(z && z->GetNx()!=n) { gr->SetWarn(mglWarnDim,name); return true; }\r
+ if(r && r->GetNx()!=n) { gr->SetWarn(mglWarnDim,name); return true; }\r
+ }\r
+ return false;\r
+}\r
+//-----------------------------------------------------------------------------\r
+bool mgl_check_dim3(HMGL gr, bool both, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *name)\r
+{\r
+ register long n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
+ if(n<2 || m<2 || l<2)\r
+ { gr->SetWarn(mglWarnLow,name); return true; }\r
+ if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
+ { gr->SetWarn(mglWarnDim,name); return true; }\r
+ if(b && b->GetNx()*b->GetNy()*b->GetNz()!=n*m*l)\r
+ { gr->SetWarn(mglWarnDim,name); return true; }\r
+ return false;\r
+}\r
+//-----------------------------------------------------------------------------\r
+bool mgl_check_trig(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, HCDT a, const char *name, int d)\r
+{\r
+ long n = x->GetNx(), m = nums->GetNy();\r
+ if(nums->GetNx()<d) { gr->SetWarn(mglWarnLow,name); return true; }\r
+ if(y->GetNx()!=n || z->GetNx()!=n) { gr->SetWarn(mglWarnDim,name); return true; }\r
+ if(a->GetNx()!=m && a->GetNx()!=n) { gr->SetWarn(mglWarnDim,name); return true; }\r
+ return false;\r
+}\r
+//-----------------------------------------------------------------------------\r
+bool mgl_isboth(HCDT x, HCDT y, HCDT z, HCDT a)\r
+{\r
+ register long n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
+ return x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
+}\r
+//-----------------------------------------------------------------------------\r
+bool mgl_check_vec3(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *name)\r
+{\r
+ register long n=ax->GetNx(),m=ax->GetNy(),l=ax->GetNz();\r
+ if(n*m*l!=ay->GetNx()*ay->GetNy()*ay->GetNz() || n*m*l!=az->GetNx()*az->GetNy()*az->GetNz())\r
+ { gr->SetWarn(mglWarnDim,name); return true; }\r
+ if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,name); return true; }\r
+ bool both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
+ if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
+ { gr->SetWarn(mglWarnDim,name); return true; }\r
+ return false;\r
+}\r
+//-----------------------------------------------------------------------------\r
// C interfaces\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_set_color(char id, float r, float g, float b)\r
+int mgl_get_flag(HMGL gr, long flag) { return gr->get(flag); }\r
+void mgl_set_flag(HMGL gr, int val, long flag) { gr->set(val,flag); }\r
+//-----------------------------------------------------------------------------\r
+void mgl_set_color(char id, mreal r, mreal g, mreal b)\r
{\r
register size_t i;\r
for(i=0;mglColorIds[i].id;i++) if(mglColorIds[i].id==id) mglColorIds[i].col = mglColor(r,g,b);\r
}\r
-void mgl_set_color_(char *id, float *r, float *g, float *b, int) { mgl_set_color(*id,*r,*g,*b); }\r
+void mgl_set_color_(char *id, mreal *r, mreal *g, mreal *b, int) { mgl_set_color(*id,*r,*g,*b); }\r
//-----------------------------------------------------------------------------\r
void mgl_set_def_sch(HMGL gr, const char *sch) { gr->SetDefScheme(sch); }\r
void mgl_set_def_sch_(uintptr_t *gr, const char *sch,int l)\r
int mgl_get_warn(HMGL gr) { return gr->GetWarn(); }\r
void mgl_set_warn(HMGL gr, int code, const char *txt)\r
{ gr->SetWarn(code,txt); }\r
-void mgl_set_origin(HMGL gr, float x0, float y0, float z0)\r
+void mgl_set_origin(HMGL gr, mreal x0, mreal y0, mreal z0)\r
{ gr->SetOrigin(x0,y0,z0); }\r
void mgl_set_palette(HMGL gr, const char *colors)\r
{ gr->SetPalette(colors); }\r
void mgl_set_meshnum(HMGL gr, int num) { gr->SetMeshNum(num); }\r
-void mgl_set_alpha_default(HMGL gr, float alpha) { gr->SetAlphaDef(alpha); }\r
+void mgl_set_alpha_default(HMGL gr, mreal alpha) { gr->SetAlphaDef(alpha); }\r
void mgl_set_light_dif(HMGL gr, int enable) { gr->SetDifLight(enable); }\r
//-----------------------------------------------------------------------------\r
void mgl_set_rdc_acc(HMGL gr, int reduce) { gr->SetReduceAcc(reduce); }\r
void mgl_highlight(HMGL gr, int id) { gr->Highlight(id); }\r
void mgl_set_cut(HMGL gr, int cut) { gr->SetCut(cut); }\r
-void mgl_set_cut_box(HMGL gr, float x1,float y1,float z1,float x2,float y2,float z2)\r
+void mgl_set_cut_box(HMGL gr, mreal x1,mreal y1,mreal z1,mreal x2,mreal y2,mreal z2)\r
{ gr->SetCutBox(x1,y1,z1,x2,y2,z2); }\r
void mgl_set_cutoff(HMGL gr, const char *EqC) { gr->CutOff(EqC); }\r
//-----------------------------------------------------------------------------\r
void mgl_set_ternary(HMGL gr, int enable) { gr->Ternary(enable); }\r
-void mgl_set_range_val(HMGL gr, char dir, float v1,float v2)\r
+void mgl_set_range_val(HMGL gr, char dir, mreal v1,mreal v2)\r
{\r
if(dir=='c') gr->CRange(v1,v2);\r
else if(dir=='x') gr->XRange(v1,v2);\r
else if(dir=='z') gr->ZRange(v1,v2); }\r
void mgl_set_range_dat(HMGL gr, char dir, HCDT a, int add)\r
{\r
- if(dir=='c') gr->CRange(_Da_(a),add);\r
- else if(dir=='x') gr->XRange(_Da_(a),add);\r
- else if(dir=='y') gr->YRange(_Da_(a),add);\r
- else if(dir=='z') gr->ZRange(_Da_(a),add); }\r
-void mgl_set_ranges(HMGL gr, float x1, float y1, float z1, float x2, float y2, float z2)\r
+ if(dir=='c') gr->CRange(a,add);\r
+ else if(dir=='x') gr->XRange(a,add);\r
+ else if(dir=='y') gr->YRange(a,add);\r
+ else if(dir=='z') gr->ZRange(a,add); }\r
+void mgl_set_ranges(HMGL gr, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2)\r
{ gr->SetRanges(x1,y1,z1,x2,y2,z2); }\r
void mgl_set_func(HMGL gr, const char *EqX,const char *EqY,const char *EqZ,const char *EqA)\r
{ gr->SetFunc(EqX,EqY,EqZ,EqA); }\r
void mgl_set_coor(HMGL gr, int how) { gr->SetCoor(how); }\r
//-----------------------------------------------------------------------------\r
-long mgl_data_get_nx(HCDT d) { return _Da_(d).GetNx(); }\r
-long mgl_data_get_ny(HCDT d) { return _Da_(d).GetNy(); }\r
-long mgl_data_get_nz(HCDT d) { return _Da_(d).GetNz(); }\r
+long mgl_data_get_nx(HCDT d) { return d->GetNx(); }\r
+long mgl_data_get_ny(HCDT d) { return d->GetNy(); }\r
+long mgl_data_get_nz(HCDT d) { return d->GetNz(); }\r
//-----------------------------------------------------------------------------\r
-void mgl_set_bar_width(HMGL gr, float width) { gr->SetBarWidth(width); }\r
+void mgl_set_bar_width(HMGL gr, mreal width) { gr->SetBarWidth(width); }\r
//-----------------------------------------------------------------------------\r
//\r
// Fortran interfaces\r
void mgl_set_rdc_acc_(uintptr_t *gr, int *reduce)\r
{ _GR_->SetReduceAcc(*reduce); }\r
void mgl_highlight_(uintptr_t *gr, int *id) { _GR_->Highlight(*id); }\r
-void mgl_set_origin_(uintptr_t *gr, float *x0, float *y0, float *z0)\r
+void mgl_set_origin_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0)\r
{ _GR_->SetOrigin(*x0,*y0,*z0); }\r
int mgl_get_warn_(uintptr_t *gr) { return _GR_->GetWarn(); }\r
void mgl_set_warn_(uintptr_t *gr, int *code, const char *txt, int l)\r
{ char *s=new char[l+1]; memcpy(s,colors,l); s[l]=0;\r
_GR_->SetPalette(s); delete []s; }\r
void mgl_set_meshnum_(uintptr_t *gr, int *num) { _GR_->SetMeshNum(*num); }\r
-void mgl_set_alpha_default_(uintptr_t *gr, float *alpha) { _GR_->SetAlphaDef(*alpha); }\r
+void mgl_set_alpha_default_(uintptr_t *gr, mreal *alpha) { _GR_->SetAlphaDef(*alpha); }\r
void mgl_set_light_dif_(uintptr_t *gr, int *enable) { _GR_->SetDifLight(*enable); }\r
//-----------------------------------------------------------------------------\r
-void mgl_set_cut_box_(uintptr_t *gr, float *x1,float *y1,float *z1,float *x2,float *y2,float *z2)\r
+void mgl_set_cut_box_(uintptr_t *gr, mreal *x1,mreal *y1,mreal *z1,mreal *x2,mreal *y2,mreal *z2)\r
{ _GR_->SetCutBox(*x1,*y1,*z1,*x2,*y2,*z2); }\r
void mgl_set_cut_(uintptr_t *gr, int *cut) { _GR_->SetCut(*cut); }\r
void mgl_set_cutoff_(uintptr_t *gr, const char *EqC, int l)\r
_GR_->CutOff(s); delete []s; }\r
//-----------------------------------------------------------------------------\r
void mgl_set_ternary_(uintptr_t *gr, int *enable) { _GR_->Ternary(*enable); }\r
-void mgl_set_range_val_(uintptr_t *gr, const char *dir, float *v1,float *v2,int)\r
-{\r
- if(*dir=='c') _GR_->CRange(*v1,*v2);\r
- else if(*dir=='x') _GR_->XRange(*v1,*v2);\r
- else if(*dir=='y') _GR_->YRange(*v1,*v2);\r
- else if(*dir=='z') _GR_->ZRange(*v1,*v2); }\r
+void mgl_set_range_val_(uintptr_t *gr, const char *dir, mreal *v1,mreal *v2,int)\r
+{ mgl_set_range_val(_GR_,*dir,*v1,*v2); }\r
void mgl_set_range_dat_(uintptr_t *gr, const char *dir, uintptr_t *a, int *add,int)\r
-{\r
- if(*dir=='c') _GR_->CRange(*_DA_(a),*add);\r
- else if(*dir=='x') _GR_->XRange(*_DA_(a),*add);\r
- else if(*dir=='y') _GR_->YRange(*_DA_(a),*add);\r
- else if(*dir=='z') _GR_->ZRange(*_DA_(a),*add); }\r
-void mgl_set_ranges_(uintptr_t *gr, float *x1, float *y1, float *z1, float *x2, float *y2, float *z2)\r
+{ mgl_set_range_dat(_GR_,*dir,_DA_(a),*add); }\r
+void mgl_set_ranges_(uintptr_t *gr, mreal *x1, mreal *y1, mreal *z1, mreal *x2, mreal *y2, mreal *z2)\r
{ _GR_->SetRanges(*x1,*y1,*z1,*x2,*y2,*z2); }\r
void mgl_set_func_(uintptr_t *gr, const char *EqX,const char *EqY,const char *EqZ,const char *EqA,int lx,int ly,int lz,int la)\r
{\r
void mgl_set_tick_skip_(uintptr_t *gr, int *enable) { _GR_->SetTickSkip(*enable); }\r
//-----------------------------------------------------------------------------\r
void mgl_set_rotated_text(HMGL gr, int enable) { gr->SetRotatedText(enable); }\r
-void mgl_set_mark_size(HMGL gr, float size) { gr->SetMarkSize(size); }\r
-void mgl_set_arrow_size(HMGL gr, float size) { gr->SetArrowSize(size); }\r
-void mgl_set_font_size(HMGL gr, float size) { gr->SetFontSize(size); }\r
+void mgl_set_mark_size(HMGL gr, mreal size) { gr->SetMarkSize(size); }\r
+void mgl_set_arrow_size(HMGL gr, mreal size) { gr->SetArrowSize(size); }\r
+void mgl_set_font_size(HMGL gr, mreal size) { gr->SetFontSize(size); }\r
void mgl_set_font_def(HMGL gr, const char *fnt) { gr->SetFontDef(fnt); }\r
void mgl_load_font(HMGL gr, const char *name, const char *path)\r
{ if(name && *name) gr->GetFont()->Load(name,path); else gr->GetFont()->Restore(); }\r
void mgl_copy_font(HMGL gr, HMGL gr_from) { gr->GetFont()->Copy(gr_from->GetFont()); }\r
void mgl_restore_font(HMGL gr) { gr->GetFont()->Restore(); }\r
//-----------------------------------------------------------------------------\r
-void mgl_set_bar_width_(uintptr_t *gr, float *width) { _GR_->SetBarWidth(*width); }\r
+void mgl_set_bar_width_(uintptr_t *gr, mreal *width) { _GR_->SetBarWidth(*width); }\r
void mgl_set_rotated_text_(uintptr_t *gr, int *rotated) { _GR_->SetRotatedText(*rotated); }\r
-void mgl_set_mark_size_(uintptr_t *gr, float *size) { _GR_->SetMarkSize(*size); }\r
-void mgl_set_arrow_size_(uintptr_t *gr, float *size) { _GR_->SetArrowSize(*size); }\r
-void mgl_set_font_size_(uintptr_t *gr, float *size) { _GR_->SetFontSize(*size); }\r
+void mgl_set_mark_size_(uintptr_t *gr, mreal *size) { _GR_->SetMarkSize(*size); }\r
+void mgl_set_arrow_size_(uintptr_t *gr, mreal *size) { _GR_->SetArrowSize(*size); }\r
+void mgl_set_font_size_(uintptr_t *gr, mreal *size) { _GR_->SetFontSize(*size); }\r
void mgl_set_font_def_(uintptr_t *gr, char *name, int l)\r
{ char *s=new char[l+1]; memcpy(s,name,l); s[l]=0;\r
_GR_->SetFontDef(s); delete []s; }\r
fflush(stdout);\r
}\r
}\r
-void mgl_set_test_mode(int enable)\r
-{ mglTestMode=enable; }\r
+void mgl_set_test_mode(int enable) { mglTestMode=enable; }\r
//---------------------------------------------------------------------------\r
long mgl_use_graph(HMGL gr, int inc)\r
-{ gr->InUse+=inc; return gr->InUse; }\r
+{ if(!gr) return 0; gr->InUse+=inc; return gr->InUse; }\r
long mgl_use_graph_(uintptr_t *gr, int *inc)\r
-{ _GR_->InUse+=*inc; return _GR_->InUse; }\r
+{ return mgl_use_graph(_GR_,*inc); }\r
//---------------------------------------------------------------------------\r
-void mgl_set_ambbr(HMGL gr, float i) { gr->SetAmbient(i); }\r
-void mgl_set_ambbr_(uintptr_t *gr, float *i){ _GR_->SetAmbient(*i); }\r
+void mgl_set_ambbr(HMGL gr, mreal i) { gr->SetAmbient(i); }\r
+void mgl_set_ambbr_(uintptr_t *gr, mreal *i){ _GR_->SetAmbient(*i); }\r
//---------------------------------------------------------------------------\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdlib.h>\r
-#include <wchar.h>\r
+#include <limits.h>\r
#include "mgl2/canvas.h"\r
//-----------------------------------------------------------------------------\r
mglCanvas::mglCanvas(int w, int h) : mglBase()\r
//-----------------------------------------------------------------------------\r
const unsigned char *mglCanvas::GetBits() { Finish(); return G; }\r
//-----------------------------------------------------------------------------\r
-float mglCanvas::GetRatio() const { return inW/inH; }\r
+mreal mglCanvas::GetRatio() const { return inW/inH; }\r
//-----------------------------------------------------------------------------\r
void mglCanvas::add_prim(mglPrim &a)\r
{\r
int CurFrameId; ///< Number of automaticle created frames\r
GifFileType *gif;*/\r
SetTickRotate(true); SetTickSkip(true);\r
- SetWarn(mglWarnNone); ObjId = -1;\r
+ SetWarn(mglWarnNone,"");\r
+ ObjId = -1; HighId = INT_MIN;\r
SetFunc(0,0); Stop=false; CutOff(0); Ternary(0);\r
SetRanges(mglPoint(-1,-1,-1,-1), mglPoint(1,1,1,1));\r
SetBarWidth(0.7); SetMarkSize(1); SetArrowSize(1);\r
SetTranspType(0); SetMeshNum(0); // NOTE: default MeshNum=0\r
SetRotatedText(true); CurrPal = 0;\r
SetLegendMarks(); SetFontSize(4);\r
- SetTuneTicks(-1); SetAmbient();\r
+ SetTuneTicks(-1); SetAmbient();\r
PlotId = "frame"; clr(MGL_DISABLE_SCALE);\r
+ clr(MGL_USE_GMTIME); clr(MGL_NOSUBTICKS);\r
+ SetDifLight(false); SetReduceAcc(false);\r
SetDefScheme("BbcyrR"); SetPalette(MGL_DEF_PAL);\r
- SetPenPal("k-1");\r
+ SetPenPal("k-1"); Alpha(false);\r
SetTicks('x'); SetTicks('y'); SetTicks('z'); SetTicks('c');\r
- stack.clear(); Restore(); Alpha(false);\r
+ stack.clear(); Restore(); DefColor('k');\r
+ SetPlotFactor(0); InPlot(0,1,0,1,false);\r
SetTickLen(0); SetCut(true);\r
AdjustTicks("xyzc",true); Clf();\r
\r
for(int i=0;i<10;i++) { AddLight(i, mglPoint(0,0,1)); Light(i,false); }\r
Light(0,true); Light(false); SetDifLight(true);\r
- SetPlotFactor(0); InPlot(0,1,0,1,false);\r
}\r
//-----------------------------------------------------------------------------\r
// Optimal axis position\r
//-----------------------------------------------------------------------------\r
-float mglCanvas::FindOptOrg(char dir, int ind) const\r
+mreal mglCanvas::FindOptOrg(char dir, int ind) const\r
{\r
static mglPoint px, py, pz, m1, m2;\r
static mglMatrix bb; bb.b[0]=1e30;\r
- mglPoint nn[8]={mglPoint(0,0,0), mglPoint(0,0,1), mglPoint(0,1,0), mglPoint(0,1,1),\r
- mglPoint(1,0,0), mglPoint(1,0,1), mglPoint(1,1,0), mglPoint(1,1,1)}, pp[8];\r
+ mglPoint nn[8]={mglPoint(0,0,0), mglPoint(0,0,1), mglPoint(0,1,0,0), mglPoint(0,1,1),\r
+ mglPoint(1,0,0), mglPoint(1,0,1), mglPoint(1,1,0), mglPoint(1,1,1)}, pp[8];\r
memcpy(pp, nn, 8*sizeof(mglPoint));\r
// do nothing if transformation matrix the same\r
- if(memcmp(B.b,bb.b,9*sizeof(float)) || m1!=Min || m2!=Max)\r
+ if(memcmp(B.b,bb.b,9*sizeof(mreal)) || m1!=Min || m2!=Max)\r
{\r
m1 = Min; m2 = Max; memcpy(&bb,&B,sizeof(mglMatrix));\r
PostScale(pp,8);\r
// find point with minimal y\r
- register long i,j;\r
- for(i=
j=0;i<8;i++) if(pp[i].y<pp[j].y) j=i;
\r+ register long i,j=0;\r
+ for(i=
1;i<8;i++) if(pp[i].y<pp[j].y) j=i;
\r pp[0]=pp[j];\r
// find max angle and left point\r
// first select 3 closest points\r
PostScale(pp+1,3);\r
pp[1]-=pp[0]; pp[2]-=pp[0]; pp[3]-=pp[0];\r
// find cosine of axis projection\r
- float cxy, cxz, cyz, dx, dy, dz;\r
+ mreal cxy, cxz, cyz, dx, dy, dz;\r
dx = pp[1].x*pp[1].x + pp[1].y*pp[1].y;\r
dy = pp[2].x*pp[2].x + pp[2].y*pp[2].y;\r
dz = pp[3].x*pp[3].x + pp[3].y*pp[3].y;\r
py = Min+(Max-Min)/py;\r
pz = Min+(Max-Min)/pz;\r
}\r
- float res = px.val(ind);\r
+ mreal res = px.val(ind);\r
if(dir=='y') res = py.val(ind);\r
if(dir=='z') res = pz.val(ind);\r
return res;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglCanvas::GetOrgX(char dir) const\r
+mreal mglCanvas::GetOrgX(char dir) const\r
{\r
- float res = Org.x;\r
+ mreal res = Org.x;\r
if(mgl_isnan(res))\r
{\r
if(strchr("xyz",dir)) res = FindOptOrg(dir,0);\r
return res;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglCanvas::GetOrgY(char dir) const\r
+mreal mglCanvas::GetOrgY(char dir) const\r
{\r
- float res = Org.y;\r
+ mreal res = Org.y;\r
if(mgl_isnan(res))\r
{\r
if(strchr("xyz",dir)) res = FindOptOrg(dir,1);\r
return res;\r
}\r
//-----------------------------------------------------------------------------\r
-float mglCanvas::GetOrgZ(char dir) const\r
+mreal mglCanvas::GetOrgZ(char dir) const\r
{\r
- float res = Org.z;\r
+ mreal res = Org.z;\r
if(mgl_isnan(res))\r
{\r
if(strchr("xyz",dir)) res = FindOptOrg(dir,2);\r
#define MGL_MARK_PLOT if(Quality&4) mark_draw(p,type,size?size:MarkSize,&d);else \\r
{ mglPrim a; a.w = fabs(PenWidth); a.s = size?size:MarkSize; \\r
a.n1 = p; a.n4 = type; add_prim(a); }\r
-void mglCanvas::mark_plot(long p, char type, float size)\r
+void mglCanvas::mark_plot(long p, char type, mreal size)\r
{\r
if(p<0 || mgl_isnan(Pnt[p].x)) return;\r
long pp=p;\r
if(p1<0 || p2<0 || mgl_isnan(Pnt[p1].x) || mgl_isnan(Pnt[p2].x)) return;\r
mglDrawReg dd; dd.set(this,1,1,0);\r
long pp1=p1,pp2=p2;\r
- float pw = fabs(PenWidth),d;\r
+ mreal pw = fabs(PenWidth),d;\r
d = hypot(Pnt[p1].x-Pnt[p2].x, Pnt[p1].y-Pnt[p2].y);\r
if(TernAxis&4) for(int i=0;i<4;i++)\r
{ p1 = ProjScale(i, pp1); p2 = ProjScale(i, pp2);\r
else { MGL_QUAD_PLOT }\r
}\r
//-----------------------------------------------------------------------------\r
-float mglCanvas::text_plot(long p,const wchar_t *text,const char *font,float size,float sh,float col,bool rot)\r
+mreal mglCanvas::text_plot(long p,const wchar_t *text,const char *font,mreal size,mreal sh,mreal col,bool rot)\r
{\r
- if(p<0 || mgl_isnan(Pnt[p].x)) return 0;\r
+ if(p<0 || mgl_isnan(Pnt[p].x) || !text || *text==0) return 0;\r
if(size<0) size *= -FontSize;\r
if(!font) font="";\r
\r
if(TernAxis&4) // text at projections\r
{\r
- float res;\r
+ mreal res;\r
TernAxis = TernAxis&(~4);\r
for(int i=0;i<4;i++)\r
res = text_plot(ProjScale(i,p),text,font,size/2,sh,col);\r
}\r
\r
mglPnt q=Pnt[p];\r
- float ll = q.u*q.u+q.v*q.v;\r
+ mreal ll = q.u*q.u+q.v*q.v;\r
bool inv=false;\r
if(rot && (q.u<0 || (q.u==0 && q.v<0)))\r
{ q.u=-q.u; q.v=-q.v; q.w=-q.w; inv=true; }\r
a.s = size; a.w = sh; a.p=col;\r
add_prim(a);\r
}\r
- float shift = -sh-0.2, fsize=size/8.*font_factor, h = fnt->Height(font)*fsize, w;\r
+ if(ll==0) return 0;\r
+\r
+ mreal fsize=size/6.5*font_factor, h = fnt->Height(font)*fsize, w, shift = -sh*h-2;\r
// text drawing itself\r
Push();\r
inv = inv ^ (strchr(font,'T')!=0);\r
- if(inv) shift = sh+0.2;\r
- shift += 0.11; // Correction for glyph rotation around proper point\r
+ if(inv) shift = 0.17*h-shift;\r
+ shift += 1.1; // Correction for glyph rotation around proper point\r
+// shift *= h;\r
\r
- shift *= h; B.z= q.z;\r
- if(ll==0) { Pop(); return 0; }\r
+ int align; mglGetStyle(font,0,&align); align = align&3;\r
+ B.x = q.x; B.y = q.y - shift; B.z = q.z;\r
+ if(ll>0) { B.x += shift*q.v/sqrt(ll); B.y += shift*(1-q.u/sqrt(ll)); }\r
+ fscl = fsize;\r
\r
- if(mgl_isnan(ll) || !get(MGL_ENABLE_RTEXT))\r
- {\r
- fscl = fsize; ftet = 0;\r
- B.x = q.x; B.y= q.y - shift;\r
- }\r
- else\r
- {\r
- if(ll==0) { Pop(); return 0; }\r
- B.x = q.x+shift*q.v/sqrt(ll);\r
- B.y= q.y-shift*q.u/sqrt(ll);\r
- fscl = fsize;\r
- ftet = -180*atan2(q.v,q.u)/M_PI;\r
- }\r
- memset(B.b,0,9*sizeof(float));\r
+ if(mgl_isnan(ll) || !get(MGL_ENABLE_RTEXT)) ftet = 0;\r
+ else ftet = -180*atan2(q.v,q.u)/M_PI;\r
+\r
+ memset(B.b,0,9*sizeof(mreal));\r
B.b[0] = B.b[4] = B.b[8] = fscl;\r
- RotateN(ftet,0,0,1);\r
+ register mreal opf = B.pf;\r
+ RotateN(ftet,0,0,1); B.pf = opf;\r
if(strchr(font,'@')) // draw box around text\r
{\r
long k1,k2,k3,k4; mglPnt pt; mglPoint pp;\r
w = fnt->Width(text,font); h = fnt->Height(font);\r
- int align; mglGetStyle(font,0,&align); align = align&3;\r
- float d=-w*align/2.-h*0.2; w+=h*0.4;\r
+// int align; mglGetStyle(font,0,&align); align = align&3;\r
+ mreal d=-w*align/2.-h*0.2; w+=h*0.4;\r
pt = q; pp = mglPoint(d,-h*0.4); PostScale(pp);\r
pt.x=pt.xx=pp.x; pt.y=pt.yy=pp.y; MGL_PUSH(Pnt,pt,mutexPnt); k1=Pnt.size()-1;\r
pt = q; pp = mglPoint(w+d,-h*0.4); PostScale(pp);\r
Pop(); return fsize;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::Glyph(float x, float y, float f, int s, long j, float col)\r
+void mglCanvas::Glyph(mreal x, mreal y, mreal f, int s, long j, mreal col)\r
{\r
mglPrim a(4); // NOTE: no projection since text_plot() did it\r
a.s = fscl/B.pf; a.w = ftet; a.p = B.pf;\r
- float cc = col<0 ? AddTexture(char(0.5-col)):col;\r
+ mreal cc = col<0 ? AddTexture(char(0.5-col)):col;\r
if(cc<0) cc = CDef;\r
a.n1 = AddPnt(mglPoint(B.x,B.y,B.z), cc, mglPoint(x,y,f/fnt->GetFact(s&3)), -1, -1);\r
a.n3 = s; a.n4 = j;\r
//-----------------------------------------------------------------------------\r
// Plot positioning functions\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::InPlot(float x1,float x2,float y1,float y2, const char *st)\r
+void mglCanvas::InPlot(mreal x1,mreal x2,mreal y1,mreal y2, const char *st)\r
{\r
if(Width<=0 || Height<=0 || Depth<=0) return;\r
if(!st) { InPlot(x1,x2,y1,y2,false); return; }\r
- inW = Width*(x2-x1); inH = Height*(y2-y1);\r
+ inW = Width*(x2-x1); inH = Height*(y2-y1); ZMin=1;\r
mglPrim p; p.id = ObjId;\r
p.n1=x1*Width; p.n2=x2*Width; p.n3=y1*Height; p.n4=y2*Height;\r
MGL_PUSH(Sub,p,mutexSub);\r
bool u = !(strchr(st,'u') || strchr(st,'U') || strchr(st,'_') || strchr(st,'g'));\r
bool a = !(strchr(st,'a') || strchr(st,'A') || strchr(st,'^') || strchr(st,'g') || strchr(st,'t'));\r
// let use simplified scheme -- i.e. no differences between axis, colorbar and/or title\r
- register float xs=(x1+x2)/2, ys=(y1+y2)/2, f1 = 1.3, f2 = 1.1;\r
+ register mreal xs=(x1+x2)/2, ys=(y1+y2)/2, f1 = 1.3, f2 = 1.1;\r
if(r && l) { x2=xs+(x2-xs)*f1; x1=xs+(x1-xs)*f1; }\r
else if(r) { x2=xs+(x2-xs)*f1; x1=xs+(x1-xs)*f2; }\r
else if(l) { x2=xs+(x2-xs)*f2; x1=xs+(x1-xs)*f1; }\r
B1=B; font_factor = B.b[0] < B.b[4] ? B.b[0] : B.b[4];\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::InPlot(float x1,float x2,float y1,float y2, bool rel)\r
+void mglCanvas::InPlot(mreal x1,mreal x2,mreal y1,mreal y2, bool rel)\r
{\r
if(Width<=0 || Height<=0 || Depth<=0) return;\r
B.clear();\r
B.z = (1.f-B.b[8]/(2*Depth))*Depth;\r
B1=B;\r
}\r
- inW = B.b[0]; inH=B.b[4];\r
+ inW = B.b[0]; inH=B.b[4]; ZMin=1;\r
font_factor = B.b[0] < B.b[4] ? B.b[0] : B.b[4];\r
mglPrim p; p.id = ObjId;\r
p.n1=x1*Width; p.n2=x2*Width; p.n3=y1*Height; p.n4=y2*Height;\r
MGL_PUSH(Sub,p,mutexSub);\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::StickPlot(int num, int id, float tet, float phi)\r
+void mglCanvas::StickPlot(int num, int id, mreal tet, mreal phi)\r
{\r
- float dx,dy,wx,wy,x1,y1,f1,f2;\r
+ mreal dx,dy,wx,wy,x1,y1,f1,f2;\r
mglPoint p1(-1,0,0), p2(1,0,0);\r
// first iteration\r
InPlot(0,1,0,1,true); Rotate(tet, phi);\r
InPlot(x1*wx,(x1+1)*wx,y1*wy,(y1+1)*wy,true); Rotate(tet,phi);\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::Rotate(float tetz,float tetx,float tety)\r
+void mglCanvas::Rotate(mreal tetz,mreal tetx,mreal tety)\r
{\r
// RotateN(TetX,1.,0.,0.);\r
// RotateN(TetY,0.,1.,0.);\r
// RotateN(TetZ,0.,0.,1.);\r
- float R[9], O[9];\r
- float cx=cos(tetx*M_PI/180), sx=-sin(tetx*M_PI/180), cy=cos(tety*M_PI/180), sy=-sin(tety*M_PI/180), cz=cos(tetz*M_PI/180), sz=-sin(tetz*M_PI/180);\r
+ mreal R[9], O[9];\r
+ mreal cx=cos(tetx*M_PI/180), sx=-sin(tetx*M_PI/180), cy=cos(tety*M_PI/180), sy=-sin(tety*M_PI/180), cz=cos(tetz*M_PI/180), sz=-sin(tetz*M_PI/180);\r
R[0] = cx*cy; R[1] = -cy*sx; R[2] = sy;\r
R[3] = cx*sy*sz+cz*sx; R[4] = cx*cz-sx*sy*sz; R[5] =-cy*sz;\r
R[6] = sx*sz-cx*cz*sy; R[7] = cx*sz+cz*sx*sy; R[8] = cy*cz;\r
- memcpy(O,B.b,9*sizeof(float));\r
+ memcpy(O,B.b,9*sizeof(mreal));\r
B.b[0] = R[0]*O[0] + R[3]*O[1] + R[6]*O[2];\r
B.b[1] = R[1]*O[0] + R[4]*O[1] + R[7]*O[2];\r
B.b[2] = R[2]*O[0] + R[5]*O[1] + R[8]*O[2];\r
B.b[8] = R[2]*O[6] + R[5]*O[7] + R[8]*O[8];\r
if(get(MGL_AUTO_FACTOR))\r
{\r
- float w=(fabs(B.b[3])+fabs(B.b[4])+fabs(B.b[5]))/B1.b[4];\r
- float h=(fabs(B.b[0])+fabs(B.b[1])+fabs(B.b[2]))/B1.b[0];\r
+ mreal w=(fabs(B.b[3])+fabs(B.b[4])+fabs(B.b[5]))/B1.b[4];\r
+ mreal h=(fabs(B.b[0])+fabs(B.b[1])+fabs(B.b[2]))/B1.b[0];\r
B.pf = 1.55+0.6147*(w<h ? (h-1):(w-1));\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::RotateN(float Tet,float x,float y,float z)\r
+void mglCanvas::RotateN(mreal Tet,mreal x,mreal y,mreal z)\r
{\r
- float R[9],T[9],c=cos(Tet*M_PI/180),s=-sin(Tet*M_PI/180),r=1-c,n=sqrt(x*x+y*y+z*z);\r
+ mreal R[9],T[9],c=cos(Tet*M_PI/180),s=-sin(Tet*M_PI/180),r=1-c,n=sqrt(x*x+y*y+z*z);\r
x/=n; y/=n; z/=n;\r
T[0] = x*x*r+c; T[1] = x*y*r-z*s; T[2] = x*z*r+y*s;\r
T[3] = x*y*r+z*s; T[4] = y*y*r+c; T[5] = y*z*r-x*s;\r
T[6] = x*z*r-y*s; T[7] = y*z*r+x*s; T[8] = z*z*r+c;\r
- memcpy(R,B.b,9*sizeof(float));\r
+ memcpy(R,B.b,9*sizeof(mreal));\r
B.b[0] = T[0]*R[0] + T[3]*R[1] + T[6]*R[2];\r
B.b[1] = T[1]*R[0] + T[4]*R[1] + T[7]*R[2];\r
B.b[2] = T[2]*R[0] + T[5]*R[1] + T[8]*R[2];\r
B.b[8] = T[2]*R[6] + T[5]*R[7] + T[8]*R[8];\r
if(get(MGL_AUTO_FACTOR))\r
{\r
- float w=(fabs(B.b[3])+fabs(B.b[4])+fabs(B.b[5]))/B1.b[4];\r
- float h=(fabs(B.b[0])+fabs(B.b[1])+fabs(B.b[2]))/B1.b[0];\r
+ mreal w=(fabs(B.b[3])+fabs(B.b[4])+fabs(B.b[5]))/B1.b[4];\r
+ mreal h=(fabs(B.b[0])+fabs(B.b[1])+fabs(B.b[2]))/B1.b[0];\r
B.pf = 1.55+0.6147*(w<h ? (h-1):(w-1));\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::View(float tetx,float tetz,float tety)\r
+void mglCanvas::View(mreal tetx,mreal tetz,mreal tety)\r
{\r
- float R[9], A[9];\r
- float cx=cos(tetx*M_PI/180), sx=sin(tetx*M_PI/180);\r
- float cy=cos(tety*M_PI/180), sy=sin(tety*M_PI/180);\r
- float cz=cos(tetz*M_PI/180), sz=sin(tetz*M_PI/180);\r
+ mreal R[9], A[9];\r
+ mreal cx=cos(tetx*M_PI/180), sx=sin(tetx*M_PI/180);\r
+ mreal cy=cos(tety*M_PI/180), sy=sin(tety*M_PI/180);\r
+ mreal cz=cos(tetz*M_PI/180), sz=sin(tetz*M_PI/180);\r
R[0] = cx*cy; R[1] = -cy*sx; R[2] = sy;\r
R[3] = cx*sy*sz+cz*sx; R[4] = cx*cz-sx*sy*sz; R[5] =-cy*sz;\r
R[6] = sx*sz-cx*cz*sy; R[7] = cx*sz+cz*sx*sy; R[8] = cy*cz;\r
- memcpy(A,Bp.b,9*sizeof(float)); ClfZB();\r
+ memcpy(A,Bp.b,9*sizeof(mreal)); ClfZB();\r
Bp.b[0] = R[0]*A[0] + R[3]*A[1] + R[6]*A[2];\r
Bp.b[1] = R[1]*A[0] + R[4]*A[1] + R[7]*A[2];\r
Bp.b[2] = R[2]*A[0] + R[5]*A[1] + R[8]*A[2];\r
Bp.b[8] = R[2]*A[6] + R[5]*A[7] + R[8]*A[8];\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::Zoom(float x1, float y1, float x2, float y2)\r
+void mglCanvas::Zoom(mreal x1, mreal y1, mreal x2, mreal y2)\r
{\r
Bp.pf=0; Bp.clear(); ClfZB();\r
if(x1==x2 || y1==y2) { x1=y1=0; x2=y2=1; }\r
return id;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::Aspect(float Ax,float Ay,float Az)\r
+void mglCanvas::Aspect(mreal Ax,mreal Ay,mreal Az)\r
{\r
- float a = fabs(Ax) > fabs(Ay) ? fabs(Ax) : fabs(Ay);\r
+ mreal a = fabs(Ax) > fabs(Ay) ? fabs(Ax) : fabs(Ay);\r
a = a > fabs(Az) ? a : fabs(Az);\r
if(a==0) { SetWarn(mglWarnZero,"Aspect"); return; }\r
Ax/=a; Ay/=a; Az/=a;\r
//-----------------------------------------------------------------------------\r
// Lighting and transparency\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::Fog(float d, float dz) { FogDist=d; FogDz = dz; }\r
+void mglCanvas::Fog(mreal d, mreal dz) { FogDist=d; FogDz = dz; }\r
//-----------------------------------------------------------------------------\r
void mglCanvas::Light(int n, bool enable)\r
{\r
- if(n<0 || n>9) { SetWarn(mglWarnLId); return; }\r
+ if(n<0 || n>9) { SetWarn(mglWarnLId,"Light"); return; }\r
light[n].n = enable;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::AddLight(int n, mglPoint r, mglPoint d, char col, float br, float ap)\r
+void mglCanvas::AddLight(int n, mglPoint r, mglPoint d, char col, mreal br, mreal ap)\r
{\r
- if(n<0 || n>9) { SetWarn(mglWarnLId); return; }\r
+ if(n<0 || n>9) { SetWarn(mglWarnLId,"AddLight"); return; }\r
light[n].n = true; light[n].a = ap>0?ap*ap:3;\r
light[n].b = br; light[n].r = r;\r
light[n].d = d; light[n].c = mglColor(col);\r
mglPnt q1=p1,q2=p1,q3=p1,q4=p1;\r
q1.u=q1.v=q2.u=q2.v=q3.u=q3.v=q4.u=q4.v=NAN;\r
\r
- float lx=p1.x-p2.x, ly=p1.y-p2.y, ll, kx,ky;\r
+ mreal lx=p1.x-p2.x, ly=p1.y-p2.y, ll, kx,ky;\r
ll = hypot(lx,ly)/(PenWidth*ArrowSize*0.35*font_factor);\r
if(ll==0) return;\r
lx /= ll; ly /= ll; kx = ly; ky = -lx;\r
- float lz = (p2.z-p1.z)/ll;\r
+ mreal lz = (p2.z-p1.z)/ll;\r
\r
Reserve(6);\r
long k1,k2,k3,k4;\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::Legend(const std::vector<mglText> &leg, float x, float y, const char *font, float size, float ll)\r
+void mglCanvas::Legend(const std::vector<mglText> &leg, mreal x, mreal y, const char *font, mreal size, mreal ll)\r
{\r
long n=leg.size(), iw, ih;\r
- if(n<1) { SetWarn(mglWarnLeg); return; }\r
+ if(n<1) { SetWarn(mglWarnLeg,"Legend"); return; }\r
static int cgid=1; StartGroup("Legend",cgid++);\r
if(ll<=0 || mgl_isnan(ll)) ll=0.1;\r
ll *=font_factor;\r
{ *pA = ' '; InPlot(0,1,0,1,false); iw=B1.b[0]; ih=B1.b[4]; }\r
else { iw=B1.b[0]/B1.pf; ih=B1.b[4]/B1.pf; }\r
// find sizes\r
- float h=TextHeight(font,size)/2;\r
- float dx = 0.03*iw, dy = 0.03*ih, w=0, t;\r
+ mreal h=TextHeight(font,size)/2;\r
+ mreal dx = 0.03*iw, dy = 0.03*ih, w=0, t;\r
register long i,j;\r
for(i=0;i<n;i++) // find text length\r
{\r
w = w>t ? w:t;\r
}\r
w += ll+0.01*iw; // add space for lines\r
- x = x*(iw-w-2*dx)+B.x-iw/2+dx;\r
+ x = x*(iw-w-2*dx)+B.x-iw/2+dx; // TODO bypass very long legends\r
y = y*(ih-h*n-2*dy)+B.y-ih/2+dy;\r
// draw it\r
long k1=0,k2=0,k3=0,k4=0;\r
}\r
if(k4==2) k2=0;\r
if(k4==1) k1=k2=0;\r
- float c1=AddTexture(char(k1?k1:'w')), c2=AddTexture(char(k2?k2:'k'));\r
- if((Flag&3)==2) { float cc=c1; c2=c1; c2=cc; };\r
+ mreal c1=AddTexture(char(k1?k1:'w')), c2=AddTexture(char(k2?k2:'k'));\r
+ if((Flag&3)==2) { mreal cc=c1; c2=c1; c2=cc; };\r
\r
if(strchr(ff,'#')) // draw bounding box\r
{\r
Pop(); EndGroup(); delete []ff;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::Title(const char *title,const char *stl,float size)\r
+void mglCanvas::Title(const char *title,const char *stl,mreal size)\r
{\r
wchar_t *wcs = 0;\r
if(title)\r
if(wcs) delete []wcs;\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::Title(const wchar_t *title,const char *stl,float size)\r
+void mglCanvas::Title(const wchar_t *title,const char *stl,mreal size)\r
{\r
- float s = size>0 ? size/FontSize:-size, h=TextHeight(stl,size)*s/4;\r
+ mreal s = size>0 ? size/FontSize:-size, h=TextHeight(stl,size)*s/4;\r
if(h>=inH) { SetWarn(mglWarnSpc,"Title"); return; }\r
bool box=(stl && strchr(stl,'#'));\r
int align; mglGetStyle(stl,0,&align); align = align&3;\r
- float x=B1.x-inW/2, y=B1.y+inH/2-h;\r
+ mreal x=B1.x-inW/2, y=B1.y+inH/2-h;\r
mglPoint p(B1.x + inW/2.1*(align-1),y,Depth),q(NAN);\r
if(title) text_plot(AddPnt(p,-1,q,-1,0),title,stl,size);\r
if(box) // draw boungind box\r
{\r
- float c1=AddTexture('w'), c2=AddTexture('k');\r
- if((Flag&3)==2) { float cc=c1; c2=c1; c2=cc; };\r
+ mreal c1=AddTexture('w'), c2=AddTexture('k');\r
+ if((Flag&3)==2) { mreal cc=c1; c2=c1; c2=cc; };\r
long k1,k2,k3,k4;\r
k1=AddPnt(mglPoint(x,y,Depth),c1,q,-1,0);\r
k2=AddPnt(mglPoint(x+inW,y,Depth),c1,q,-1,0);\r
const unsigned char *mgl_get_rgba(HMGL gr) { return _Gr_->GetRGBA(); }\r
int mgl_get_width(HMGL gr) { return _Gr_->GetWidth(); }\r
int mgl_get_height(HMGL gr) { return _Gr_->GetHeight(); }\r
-void mgl_calc_xyz(HMGL gr, int xs, int ys, float *x, float *y, float *z)\r
+void mgl_calc_xyz(HMGL gr, int xs, int ys, mreal *x, mreal *y, mreal *z)\r
{ mglPoint p = _Gr_->CalcXYZ(xs,ys); *x = p.x; *y = p.y; *z = p.z; }\r
-void mgl_calc_scr(HMGL gr, float x, float y, float z, int *xs, int *ys)\r
+void mgl_calc_scr(HMGL gr, mreal x, mreal y, mreal z, int *xs, int *ys)\r
{ _Gr_->CalcScr(mglPoint(x,y,z),xs,ys); }\r
void mgl_set_obj_id(HMGL gr, int id) { _Gr_->SetObjId(id); }\r
int mgl_get_obj_id(HMGL gr, long x, long y) { return _Gr_->GetObjId(x,y); }\r
//-----------------------------------------------------------------------------\r
void mgl_set_transp_type(HMGL gr, int type) { _Gr_->SetTranspType(type); }\r
void mgl_set_alpha(HMGL gr, int enable) { _Gr_->Alpha(enable); }\r
-void mgl_set_fog(HMGL gr, float d, float dz) { _Gr_->Fog(d,dz); }\r
+void mgl_set_fog(HMGL gr, mreal d, mreal dz) { _Gr_->Fog(d,dz); }\r
void mgl_set_light(HMGL gr, int enable) { _Gr_->Light(enable); }\r
void mgl_set_light_n(HMGL gr, int n, int enable) { _Gr_->Light(n, enable); }\r
-void mgl_add_light_ext(HMGL gr, int n, float x, float y, float z, char c, float br, float ap)\r
+void mgl_add_light_ext(HMGL gr, int n, mreal x, mreal y, mreal z, char c, mreal br, mreal ap)\r
{ _Gr_->AddLight(n,mglPoint(x,y,z),c,br,ap); }\r
-void mgl_add_light_loc(HMGL gr, int n, float x, float y, float z, float dx, float dy, float dz, char c, float br, float ap)\r
+void mgl_add_light_loc(HMGL gr, int n, mreal x, mreal y, mreal z, mreal dx, mreal dy, mreal dz, char c, mreal br, mreal ap)\r
{ _Gr_->AddLight(n,mglPoint(x,y,z),mglPoint(dx,dy,dz),c,br,ap); }\r
-void mgl_add_light(HMGL gr, int n, float x, float y, float z)\r
+void mgl_add_light(HMGL gr, int n, mreal x, mreal y, mreal z)\r
{ _Gr_->AddLight(n,mglPoint(x,y,z)); }\r
//-----------------------------------------------------------------------------\r
void mgl_mat_push(HMGL gr) { _Gr_->Push(); }\r
void mgl_mat_pop(HMGL gr) { _Gr_->Pop(); }\r
void mgl_clf(HMGL gr) { _Gr_->Clf(); }\r
-void mgl_clf_rgb(HMGL gr, float r, float g, float b){ _Gr_->Clf(mglColor(r,g,b)); }\r
+void mgl_clf_rgb(HMGL gr, mreal r, mreal g, mreal b){ _Gr_->Clf(mglColor(r,g,b)); }\r
//-----------------------------------------------------------------------------\r
-void mgl_subplot_d(HMGL gr, int nx,int ny,int m,const char *style,float dx,float dy)\r
+void mgl_subplot_d(HMGL gr, int nx,int ny,int m,const char *style,mreal dx,mreal dy)\r
{\r
- float x1,x2,y1,y2;\r
+ mreal x1,x2,y1,y2;\r
int mx = m%nx, my = m/nx;\r
if(_Gr_->get(MGL_AUTO_FACTOR)) { dx /= 1.55; dy /= 1.55; }\r
else { dx /= 2; dy /= 2; }\r
//-----------------------------------------------------------------------------\r
void mgl_multiplot(HMGL gr, int nx,int ny,int m,int dx,int dy,const char *style)\r
{\r
- float x1,x2,y1,y2;\r
+ mreal x1,x2,y1,y2;\r
int mx = m%nx, my = m/nx;\r
dx = (dx<1 || dx+mx>nx) ? 1 : dx;\r
dy = (dy<1 || dy+my>ny) ? 1 : dy;\r
- x1 = float(mx)/nx; x2 = float(mx+dx)/nx;\r
- y2 = 1-float(my)/ny; y1 = 1-float(my+dy)/ny;\r
+ x1 = mreal(mx)/nx; x2 = mreal(mx+dx)/nx;\r
+ y2 = 1-mreal(my)/ny; y1 = 1-mreal(my+dy)/ny;\r
_Gr_->InPlot(x1,x2,y1,y2,style);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_inplot(HMGL gr, float x1,float x2,float y1,float y2)\r
+void mgl_inplot(HMGL gr, mreal x1,mreal x2,mreal y1,mreal y2)\r
{ _Gr_->InPlot(x1,x2,y1,y2,false); }\r
-void mgl_relplot(HMGL gr, float x1,float x2,float y1,float y2)\r
+void mgl_relplot(HMGL gr, mreal x1,mreal x2,mreal y1,mreal y2)\r
{ _Gr_->InPlot(x1,x2,y1,y2,true); }\r
//-----------------------------------------------------------------------------\r
-void mgl_columnplot(HMGL gr, int num, int i, float dd)\r
+void mgl_columnplot(HMGL gr, int num, int i, mreal dd)\r
{\r
- register float w = 1./num;\r
+ register mreal w = 1./num;\r
_Gr_->InPlot(0,1,1-w*(i+1-dd),1-i*w,true);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_gridplot(HMGL gr, int nx, int ny, int i, float dd)\r
+void mgl_gridplot(HMGL gr, int nx, int ny, int i, mreal dd)\r
{\r
register int ix=i%nx, iy=i/nx;\r
- register float wx = 1./nx, wy = 1./ny;\r
+ register mreal wx = 1./nx, wy = 1./ny;\r
_Gr_->InPlot(ix*wx,wx*(ix+1-dd),1-wy*(iy+1-dd),1-iy*wy,true);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_stickplot(HMGL gr, int num, int i, float tet, float phi)\r
+void mgl_stickplot(HMGL gr, int num, int i, mreal tet, mreal phi)\r
{ _Gr_->StickPlot(num, i, tet, phi); }\r
//-----------------------------------------------------------------------------\r
-void mgl_aspect(HMGL gr, float Ax,float Ay,float Az)\r
+void mgl_aspect(HMGL gr, mreal Ax,mreal Ay,mreal Az)\r
{ _Gr_->Aspect(Ax,Ay,Az); }\r
-void mgl_rotate(HMGL gr, float TetX,float TetZ,float TetY)\r
+void mgl_rotate(HMGL gr, mreal TetX,mreal TetZ,mreal TetY)\r
{ _Gr_->Rotate(TetX,TetZ,TetY); }\r
-void mgl_view(HMGL gr, float TetX,float TetZ,float TetY)\r
+void mgl_view(HMGL gr, mreal TetX,mreal TetZ,mreal TetY)\r
{ _Gr_->View(TetX,TetZ,TetY); }\r
-void mgl_zoom(HMGL gr, float x1, float y1, float x2, float y2)\r
+void mgl_zoom(HMGL gr, mreal x1, mreal y1, mreal x2, mreal y2)\r
{ _Gr_->Zoom(x1,y1,x2,y2); }\r
-void mgl_rotate_vector(HMGL gr, float Tet,float x,float y,float z)\r
+void mgl_rotate_vector(HMGL gr, mreal Tet,mreal x,mreal y,mreal z)\r
{ _Gr_->RotateN(Tet,x,y,z); }\r
-void mgl_perspective(HMGL gr, float val)\r
+void mgl_perspective(HMGL gr, mreal val)\r
{ _Gr_->Perspective(val); }\r
-void mgl_title(HMGL gr, const char *title, const char *stl, float size)\r
+void mgl_title(HMGL gr, const char *title, const char *stl, mreal size)\r
{ _Gr_->Title(title,stl,size); }\r
-void mgl_titlew(HMGL gr, const wchar_t *title, const char *stl, float size)\r
+void mgl_titlew(HMGL gr, const wchar_t *title, const char *stl, mreal size)\r
{ _Gr_->Title(title,stl,size); }\r
//-----------------------------------------------------------------------------\r
int mgl_new_frame_(uintptr_t *gr) { return _GR_->NewFrame(); }\r
//-----------------------------------------------------------------------------\r
void mgl_set_transp_type_(uintptr_t *gr, int *type) { _GR_->SetTranspType(*type); }\r
void mgl_set_alpha_(uintptr_t *gr, int *enable) { _GR_->Alpha(*enable); }\r
-void mgl_set_fog_(uintptr_t *gr, float *d, float *dz) { _GR_->Fog(*d, *dz); }\r
+void mgl_set_fog_(uintptr_t *gr, mreal *d, mreal *dz) { _GR_->Fog(*d, *dz); }\r
void mgl_set_light_(uintptr_t *gr, int *enable) { _GR_->Light(*enable); }\r
void mgl_set_light_n_(uintptr_t *gr, int *n, int *enable)\r
{ _GR_->Light(*n, *enable); }\r
-void mgl_add_light_(uintptr_t *gr, int *n, float *x, float *y, float *z)\r
+void mgl_add_light_(uintptr_t *gr, int *n, mreal *x, mreal *y, mreal *z)\r
{ _GR_->AddLight(*n,mglPoint(*x,*y,*z)); }\r
-void mgl_add_light_ext_(uintptr_t *gr, int *n, float *x, float *y, float *z, char *c, float *br, float *ap, int)\r
+void mgl_add_light_ext_(uintptr_t *gr, int *n, mreal *x, mreal *y, mreal *z, char *c, mreal *br, mreal *ap, int)\r
{ _GR_->AddLight(*n,mglPoint(*x,*y,*z),*c,*br,*ap); }\r
-void mgl_add_light_loc_(uintptr_t *gr, int *n, float *x, float *y, float *z, float *dx, float *dy, float *dz, char *c, float *br, float *ap, int)\r
+void mgl_add_light_loc_(uintptr_t *gr, int *n, mreal *x, mreal *y, mreal *z, mreal *dx, mreal *dy, mreal *dz, char *c, mreal *br, mreal *ap, int)\r
{ _GR_->AddLight(*n,mglPoint(*x,*y,*z),mglPoint(*dx,*dy,*dz),*c,*br,*ap); }\r
//-----------------------------------------------------------------------------\r
void mgl_mat_push_(uintptr_t *gr) { _GR_->Push(); }\r
void mgl_mat_pop_(uintptr_t *gr) { _GR_->Pop(); }\r
void mgl_clf_(uintptr_t *gr)\r
{ _GR_->Clf(); }\r
-void mgl_clf_rgb_(uintptr_t *gr, float *r, float *g, float *b)\r
+void mgl_clf_rgb_(uintptr_t *gr, mreal *r, mreal *g, mreal *b)\r
{ _GR_->Clf(mglColor(*r,*g,*b)); }\r
//-----------------------------------------------------------------------------\r
-void mgl_subplot_d_(uintptr_t *gr, int *nx,int *ny,int *m,const char *st,float *dx,float *dy,int l)\r
+void mgl_subplot_d_(uintptr_t *gr, int *nx,int *ny,int *m,const char *st,mreal *dx,mreal *dy,int l)\r
{ char *s=new char[l+1]; memcpy(s,st,l); s[l]=0;\r
mgl_subplot_d(_GR_,*nx,*ny,*m,s,*dx,*dy); delete []s; }\r
void mgl_subplot_(uintptr_t *gr, int *nx,int *ny,int *m,const char *st,int l)\r
void mgl_multiplot_(uintptr_t *gr, int *nx,int *ny,int *m,int *dx,int *dy,const char *st,int l)\r
{ char *s=new char[l+1]; memcpy(s,st,l); s[l]=0;\r
mgl_multiplot(_GR_,*nx,*ny,*m,*dx,*dy,s); delete []s; }\r
-void mgl_inplot_(uintptr_t *gr, float *x1,float *x2,float *y1,float *y2)\r
+void mgl_inplot_(uintptr_t *gr, mreal *x1,mreal *x2,mreal *y1,mreal *y2)\r
{ _GR_->InPlot(*x1,*x2,*y1,*y2,false); }\r
-void mgl_relplot_(uintptr_t *gr, float *x1,float *x2,float *y1,float *y2)\r
+void mgl_relplot_(uintptr_t *gr, mreal *x1,mreal *x2,mreal *y1,mreal *y2)\r
{ _GR_->InPlot(*x1,*x2,*y1,*y2,true); }\r
-void mgl_columnplot_(uintptr_t *gr, int *num, int *i, float *d)\r
+void mgl_columnplot_(uintptr_t *gr, int *num, int *i, mreal *d)\r
{ mgl_columnplot(_GR_,*num,*i,*d); }\r
-void mgl_columnplot_d_(uintptr_t *gr, int *nx, int *ny, int *i, float *d)\r
+void mgl_columnplot_d_(uintptr_t *gr, int *nx, int *ny, int *i, mreal *d)\r
{ mgl_gridplot(_GR_,*nx,*ny,*i,*d); }\r
-void mgl_stickplot_(uintptr_t *gr, int *num, int *i, float *tet, float *phi)\r
+void mgl_stickplot_(uintptr_t *gr, int *num, int *i, mreal *tet, mreal *phi)\r
{ _GR_->StickPlot(*num, *i, *tet, *phi); }\r
\r
-void mgl_title_(uintptr_t *gr, const char *title, const char *stl, float *size, int l,int m)\r
+void mgl_title_(uintptr_t *gr, const char *title, const char *stl, mreal *size, int l,int m)\r
{ char *t=new char[l+1]; memcpy(t,title,l); t[l]=0;\r
char *s=new char[m+1]; memcpy(s,stl,m); s[m]=0;\r
_GR_->Title(t,s,*size); delete []s; delete []t; }\r
-void mgl_aspect_(uintptr_t *gr, float *Ax,float *Ay,float *Az)\r
+void mgl_aspect_(uintptr_t *gr, mreal *Ax,mreal *Ay,mreal *Az)\r
{ _GR_->Aspect(*Ax,*Ay,*Az); }\r
-void mgl_rotate_(uintptr_t *gr, float *TetX,float *TetZ,float *TetY)\r
+void mgl_rotate_(uintptr_t *gr, mreal *TetX,mreal *TetZ,mreal *TetY)\r
{ _GR_->Rotate(*TetX,*TetZ,*TetY); }\r
-void mgl_view_(uintptr_t *gr, float *TetX,float *TetZ,float *TetY)\r
+void mgl_view_(uintptr_t *gr, mreal *TetX,mreal *TetZ,mreal *TetY)\r
{ _GR_->View(*TetX,*TetZ,*TetY); }\r
-void mgl_zoom_(uintptr_t *gr, float *x1, float *y1, float *x2, float *y2)\r
+void mgl_zoom_(uintptr_t *gr, mreal *x1, mreal *y1, mreal *x2, mreal *y2)\r
{ _GR_->Zoom(*x1,*y1,*x2,*y2); }\r
-void mgl_rotate_vector_(uintptr_t *gr, float *Tet,float *x,float *y,float *z)\r
+void mgl_rotate_vector_(uintptr_t *gr, mreal *Tet,mreal *x,mreal *y,mreal *z)\r
{ _GR_->RotateN(*Tet,*x,*y,*z); }\r
-void mgl_perspective_(uintptr_t *gr, float val)\r
+void mgl_perspective_(uintptr_t *gr, mreal val)\r
{ _GR_->Perspective(val); }\r
//-----------------------------------------------------------------------------\r
const unsigned char *mgl_get_rgb_(uintptr_t *gr) { return gr ? _GR_->GetBits():0; }\r
//-----------------------------------------------------------------------------\r
HMGL mgl_create_graph(int width, int height)\r
{ return new mglCanvas(width,height); }\r
-void mgl_delete_graph(HMGL gr) { delete gr; }\r
+void mgl_delete_graph(HMGL gr) { if(gr) delete gr; }\r
void mgl_set_size(HMGL gr, int width, int height)\r
{ _Gr_->SetSize(width, height); }\r
void mgl_set_def_param(HMGL gr) { _Gr_->DefaultPlotParam(); }\r
{ const mglCanvas *gg = dynamic_cast<const mglCanvas *>(in);\r
if(gg) _Gr_->Combine(gg); }\r
//-----------------------------------------------------------------------------\r
-void mgl_set_tick_len(HMGL gr, float len, float stt)\r
+void mgl_set_tick_len(HMGL gr, mreal len, mreal stt)\r
{ _Gr_->SetTickLen(len,stt); }\r
void mgl_set_axis_stl(HMGL gr, const char *stl, const char *tck, const char *sub)\r
{ _Gr_->SetAxisStl(stl,tck,sub); }\r
-void mgl_tune_ticks(HMGL gr, int tune, float pos)\r
+void mgl_tune_ticks(HMGL gr, int tune, mreal pos)\r
{ _Gr_->SetTuneTicks(tune,pos); }\r
void mgl_adjust_ticks(HMGL gr, const char *dir)\r
{ _Gr_->AdjustTicks(dir,true); }\r
-void mgl_set_ticks(HMGL gr, char dir, float d, int ns, float org)\r
+void mgl_set_ticks(HMGL gr, char dir, mreal d, int ns, mreal org)\r
{ _Gr_->SetTicks(dir,d,ns,org); }\r
void mgl_set_ticks_str(HMGL gr, char dir, const char *lbl, int add)\r
{ _Gr_->SetTicksVal(dir,lbl,add); }\r
{ _Gr_->SetTickTempl(dir,templ); }\r
void mgl_set_tick_templw(HMGL gr, char dir, const wchar_t *templ)\r
{ _Gr_->SetTickTempl(dir,templ); }\r
-void mgl_set_ticks_time(HMGL gr, char dir, float d, const char *t)\r
+void mgl_set_ticks_time(HMGL gr, char dir, mreal d, const char *t)\r
{ _Gr_->SetTickTime(dir,d,t); }\r
//-----------------------------------------------------------------------------\r
void mgl_box(HMGL gr) { _Gr_->Box(); }\r
{ _Gr_->Grid(dir,pen); }\r
void mgl_label(HMGL gr, char dir, const char *text)\r
{ _Gr_->Label(dir,text); }\r
-void mgl_label_ext(HMGL gr, char dir, const char *text, float pos, float shift)\r
+void mgl_label_ext(HMGL gr, char dir, const char *text, mreal pos, mreal shift)\r
{ _Gr_->Label(dir,text,pos,shift); }\r
-void mgl_labelw_ext(HMGL gr, char dir, const wchar_t *text, float pos, float shift)\r
+void mgl_labelw_ext(HMGL gr, char dir, const wchar_t *text, mreal pos, mreal shift)\r
{ _Gr_->Labelw(dir,text,pos,shift); }\r
//-----------------------------------------------------------------------------\r
void mgl_colorbar(HMGL gr, const char *sch)\r
{ _Gr_->Colorbar(sch); }\r
-void mgl_colorbar_ext(HMGL gr, const char *sch, float x, float y, float w, float h)\r
+void mgl_colorbar_ext(HMGL gr, const char *sch, mreal x, mreal y, mreal w, mreal h)\r
{ _Gr_->Colorbar(sch,x,y,w,h); }\r
void mgl_colorbar_val(HMGL gr, HCDT dat, const char *sch)\r
{ _Gr_->Colorbar(dat,sch); }\r
-void mgl_colorbar_val_ext(HMGL gr, HCDT dat, const char *sch,float x, float y, float w, float h)\r
+void mgl_colorbar_val_ext(HMGL gr, HCDT dat, const char *sch,mreal x, mreal y, mreal w, mreal h)\r
{ _Gr_->Colorbar(dat,sch,x,y,w,h); }\r
//-----------------------------------------------------------------------------\r
void mgl_add_legend(HMGL gr, const char *text,const char *style)\r
{ _Gr_->AddLegend(text,style); }\r
void mgl_clear_legend(HMGL gr)\r
{ _Gr_->ClearLegend(); }\r
-void mgl_legend_pos(HMGL gr, float x, float y, const char *font, float size, float llen)\r
+void mgl_legend_pos(HMGL gr, mreal x, mreal y, const char *font, mreal size, mreal llen)\r
{ _Gr_->Legend(x,y,font,size,llen); }\r
-void mgl_legend(HMGL gr, int where, const char *font, float size, float llen)\r
+void mgl_legend(HMGL gr, int where, const char *font, mreal size, mreal llen)\r
{ _Gr_->Legend(where,font,size,llen); }\r
void mgl_set_legend_marks(HMGL gr, int num)\r
{ _Gr_->SetLegendMarks(num); }\r
void mgl_combine_gr_(uintptr_t *gr, uintptr_t *in)\r
{ _GR_->Combine((mglCanvas *)in); }\r
//-----------------------------------------------------------------------------\r
-void mgl_set_tick_len_(uintptr_t *gr, float *len, float *stt)\r
+void mgl_set_tick_len_(uintptr_t *gr, mreal *len, mreal *stt)\r
{ _GR_->SetTickLen(*len, *stt); }\r
void mgl_set_axis_stl_(uintptr_t *gr, const char *stl, const char *tck, const char *sub, int l,int m,int n)\r
{ char *a=new char[l+1]; memcpy(a,stl,l); a[l]=0;\r
void mgl_adjust_ticks_(uintptr_t *gr, const char *dir, int l)\r
{ char *s=new char[l+1]; memcpy(s,dir,l); s[l]=0;\r
_GR_->AdjustTicks(s); delete []s; }\r
-void mgl_set_ticks_(uintptr_t *gr, char *dir, float *d, int *ns, float *org, int)\r
+void mgl_set_ticks_(uintptr_t *gr, char *dir, mreal *d, int *ns, mreal *org, int)\r
{ _GR_->SetTicks(*dir, *d, *ns, *org); }\r
void mgl_set_ticks_str_(uintptr_t *gr, const char *dir, const char *lbl, int *add,int,int l)\r
{ char *s=new char[l+1]; memcpy(s,lbl,l); s[l]=0;\r
void mgl_set_ticks_val_(uintptr_t *gr, const char *dir, uintptr_t *val, const char *lbl, int *add,int,int l)\r
{ char *s=new char[l+1]; memcpy(s,lbl,l); s[l]=0;\r
_GR_->SetTicksVal(*dir,_DA_(val),s,*add); delete []s; }\r
-void mgl_tune_ticks_(uintptr_t *gr, int *tune, float *fact_pos)\r
+void mgl_tune_ticks_(uintptr_t *gr, int *tune, mreal *fact_pos)\r
{ _GR_->SetTuneTicks(*tune, *fact_pos); }\r
void mgl_set_tick_templ_(uintptr_t *gr, const char *dir, const char *templ,int,int l)\r
{ char *s=new char[l+1]; memcpy(s,templ,l); s[l]=0;\r
_GR_->SetTickTempl(*dir,s); delete []s; }\r
-void mgl_set_ticks_time_(uintptr_t *gr, const char *dir, float *d, const char *t,int,int l)\r
+void mgl_set_ticks_time_(uintptr_t *gr, const char *dir, mreal *d, const char *t,int,int l)\r
{ char *s=new char[l+1]; memcpy(s,t,l); s[l]=0;\r
_GR_->SetTickTime(*dir,*d,s); delete []s; }\r
//-----------------------------------------------------------------------------\r
void mgl_label_(uintptr_t *gr, const char *dir, const char *text,int,int l)\r
{ char *s=new char[l+1]; memcpy(s,text,l); s[l]=0;\r
_GR_->Label(*dir, s); delete []s; }\r
-void mgl_label_ext_(uintptr_t *gr, const char *dir, const char *text, float *pos, float *shift,int,int l)\r
+void mgl_label_ext_(uintptr_t *gr, const char *dir, const char *text, mreal *pos, mreal *shift,int,int l)\r
{ char *s=new char[l+1]; memcpy(s,text,l); s[l]=0;\r
_GR_->Label(*dir, s, *pos, *shift); delete []s; }\r
//-----------------------------------------------------------------------------\r
void mgl_colorbar_(uintptr_t *gr, const char *sch,int l)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
_GR_->Colorbar(s); delete []s; }\r
-void mgl_colorbar_ext_(uintptr_t *gr, const char *sch, float *x, float *y, float *w, float *h, int l)\r
+void mgl_colorbar_ext_(uintptr_t *gr, const char *sch, mreal *x, mreal *y, mreal *w, mreal *h, int l)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
_GR_->Colorbar(s,*x,*y,*w,*h); delete []s; }\r
void mgl_colorbar_val_(uintptr_t *gr, uintptr_t *dat, const char *sch,int l)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
_GR_->Colorbar(_DA_(dat), s); delete []s; }\r
-void mgl_colorbar_val_ext_(uintptr_t *gr, uintptr_t *dat, const char *sch, float *x, float *y, float *w, float *h, int l)\r
+void mgl_colorbar_val_ext_(uintptr_t *gr, uintptr_t *dat, const char *sch, mreal *x, mreal *y, mreal *w, mreal *h, int l)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
_GR_->Colorbar(_DA_(dat),s,*x,*y,*w,*h); delete []s; }\r
//-----------------------------------------------------------------------------\r
char *f=new char[n+1]; memcpy(f,style,n); f[n]=0;\r
_GR_->AddLegend(s,f); delete []s; delete []f; }\r
void mgl_clear_legend_(uintptr_t *gr) { if(gr) _GR_->ClearLegend(); }\r
-void mgl_legend_pos_(uintptr_t *gr, float *x, float *y, const char *font, float *size, float *llen,int l)\r
+void mgl_legend_pos_(uintptr_t *gr, mreal *x, mreal *y, const char *font, mreal *size, mreal *llen,int l)\r
{ char *s=new char[l+1]; memcpy(s,font,l); s[l]=0;\r
_GR_->Legend(*x, *y, s, *size,*llen); delete []s; }\r
-void mgl_legend_(uintptr_t *gr, int *where, const char *font, float *size, float *llen,int l)\r
+void mgl_legend_(uintptr_t *gr, int *where, const char *font, mreal *size, mreal *llen,int l)\r
{ char *s=new char[l+1]; memcpy(s,font,l); s[l]=0;\r
_GR_->Legend(*where, s, *size,*llen); delete []s; }\r
void mgl_set_legend_marks_(uintptr_t *gr, int *num)\r
void mgl_mpi_recv_(uintptr_t *gr, int *id) { mgl_mpi_recv(_GR_, *id); }\r
//-----------------------------------------------------------------------------\r
void mgl_wnd_set_delay_(uintptr_t *gr, mreal *dt) { _GR_->SetDelay(*dt); }\r
-void mgl_wnd_set_delay(HMGL gr, float dt) { _Gr_->SetDelay(dt); }\r
+void mgl_wnd_set_delay(HMGL gr, mreal dt) { _Gr_->SetDelay(dt); }\r
//-----------------------------------------------------------------------------\r
HMEX mgl_create_expr(const char *expr) { return new mglFormula(expr); }\r
void mgl_delete_expr(HMEX ex) { delete ex; }\r
uintptr_t res = uintptr_t(mgl_create_expr(s));\r
delete []s; return res; }\r
void mgl_delete_expr_(uintptr_t *ex) { mgl_delete_expr((HMEX)ex); }\r
-float mgl_eval_expr_(uintptr_t *ex, float *x, float *y,float *z)\r
+mreal mgl_eval_expr_(uintptr_t *ex, mreal *x, mreal *y,mreal *z)\r
{ return mgl_expr_eval((HMEX) ex, *x,*y,*z); }\r
-float mgl_diff_expr_(uintptr_t *ex, const char *dir, float *x, float *y,float *z, int)\r
+mreal mgl_diff_expr_(uintptr_t *ex, const char *dir, mreal *x, mreal *y,mreal *z, int)\r
{ return mgl_expr_diff((HMEX) ex, *dir,*x,*y,*z); }\r
//-----------------------------------------------------------------------------\r
-void mgl_set_plotfactor(HMGL gr, float val)\r
+void mgl_set_plotfactor(HMGL gr, mreal val)\r
{ _Gr_->SetPlotFactor(val); }\r
-void mgl_set_plotfactor_(uintptr_t *gr, float *val)\r
+void mgl_set_plotfactor_(uintptr_t *gr, mreal *val)\r
{ _GR_->SetPlotFactor(*val); }\r
//-----------------------------------------------------------------------------\r
+void mgl_set_tick_shift(HMGL gr, mreal sx, mreal sy, mreal sz, mreal sc)\r
+{ _Gr_->SetTickShift(mglPoint(sx,sy,sz,sc)); }\r
+void mgl_set_tick_shift_(uintptr_t *gr, mreal *sx, mreal *sy, mreal *sz, mreal *sc)\r
+{ _GR_->SetTickShift(mglPoint(*sx,*sy,*sz,*sc)); }\r
+//-----------------------------------------------------------------------------\r
+#if !MGL_HAVE_PNG\r
+void mgl_write_prc(HMGL gr, const char *fname,const char *descr, int make_pdf){}\r
+void mgl_write_prc_(uintptr_t *graph, const char *fname,const char *descr, int *make_pdf,int lf,int ld){}\r
+#endif\r
+//-----------------------------------------------------------------------------\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <wchar.h>\r
#include <algorithm>\r
#include "mgl2/surf.h"\r
#include "mgl2/cont.h"\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_string_curve(mglBase *gr,long f,long ,long *ff,long *nn,const wchar_t *text, const char *font, float size)\r
+void mgl_string_curve(mglBase *gr,long f,long ,long *ff,long *nn,const wchar_t *text, const char *font, mreal size)\r
{\r
if(nn[f]==-1) return; // do nothing since there is no curve\r
if(!font) font="";\r
int pos = strchr(font,'t') ? 1:-1, align;\r
char cc=mglGetStyle(font,0,&align); align = align&3;\r
- float c=cc ? -cc : gr->GetClrC(ff[f]);\r
+ mreal c=cc ? -cc : gr->GetClrC(ff[f]);\r
long len = wcslen(text);\r
char *fnt = new char[strlen(font)+3]; strcpy(fnt,font);\r
- float *wdt=new float[len+1], h=gr->TextHeight(font,size)/4, tet, tt; // TODO optimaze ratio\r
+ mreal *wdt=new mreal[len+1], h=gr->TextHeight(font,size)/4, tet, tt; // TODO optimaze ratio\r
mglPoint *pt=new mglPoint[len+1];\r
wchar_t L[2]=L"a";\r
register long i,j,k,m;\r
\r
// place glyphs points\r
pt[0] = qa[0]; m = qa.size();\r
- float a,b,d,w,t1,t2;\r
+ mreal a,b,d,w,t1,t2;\r
for(i=j=0,tt=0;j<len;j++)\r
{\r
if(gr->Stop) { delete []wdt; delete []pt; delete []fnt; return; }\r
if(rev) pos=-pos;\r
for(j=0;j<len;j++) // draw text\r
{ L[0] = text[align!=2?j:len-1-j]; s = pt[j+1]-pt[j]; l = !s;\r
- gr->text_plot(gr->AddPnt(pt[j]-(pos*h)*l,c,s,-1,-1),L,font,size,0,c); }\r
+ gr->text_plot(gr->AddPnt(pt[j]-(pos*h)*l,c,s,-1,-1),L,font,size,0.05,c); }\r
delete []wdt; delete []pt; delete []fnt;\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_textw_xyz(HMGL gr, HCDT x, HCDT y, HCDT z,const wchar_t *text, const char *font, const char *opt)\r
{\r
long n=y->GetNx();\r
- if(x->GetNx()!=n || z->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Text"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Text"); return; }\r
+ if(mgl_check_dim1(gr,x,y,z,0,"Text")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("TextC",cgid++);\r
\r
long *nn = new long[n], *ff = new long[n];\r
mglPoint p;\r
register long i;\r
- for(i=0;i<n;i++)\r
- {\r
- p = mglPoint(x->v(i),y->v(i),z->v(i));\r
- ff[i] = gr->AddPnt(p,-1);\r
- }\r
+ const mglData *mdx = dynamic_cast<const mglData *>(x);\r
+ const mglData *mdy = dynamic_cast<const mglData *>(y);\r
+ const mglData *mdz = dynamic_cast<const mglData *>(z);\r
+ if(mdx && mdy && mdz) for(i=0;i<n;i++)\r
+ { p = mglPoint(mdx->a[i],mdy->a[i],mdz->a[i]); ff[i] = gr->AddPnt(p,-1); }\r
+ else for(i=0;i<n;i++)\r
+ { p = mglPoint(x->v(i),y->v(i),z->v(i)); ff[i] = gr->AddPnt(p,-1); }\r
for(i=1;i<n;i++) nn[i-1] = i;\r
nn[n-1]=-1;\r
mgl_string_curve(gr,0,n,ff,nn,text,font,-1);\r
//-----------------------------------------------------------------------------\r
void mgl_textw_xy(HMGL gr, HCDT x, HCDT y, const wchar_t *text, const char *font, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Text"); return; }\r
gr->SaveState(opt);\r
mglData z(y->GetNx());\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_textw_xyz(gr,x,y,&z,text,font,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_textw_y(HMGL gr, HCDT y, const wchar_t *text, const char *font, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Text"); return; }\r
gr->SaveState(opt);\r
mglData x(y->GetNx()), z(y->GetNx());\r
x.Fill(gr->Min.x,gr->Max.x);\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_textw_xyz(gr,&x,y,&z,text,font,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_text_xyz(HMGL gr, HCDT x, HCDT y, HCDT z,const char *text, const char *font, const char *opt)\r
//-----------------------------------------------------------------------------\r
void mgl_text_xy(HMGL gr, HCDT x, HCDT y, const char *text, const char *font, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Text"); return; }\r
mglData z(y->GetNx());\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_text_xyz(gr,x,y,&z,text,font,opt);\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_text_y(HMGL gr, HCDT y, const char *text, const char *font, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Text"); return; }\r
mglData x(y->GetNx()), z(y->GetNx());\r
x.Fill(gr->Min.x,gr->Max.x);\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_text_xyz(gr,&x,y,&z,text,font,opt);\r
}\r
//-----------------------------------------------------------------------------\r
mglSegment(mglPoint q1,mglPoint q2) {p1=q1;p2=q2;next=prev=-1;}\r
};\r
// function for connecting arbitrary line segments\r
-/*void mgl_connect(HMGL gr, float val, HCDT a, HCDT x, HCDT y, HCDT z, float c, int text,long ak)\r
+/*void mgl_connect(HMGL gr, mreal val, HCDT a, HCDT x, HCDT y, HCDT z, mreal c, int text,long ak)\r
{\r
long n=a->GetNx(), m=a->GetNy();\r
if(n<2 || m<2 || x->GetNx()*x->GetNy()!=n*m || y->GetNx()*y->GetNy()!=n*m || z->GetNx()*z->GetNy()!=n*m)\r
std::vector<mglSegment> ss,cc;\r
\r
register long i,j;\r
- float d1,d2,d3,d4;\r
+ mreal d1,d2,d3,d4;\r
bool o1,o2,o3,o4;\r
mglPoint p1,p2,p3,p4,q1,q2,q3,q4;\r
for(i=0;i<n;i++) for(j=0;j<m;j++) // prepare segments\r
}*/\r
//-----------------------------------------------------------------------------\r
// NOTE! returned must be deleted!!!\r
-struct mglPnt2 { float x,y; mglPnt2(float xx=0,float yy=0) {x=xx;y=yy;} };\r
-long *mgl_cont_prep(float val, HCDT a,long ak, std::vector<mglPnt2> &kk)\r
+struct mglPnt2 { mreal x,y; mglPnt2(mreal xx=0,mreal yy=0) {x=xx;y=yy;} };\r
+long *mgl_cont_prep(mreal val, HCDT a,long ak, std::vector<mglPnt2> &kk)\r
{\r
long n=a->GetNx(), m=a->GetNy();\r
- float d, r, kx, ky;\r
+ mreal d, r, kx, ky;\r
register long i,j,k, pc=0;\r
kk.clear();\r
// add intersection point of isoline and Y axis\r
- for(i=0;i<n-1;i++) for(j=0;j<m;j++)\r
+ const mglData *ma = dynamic_cast<const mglData *>(a);\r
+ if(ma)\r
{\r
- d = mgl_d(val,a->v(i,j,ak),a->v(i+1,j,ak));\r
- if(d>=0 && d<1) kk.push_back(mglPnt2(i+d,j));\r
+ for(i=0;i<n-1;i++) for(j=0;j<m;j++)\r
+ {\r
+ d = mgl_d(val,ma->a[i+n*(j+m*ak)],ma->a[i+1+n*(j+m*ak)]);\r
+ if(d>=0 && d<1) kk.push_back(mglPnt2(i+d,j));\r
+ }\r
+ // add intersection point of isoline and X axis\r
+ for(i=0;i<n;i++) for(j=0;j<m-1;j++)\r
+ {\r
+ d = mgl_d(val,ma->a[i+n*(j+m*ak)],ma->a[i+n*(j+1+m*ak)]);\r
+ if(d>=0 && d<1) kk.push_back(mglPnt2(i,j+d));\r
+ }\r
}\r
- // add intersection point of isoline and X axis\r
- for(i=0;i<n;i++) for(j=0;j<m-1;j++)\r
+ else for(i=0;i<n-1;i++) for(j=0;j<m;j++)\r
{\r
- d = mgl_d(val,a->v(i,j,ak),a->v(i,j+1,ak));\r
+ register mreal vv = a->v(i,j,ak);\r
+ d = (i<n-1)?mgl_d(val,vv,a->v(i+1,j,ak)):-1;\r
+ if(d>=0 && d<1) kk.push_back(mglPnt2(i+d,j));\r
+ d = (j<m-1)?mgl_d(val,vv,a->v(i,j+1,ak)):-1;\r
if(d>=0 && d<1) kk.push_back(mglPnt2(i,j+d));\r
}\r
\r
}\r
//-----------------------------------------------------------------------------\r
// NOTE! All data MUST have the same size! Only first slice is used!\r
-void mgl_cont_gen(HMGL gr, float val, HCDT a, HCDT x, HCDT y, HCDT z, float c, int text,long ak)\r
+void mgl_cont_gen(HMGL gr, mreal val, HCDT a, HCDT x, HCDT y, HCDT z, mreal c, int text,long ak)\r
{\r
long n=a->GetNx(), m=a->GetNy();\r
if(n<2 || m<2 || x->GetNx()*x->GetNy()!=n*m || y->GetNx()*y->GetNy()!=n*m || z->GetNx()*z->GetNy()!=n*m)\r
long *nn = mgl_cont_prep(val, a, ak, kk), *ff;\r
if(!nn) return; // nothing to do\r
register long i, pc=kk.size();\r
- register float xx, yy;\r
+ register mreal xx, yy;\r
ff = new long[pc]; gr->Reserve(pc);\r
for(i=0;i<pc;i++)\r
{\r
wchar_t wcs[64];\r
mglprintf(wcs,64,L"%4.3g",val);\r
mglPoint t;\r
- float del = 2*gr->TextWidth(wcs,"",-0.5);\r
+ mreal del = 2*gr->TextWidth(wcs,"",-0.5);\r
// find width and height of drawing area\r
- float ar=gr->GetRatio(), w=gr->FontFactor(), h;\r
+ mreal ar=gr->GetRatio(), w=gr->FontFactor(), h;\r
if(del<w/5) del = w/5;\r
if(ar<1) h=w/ar; else { h=w; w*=ar; }\r
m=long(2*w/del)+1; n=long(2*h/del)+1; // don't need data size anymore\r
long *oo=new long[n*m];\r
- float *rr=new float[n*m];\r
+ mreal *rr=new mreal[n*m];\r
for(i=0;i<n*m;i++) { oo[i]=-1; rr[i]=del*del/4; }\r
\r
register long j,k;\r
delete []nn; delete []ff;\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_cont_gen(HMGL gr, float val, HCDT a, HCDT x, HCDT y, HCDT z, const char *sch)\r
+void mgl_cont_gen(HMGL gr, mreal val, HCDT a, HCDT x, HCDT y, HCDT z, const char *sch)\r
{\r
bool text=(sch && strchr(sch,'t'));\r
gr->SetPenPal(sch);\r
void mgl_cont_xy_val(HMGL gr, HCDT v, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Cont"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Cont"); return; }\r
- bool both = x->GetNx()*x->GetNy()==m*n && y->GetNx()*y->GetNy()==m*n;\r
- if(y->GetNx()!=z->GetNy() && !both) { gr->SetWarn(mglWarnDim, "Cont"); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,0,"Cont")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Cont",cgid++);\r
\r
gr->SetPenPal(sch);\r
\r
mglData xx, yy, zz(z->GetNx(), z->GetNy());\r
- if(!both) // make\r
+ if(x->GetNx()*x->GetNy()!=m*n || y->GetNx()*y->GetNy()!=m*n) // make\r
{\r
- xx.Create(z->GetNx(), z->GetNy());\r
- yy.Create(z->GetNx(), z->GetNy());\r
- for(i=0;i<n;i++) for(j=0;j<m;j++)\r
+ xx.Create(n, m); yy.Create(n, m);\r
+ const mglData *mx = dynamic_cast<const mglData *>(x);\r
+ const mglData *my = dynamic_cast<const mglData *>(y);\r
+ if(mx && my) for(i=0;i<n;i++) for(j=0;j<m;j++)\r
+ { xx.a[i+n*j] = mx->a[i]; yy.a[i+n*j] = my->a[j]; }\r
+ else for(i=0;i<n;i++) for(j=0;j<m;j++)\r
{ xx.a[i+n*j] = x->v(i); yy.a[i+n*j] = y->v(j); }\r
x = &xx; y = &yy;\r
}\r
// x, y -- have the same size z\r
- float z0, v0;\r
+ mreal z0, v0;\r
for(j=0;j<z->GetNz();j++) for(i=0;i<v->GetNx();i++)\r
{\r
if(gr->Stop) return;\r
v0 = v->v(i); z0 = fixed ? gr->Min.z : v0;\r
if(z->GetNz()>1)\r
- z0 = gr->Min.z+(gr->Max.z-gr->Min.z)*float(j)/(z->GetNz()-1);\r
+ z0 = gr->Min.z+(gr->Max.z-gr->Min.z)*mreal(j)/(z->GetNz()-1);\r
zz.Fill(z0,z0);\r
mgl_cont_gen(gr,v0,z,x,y,&zz,gr->GetC(s,v0),text,j);\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_cont_val(HMGL gr, HCDT v, HCDT z, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2) { gr->SetWarn(mglWarnLow,"Cont"); return; }\r
+ register long n = z->GetNx(), m = z->GetNy();\r
+ if(m<2 || n<2) { gr->SetWarn(mglWarnLow,"Cont"); return; }\r
gr->SaveState(opt);\r
- mglData x(z->GetNx(), z->GetNy()), y(z->GetNx(), z->GetNy());\r
+ mglData x(n, m), y(n, m);\r
x.Fill(gr->Min.x,gr->Max.x,'x');\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_cont_xy_val(gr,v,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_cont_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
mglData v(Num);\r
- for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(Num+1);\r
+ for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_cont_xy_val(gr,&v,x,y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_cont(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
mglData v(Num);\r
- for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(Num+1);\r
+ for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_cont_val(gr,&v,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_cont_xy_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
// ContF series\r
//\r
//-----------------------------------------------------------------------------\r
-long mgl_add_pnt(HMGL gr, float d, HCDT x, HCDT y, HCDT z, long i1, long j1, long i2, long j2, float c, bool edge)\r
+long mgl_add_pnt(HMGL gr, mreal d, HCDT x, HCDT y, HCDT z, long i1, long j1, long i2, long j2, mreal c, bool edge)\r
{\r
long res=-1;\r
if(edge || (d>0 && d<1))\r
return res;\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_add_range(HMGL gr, HCDT a, HCDT x, HCDT y, HCDT z, long i1, long j1, long di, long dj, float c, long &u1, long &u2, long ak, float v1, float v2)\r
+void mgl_add_range(HMGL gr, HCDT a, HCDT x, HCDT y, HCDT z, long i1, long j1, long di, long dj, mreal c, long &u1, long &u2, long ak, mreal v1, mreal v2)\r
{\r
long i2=i1+di, j2=j1+dj;\r
\r
- float f1 = a->v(i1,j1,ak), f2 = a->v(i2,j2,ak), d1, d2;\r
+ mreal f1 = a->v(i1,j1,ak), f2 = a->v(i2,j2,ak), d1, d2;\r
d1 = mgl_d(v1,f1,f2);\r
u1 = mgl_add_pnt(gr,d1,x,y,z,i1,j1,i2,j2,c,false);\r
d2 = mgl_d(v2,f1,f2);\r
if(d1>d2) { j2=u1; u1=u2; u2=j2; }\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_add_edges(HMGL gr, HCDT a, HCDT x, HCDT y, HCDT z, long i1, long j1, long di, long dj, float c, long &u1, long &u2, long ak, float v1, float v2)\r
+void mgl_add_edges(HMGL gr, HCDT a, HCDT x, HCDT y, HCDT z, long i1, long j1, long di, long dj, mreal c, long &u1, long &u2, long ak, mreal v1, mreal v2)\r
{\r
long i2=i1+di, j2=j1+dj;\r
u1 = u2 = -1;\r
\r
- float f1 = a->v(i1,j1,ak), f2 = a->v(i2,j2,ak);\r
+ mreal f1 = a->v(i1,j1,ak), f2 = a->v(i2,j2,ak);\r
if(f1<=v2 && f1>=v1)\r
u1 = mgl_add_pnt(gr,0,x,y,z,i1,j1,i2,j2,c,true);\r
if(f2<=v2 && f2>=v1)\r
u2 = mgl_add_pnt(gr,1,x,y,z,i1,j1,i2,j2,c,true);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_contf_gen(HMGL gr, float v1, float v2, HCDT a, HCDT x, HCDT y, HCDT z, float c, long ak)\r
+void mgl_contf_gen(HMGL gr, mreal v1, mreal v2, HCDT a, HCDT x, HCDT y, HCDT z, mreal c, long ak)\r
{\r
long n=a->GetNx(), m=a->GetNy();\r
if(n<2 || m<2 || x->GetNx()*x->GetNy()!=n*m || y->GetNx()*y->GetNy()!=n*m || z->GetNx()*z->GetNy()!=n*m)\r
delete []kk;\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_contf_gen(HMGL gr, float v1, float v2, HCDT a, HCDT x, HCDT y, HCDT z, const char *c)\r
+void mgl_contf_gen(HMGL gr, mreal v1, mreal v2, HCDT a, HCDT x, HCDT y, HCDT z, const char *c)\r
{\r
gr->SetPenPal(c);\r
mgl_contf_gen(gr,v1,v2,a,x,y,z,gr->CDef,0);\r
void mgl_contf_xy_val(HMGL gr, HCDT v, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=n) { gr->SetWarn(mglWarnDim,"ContF"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContF"); return; }\r
- bool both = x->GetNx()*x->GetNy()==m*n && y->GetNx()*y->GetNy()==m*n;\r
- if(y->GetNx()!=z->GetNy() && !both) { gr->SetWarn(mglWarnDim, "ContF"); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,0,"ContF")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("ContF",cgid++);\r
long s=gr->AddTexture(sch);\r
\r
bool fixed=(sch && strchr(sch,'_')) || (gr->Min.z==gr->Max.z);\r
- mglData xx, yy, zz(z->GetNx(), z->GetNy());\r
- if(!both) // make\r
+ mglData xx, yy, zz(n, m);\r
+ if(x->GetNx()*x->GetNy()!=m*n || y->GetNx()*y->GetNy()!=m*n) // make\r
{\r
- xx.Create(z->GetNx(), z->GetNy());\r
- yy.Create(z->GetNx(), z->GetNy());\r
- for(j=0;j<m;j++) for(i=0;i<n;i++)\r
+ xx.Create(n, m); yy.Create(n, m);\r
+ const mglData *mx = dynamic_cast<const mglData *>(x);\r
+ const mglData *my = dynamic_cast<const mglData *>(y);\r
+ if(mx && my) for(i=0;i<n;i++) for(j=0;j<m;j++)\r
+ { xx.a[i+n*j] = mx->a[i]; yy.a[i+n*j] = my->a[j]; }\r
+ else for(i=0;i<n;i++) for(j=0;j<m;j++)\r
{ xx.a[i+n*j] = x->v(i); yy.a[i+n*j] = y->v(j); }\r
x = &xx; y = &yy;\r
}\r
// x, y -- have the same size z\r
- float z0, v0;\r
+ mreal z0, v0;\r
for(j=0;j<z->GetNz();j++) for(i=0;i<v->GetNx()-1;i++)\r
{\r
if(gr->Stop) return;\r
v0 = v->v(i); z0 = fixed ? gr->Min.z : v0;\r
if(z->GetNz()>1)\r
- z0 = gr->Min.z+(gr->Max.z-gr->Min.z)*float(j)/(z->GetNz()-1);\r
+ z0 = gr->Min.z+(gr->Max.z-gr->Min.z)*mreal(j)/(z->GetNz()-1);\r
zz.Fill(z0,z0);\r
mgl_contf_gen(gr,v0,v->v(i+1),z,x,y,&zz,gr->GetC(s,v0),j);\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_contf_val(HMGL gr, HCDT v, HCDT z, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2) { gr->SetWarn(mglWarnLow,"Cont"); return; }\r
+ register long n = z->GetNx(), m = z->GetNy();\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Cont"); return; }\r
gr->SaveState(opt);\r
- mglData x(z->GetNx(), z->GetNy()), y(z->GetNx(), z->GetNy());\r
+ mglData x(n, m), y(n, m);\r
x.Fill(gr->Min.x,gr->Max.x,'x');\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_contf_xy_val(gr,v,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_contf_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
mglData v(Num+2); v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contf_xy_val(gr,&v,x,y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_contf(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
mglData v(Num+2); v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contf_val(gr,&v,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_contf_xy_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
void mgl_contd_xy_val(HMGL gr, HCDT v, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j=0,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=n) { gr->SetWarn(mglWarnDim,"ContD"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContD"); return; }\r
- bool both = x->GetNx()*x->GetNy()==m*n && y->GetNx()*y->GetNy()==m*n;\r
- if(y->GetNx()!=z->GetNy() && !both) { gr->SetWarn(mglWarnDim, "ContD"); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,0,"ContD")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("ContD",cgid++);\r
\r
if(j==0) sch = MGL_DEF_PAL;\r
long s = gr->AddTexture(sch,1);\r
int nc = gr->GetNumPal(s*256);\r
- mglData xx, yy, zz(z->GetNx(), z->GetNy());\r
- if(!both) // make\r
+ mglData xx, yy, zz(n, m);\r
+ if(x->GetNx()*x->GetNy()!=m*n || y->GetNx()*y->GetNy()!=m*n) // make\r
{\r
- xx.Create(z->GetNx(), z->GetNy());\r
- yy.Create(z->GetNx(), z->GetNy());\r
- for(i=0;i<n;i++) for(j=0;j<m;j++)\r
+ xx.Create(n, m); yy.Create(n, m);\r
+ const mglData *mx = dynamic_cast<const mglData *>(x);\r
+ const mglData *my = dynamic_cast<const mglData *>(y);\r
+ if(mx && my) for(i=0;i<n;i++) for(j=0;j<m;j++)\r
+ { xx.a[i+n*j] = mx->a[i]; yy.a[i+n*j] = my->a[j]; }\r
+ else for(i=0;i<n;i++) for(j=0;j<m;j++)\r
{ xx.a[i+n*j] = x->v(i); yy.a[i+n*j] = y->v(j); }\r
x = &xx; y = &yy;\r
}\r
// x, y -- have the same size z\r
- float z0, v0, dc = nc>1 ? 1/(MGL_FLT_EPS*(nc-1)) : 0;\r
+ mreal z0, v0, dc = nc>1 ? 1/(MGL_EPSILON*(nc-1)) : 0;\r
for(j=0;j<z->GetNz();j++) for(i=0;i<v->GetNx()-1;i++)\r
{\r
if(gr->Stop) return;\r
v0 = v->v(i); z0 = fixed ? gr->Min.z : v0;\r
if(z->GetNz()>1)\r
- z0 = gr->Min.z+(gr->Max.z-gr->Min.z)*float(j)/(z->GetNz()-1);\r
+ z0 = gr->Min.z+(gr->Max.z-gr->Min.z)*mreal(j)/(z->GetNz()-1);\r
zz.Fill(z0,z0);\r
mgl_contf_gen(gr,v0,v->v(i+1),z,x,y,&zz,s+i*dc,j);\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_contd_val(HMGL gr, HCDT v, HCDT z, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2) { gr->SetWarn(mglWarnLow,"ContD"); return; }\r
+ register long n = z->GetNx(), m = z->GetNy();\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContD"); return; }\r
gr->SaveState(opt);\r
- mglData x(z->GetNx(), z->GetNy()), y(z->GetNx(), z->GetNy());\r
+ mglData x(n, m), y(n, m);\r
x.Fill(gr->Min.x,gr->Max.x,'x');\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_contd_xy_val(gr,v,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_contd_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
mglData v(mgl_get_ncol(sch,0)+1);\r
v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contd_xy_val(gr,&v,x,y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_contd(HMGL gr, HCDT z, const char *sch, const char *opt)\r
mglData v(mgl_get_ncol(sch,0)+1);\r
v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contd_val(gr,&v,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_contd_xy_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
//\r
//-----------------------------------------------------------------------------\r
// NOTE! All data MUST have the same size! Only first slice is used!\r
-void mgl_contv_gen(HMGL gr, float val, float dval, HCDT a, HCDT x, HCDT y, HCDT z, float c, long ak)\r
+void mgl_contv_gen(HMGL gr, mreal val, mreal dval, HCDT a, HCDT x, HCDT y, HCDT z, mreal c, long ak)\r
{\r
long n=a->GetNx(), m=a->GetNy();\r
if(n<2 || m<2 || x->GetNx()*x->GetNy()!=n*m || y->GetNx()*y->GetNy()!=n*m || z->GetNx()*z->GetNy()!=n*m)\r
long *nn = mgl_cont_prep(val, a, ak, kk), *ff;\r
if(!nn) return; // nothing to do\r
register long i, pc=kk.size();\r
- register float xx, yy;\r
+ register mreal xx, yy;\r
ff = new long[2*pc]; gr->Reserve(2*pc);\r
mglPoint p,q;\r
for(i=0;i<pc;i++)\r
void mgl_contv_xy_val(HMGL gr, HCDT v, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Cont"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Cont"); return; }\r
- bool both = x->GetNx()*x->GetNy()==m*n && y->GetNx()*y->GetNy()==m*n;\r
- if(y->GetNx()!=z->GetNy() && !both) { gr->SetWarn(mglWarnDim, "Cont"); return; }\r
- gr->SaveState(opt);\r
- static int cgid=1; gr->StartGroup("Cont",cgid++);\r
+ if(mgl_check_dim2(gr,x,y,z,0,"ContV")) return;\r
\r
+ gr->SaveState(opt);\r
+ static int cgid=1; gr->StartGroup("ContV",cgid++);\r
bool fixed=(sch && strchr(sch,'_')) || (gr->Min.z==gr->Max.z);\r
long s=gr->AddTexture(sch);\r
gr->SetPenPal(sch);\r
\r
- mglData xx, yy, zz(z->GetNx(), z->GetNy());\r
- if(!both) // make\r
+ mglData xx, yy, zz(n, m);\r
+ if(x->GetNx()*x->GetNy()!=m*n || y->GetNx()*y->GetNy()!=m*n) // make\r
{\r
- xx.Create(z->GetNx(), z->GetNy());\r
- yy.Create(z->GetNx(), z->GetNy());\r
- for(i=0;i<n;i++) for(j=0;j<m;j++)\r
+ xx.Create(n, m); yy.Create(n, m);\r
+ const mglData *mx = dynamic_cast<const mglData *>(x);\r
+ const mglData *my = dynamic_cast<const mglData *>(y);\r
+ if(mx && my) for(i=0;i<n;i++) for(j=0;j<m;j++)\r
+ { xx.a[i+n*j] = mx->a[i]; yy.a[i+n*j] = my->a[j]; }\r
+ else for(i=0;i<n;i++) for(j=0;j<m;j++)\r
{ xx.a[i+n*j] = x->v(i); yy.a[i+n*j] = y->v(j); }\r
x = &xx; y = &yy;\r
}\r
// x, y -- have the same size z\r
- float z0, v0;\r
+ mreal z0, v0;\r
for(j=0;j<z->GetNz();j++) for(i=0;i<v->GetNx();i++)\r
{\r
if(gr->Stop) return;\r
v0 = v->v(i); z0 = fixed ? gr->Min.z : v0;\r
- if(z->GetNz()>1) z0 = gr->Min.z+(gr->Max.z-gr->Min.z)*float(j)/(z->GetNz()-1);\r
+ if(z->GetNz()>1) z0 = gr->Min.z+(gr->Max.z-gr->Min.z)*mreal(j)/(z->GetNz()-1);\r
zz.Fill(z0,z0);\r
- float dv = (gr->Max.c-gr->Min.c)/8;\r
+ mreal dv = (gr->Max.c-gr->Min.c)/8;\r
if(i>0) dv = v->v(i-1)-v->v(i);\r
else if(i<v->GetNx()-1) dv = v->v(i)-v->v(i+1);\r
if(fixed) dv=-dv;\r
//-----------------------------------------------------------------------------\r
void mgl_contv_val(HMGL gr, HCDT v, HCDT z, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2) { gr->SetWarn(mglWarnLow,"Cont"); return; }\r
+ register long n = z->GetNx(), m = z->GetNy();\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Cont"); return; }\r
gr->SaveState(opt);\r
- mglData x(z->GetNx(), z->GetNy()), y(z->GetNx(), z->GetNy());\r
+ mglData x(n, m), y(n, m);\r
x.Fill(gr->Min.x,gr->Max.x,'x');\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_contv_xy_val(gr,v,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_contv_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
mglData v(Num);\r
- for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(Num+1);\r
+ for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_contv_xy_val(gr,&v,x,y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_contv(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont"); gr->LoadState(); return; }\r
mglData v(Num);\r
- for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(Num+1);\r
+ for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_contv_val(gr,&v,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_contv_xy_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
//-----------------------------------------------------------------------------\r
struct _mgl_slice { mglData x,y,z,a; };\r
//-----------------------------------------------------------------------------\r
-void mgl_get_slice(_mgl_slice &s, HCDT x, HCDT y, HCDT z, HCDT a, char dir, float d, bool both)\r
+void mgl_get_slice(_mgl_slice &s, HCDT x, HCDT y, HCDT z, HCDT a, char dir, mreal d, bool both)\r
{\r
register long i,j,i0,n=a->GetNx(),m=a->GetNy(),l=a->GetNz(), nx=1,ny=1,p;\r
\r
if(dir=='x' && p>=n-1) { d+=p-n+2; p=n-2; }\r
if(dir=='y' && p>=m-1) { d+=p-m+2.; p=m-2; }\r
if(dir=='z' && p>=l-1) { d+=p-l+2; p=l-2; }\r
- float v;\r
+ mreal v;\r
\r
if(both)\r
{\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_cont3_xyz_val(HMGL gr, HCDT v, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_get_slice_md(_mgl_slice &s, const mglData *x, const mglData *y, const mglData *z, const mglData *a, char dir, mreal d, bool both)\r
{\r
- long n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
- if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,"Cont3"); return; }\r
- bool both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim,"Cont3"); return; }\r
+ register long i,j,i0,i1,n=a->nx,m=a->ny,l=a->nz, nx=1,ny=1,p;\r
+\r
+ if(dir=='x') { nx = m; ny = l; if(d<0) d = n/2.; }\r
+ if(dir=='y') { nx = n; ny = l; if(d<0) d = m/2.; }\r
+ if(dir=='z') { nx = n; ny = m; if(d<0) d = l/2.; }\r
+ s.x.Create(nx,ny); s.y.Create(nx,ny);\r
+ s.z.Create(nx,ny); s.a.Create(nx,ny);\r
+ p = long(d); d -= p;\r
+ if(dir=='x' && p>=n-1) { d+=p-n+2; p=n-2; }\r
+ if(dir=='y' && p>=m-1) { d+=p-m+2.; p=m-2; }\r
+ if(dir=='z' && p>=l-1) { d+=p-l+2; p=l-2; }\r
+ mreal v;\r
+\r
+ if(both)\r
+ {\r
+ if(dir=='x') for(j=0;j<ny;j++) for(i=0;i<nx;i++)\r
+ {\r
+ i0 = i+nx*j; i1 = p+n*(i+m*j);\r
+ s.x.a[i0] = x->a[i1]*(1-d) + x->a[i1+1]*d;\r
+ s.y.a[i0] = y->a[i1]*(1-d) + y->a[i1+1]*d;\r
+ s.z.a[i0] = z->a[i1]*(1-d) + z->a[i1+1]*d;\r
+ s.a.a[i0] = a->a[i1]*(1-d) + a->a[i1+1]*d;\r
+ }\r
+ if(dir=='y') for(j=0;j<ny;j++) for(i=0;i<nx;i++)\r
+ {\r
+ i0 = i+nx*j; i1 = i+n*(p+m*j);\r
+ s.x.a[i0] = x->a[i1]*(1-d) + x->a[i1+n]*d;\r
+ s.y.a[i0] = y->a[i1]*(1-d) + y->a[i1+n]*d;\r
+ s.z.a[i0] = z->a[i1]*(1-d) + z->a[i1+n]*d;\r
+ s.a.a[i0] = a->a[i1]*(1-d) + a->a[i1+n]*d;\r
+ }\r
+ if(dir=='z') for(j=0;j<ny;j++) for(i=0;i<nx;i++)\r
+ {\r
+ i0 = i+nx*j; i1 = i+n*(j+m*p);\r
+ s.x.a[i0] = x->a[i1]*(1-d) + x->a[i1+n*m]*d;\r
+ s.y.a[i0] = y->a[i1]*(1-d) + y->a[i1+n*m]*d;\r
+ s.z.a[i0] = z->a[i1]*(1-d) + z->a[i1+n*m]*d;\r
+ s.a.a[i0] = a->a[i1]*(1-d) + a->a[i1+n*m]*d;\r
+ }\r
+ }\r
+ else // x, y, z -- vectors\r
+ {\r
+ if(dir=='x')\r
+ {\r
+ v = x->a[p]*(1-d)+x->a[p+1]*d;\r
+ for(j=0;j<ny;j++) for(i=0;i<nx;i++)\r
+ {\r
+ i0 = i+nx*j; s.x.a[i0] = v; i1 = p+n*(i+m*j);\r
+ s.y.a[i0] = y->a[i]; s.z.a[i0] = z->a[j];\r
+ s.a.a[i0] = a->a[i1]*(1-d) + a->a[i1+1]*d;\r
+ }\r
+ }\r
+ if(dir=='y')\r
+ {\r
+ v = y->a[p]*(1-d)+y->a[p+1]*d;\r
+ for(j=0;j<ny;j++) for(i=0;i<nx;i++)\r
+ {\r
+ i0 = i+nx*j; s.y.a[i0] = v; i1 = i+n*(p+m*j);\r
+ s.x.a[i0] = x->a[i]; s.z.a[i0] = z->a[j];\r
+ s.a.a[i0] = a->a[i1]*(1-d) + a->a[i1+n]*d;\r
+ }\r
+ }\r
+ if(dir=='z')\r
+ {\r
+ v = z->a[p]*(1-d)+z->a[p+1]*d;\r
+ for(j=0;j<ny;j++) for(i=0;i<nx;i++)\r
+ {\r
+ i0 = i+nx*j; s.z.a[i0] = v; i1 = i+n*(j+m*p);\r
+ s.x.a[i0] = x->a[i]; s.y.a[i0] = y->a[j];\r
+ s.a.a[i0] = a->a[i1]*(1-d) + a->a[i1+n*m]*d;\r
+ }\r
+ }\r
+ }\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont3_xyz_val(HMGL gr, HCDT v, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, mreal sVal, const char *opt)\r
+{\r
+ bool both = mgl_isboth(x,y,z,a);\r
+ if(mgl_check_dim3(gr,both,x,y,z,a,0,"Cont3")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Cont3",cgid++);\r
char dir='y';\r
gr->SetPenPal(sch);\r
\r
_mgl_slice s;\r
- mgl_get_slice(s,x,y,z,a,dir,sVal,both);\r
+ const mglData *mx = dynamic_cast<const mglData *>(x);\r
+ const mglData *my = dynamic_cast<const mglData *>(y);\r
+ const mglData *mz = dynamic_cast<const mglData *>(z);\r
+ const mglData *ma = dynamic_cast<const mglData *>(a);\r
+ if(mx&&my&&mz&&ma) mgl_get_slice_md(s,mx,my,mz,ma,dir,sVal,both);\r
+ else mgl_get_slice(s,x,y,z,a,dir,sVal,both);\r
for(long i=0;i<v->GetNx();i++)\r
{\r
- float v0 = v->v(i);\r
+ mreal v0 = v->v(i);\r
mgl_cont_gen(gr,v0,&s.a,&s.x,&s.y,&s.z,gr->GetC(ss,v0),text,0);\r
}\r
gr->EndGroup();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_cont3_val(HMGL gr, HCDT v, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_cont3_val(HMGL gr, HCDT v, HCDT a, const char *sch, mreal sVal, const char *opt)\r
{\r
- if(a->GetNx()<2 || a->GetNy()<2 || a->GetNz()<2)\r
- { gr->SetWarn(mglWarnLow,"Cont3"); return; }\r
gr->SaveState(opt);\r
mglData x(a->GetNx()), y(a->GetNy()),z(a->GetNz());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_cont3_xyz_val(gr,v,&x,&y,&z,a,sch,sVal,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_cont3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_cont3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, mreal sVal, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont3"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont3"); gr->LoadState(); return; }\r
mglData v(Num);\r
- for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(Num+1);\r
+ for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_cont3_xyz_val(gr,&v,x,y,z,a,sch,sVal,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_cont3(HMGL gr, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_cont3(HMGL gr, HCDT a, const char *sch, mreal sVal, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont3"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Cont3"); gr->LoadState(); return; }\r
mglData v(Num);\r
- for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(Num+1);\r
+ for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_cont3_val(gr,&v,a,sch,sVal,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_cont3_xyz_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_cont3_xyz_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_cont3_xyz_val(_GR_, _DA_(v), _DA_(x), _DA_(y), _DA_(z), _DA_(a), s, *sVal, o);\r
delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_cont3_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_cont3_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_cont3_val(_GR_, _DA_(v), _DA_(a), s, *sVal, o); delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_cont3_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_cont3_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_cont3_xyz(_GR_, _DA_(x), _DA_(y), _DA_(z), _DA_(a), s, *sVal, o);\r
delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_cont3_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_cont3_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_cont3(_GR_, _DA_(a), s, *sVal, o); delete []o; delete []s; }\r
// Dens3 series\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_dens3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_dens3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, mreal sVal, const char *opt)\r
{\r
- long n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
- if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,"Dens3"); return; }\r
- bool both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim,"Dens3"); return; }\r
+ bool both = mgl_isboth(x,y,z,a);\r
+ if(mgl_check_dim3(gr,both,x,y,z,a,0,"Dens3")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Dens3",cgid++);\r
char dir='y';\r
if(sch && strchr(sch,'z')) dir='z';\r
\r
_mgl_slice s;\r
- mgl_get_slice(s,x,y,z,a,dir,sVal,both);\r
+ const mglData *mx = dynamic_cast<const mglData *>(x);\r
+ const mglData *my = dynamic_cast<const mglData *>(y);\r
+ const mglData *mz = dynamic_cast<const mglData *>(z);\r
+ const mglData *ma = dynamic_cast<const mglData *>(a);\r
+ if(mx&&my&&mz&&ma) mgl_get_slice_md(s,mx,my,mz,ma,dir,sVal,both);\r
+ else mgl_get_slice(s,x,y,z,a,dir,sVal,both);\r
mgl_surfc_xy(gr,&s.x,&s.y,&s.z,&s.a,sch,0);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_dens3(HMGL gr, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_dens3(HMGL gr, HCDT a, const char *sch, mreal sVal, const char *opt)\r
{\r
- if(a->GetNx()<2 || a->GetNy()<2 || a->GetNz()<2)\r
- { gr->SetWarn(mglWarnLow,"Dens3"); return; }\r
gr->SaveState(opt);\r
mglData x(a->GetNx()), y(a->GetNy()),z(a->GetNz());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_dens3_xyz(gr,&x,&y,&z,a,sch,sVal,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_dens3_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_dens3_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_dens3_xyz(_GR_, _DA_(x), _DA_(y), _DA_(z), _DA_(a), s, *sVal, o);\r
delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_dens3_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_dens3_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_dens3(_GR_, _DA_(a), s, *sVal, o); delete []o; delete []s; }\r
// Grid3 series\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_grid3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_grid3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, mreal sVal, const char *opt)\r
{\r
- long n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
- if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,"Grid3"); return; }\r
- bool both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim,"Grid3"); return; }\r
+ bool both = mgl_isboth(x,y,z,a);\r
+ if(mgl_check_dim3(gr,both,x,y,z,a,0,"Grid3")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Grid3",cgid++);\r
char dir='y';\r
if(sch && strchr(sch,'z')) dir='z';\r
\r
_mgl_slice s;\r
- mgl_get_slice(s,x,y,z,a,dir,sVal,both);\r
+ const mglData *mx = dynamic_cast<const mglData *>(x);\r
+ const mglData *my = dynamic_cast<const mglData *>(y);\r
+ const mglData *mz = dynamic_cast<const mglData *>(z);\r
+ const mglData *ma = dynamic_cast<const mglData *>(a);\r
+ if(mx&&my&&mz&&ma) mgl_get_slice_md(s,mx,my,mz,ma,dir,sVal,both);\r
+ else mgl_get_slice(s,x,y,z,a,dir,sVal,both);\r
mgl_mesh_xy(gr,&s.x,&s.y,&s.z,sch,0);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_grid3(HMGL gr, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_grid3(HMGL gr, HCDT a, const char *sch, mreal sVal, const char *opt)\r
{\r
- if(a->GetNx()<2 || a->GetNy()<2 || a->GetNz()<2)\r
- { gr->SetWarn(mglWarnLow,"Grid3"); return; }\r
gr->SaveState(opt);\r
mglData x(a->GetNx()), y(a->GetNy()), z(a->GetNz());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_grid3_xyz(gr,&x,&y,&z,a,sch,sVal,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_grid3_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_grid3_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_grid3_xyz(_GR_, _DA_(x), _DA_(y), _DA_(z), _DA_(a), s, *sVal, o);\r
delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_grid3_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_grid3_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_grid3(_GR_, _DA_(a), s, *sVal, o); delete []o; delete []s; }\r
// ContF3 series\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_contf3_xyz_val(HMGL gr, HCDT v, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_contf3_xyz_val(HMGL gr, HCDT v, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, mreal sVal, const char *opt)\r
{\r
- long n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
- if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,"ContF3"); return; }\r
- bool both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim,"ContF3"); return; }\r
+ bool both = mgl_isboth(x,y,z,a);\r
+ if(mgl_check_dim3(gr,both,x,y,z,a,0,"ContF3")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("ContF3",cgid++);\r
char dir='y';\r
\r
long ss=gr->AddTexture(sch);\r
_mgl_slice s;\r
- mgl_get_slice(s,x,y,z,a,dir,sVal,both);\r
+ const mglData *mx = dynamic_cast<const mglData *>(x);\r
+ const mglData *my = dynamic_cast<const mglData *>(y);\r
+ const mglData *mz = dynamic_cast<const mglData *>(z);\r
+ const mglData *ma = dynamic_cast<const mglData *>(a);\r
+ if(mx&&my&&mz&&ma) mgl_get_slice_md(s,mx,my,mz,ma,dir,sVal,both);\r
+ else mgl_get_slice(s,x,y,z,a,dir,sVal,both);\r
for(long i=0;i<v->GetNx()-1;i++)\r
{\r
- float v0 = v->v(i);\r
+ mreal v0 = v->v(i);\r
mgl_contf_gen(gr,v0,v->v(i+1),&s.a,&s.x,&s.y,&s.z,gr->GetC(ss,v0),0);\r
}\r
gr->EndGroup();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_contf3_val(HMGL gr, HCDT v, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_contf3_val(HMGL gr, HCDT v, HCDT a, const char *sch, mreal sVal, const char *opt)\r
{\r
- if(a->GetNx()<2 || a->GetNy()<2 || a->GetNz()<2)\r
- { gr->SetWarn(mglWarnLow,"ContF3"); return; }\r
gr->SaveState(opt);\r
mglData x(a->GetNx()), y(a->GetNy()),z(a->GetNz());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_contf3_xyz_val(gr,v,&x,&y,&z,a,sch,sVal,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_contf3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_contf3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, mreal sVal, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"ContF3"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"ContF3"); gr->LoadState(); return; }\r
mglData v(Num+2); v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contf3_xyz_val(gr,&v,x,y,z,a,sch,sVal,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_contf3(HMGL gr, HCDT a, const char *sch, float sVal, const char *opt)\r
+void mgl_contf3(HMGL gr, HCDT a, const char *sch, mreal sVal, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?7:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"ContF3"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"ContF3"); gr->LoadState(); return; }\r
mglData v(Num+2); v.Fill(gr->Min.c, gr->Max.c);\r
mgl_contf3_val(gr,&v,a,sch,sVal,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_contf3_xyz_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_contf3_xyz_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_contf3_xyz_val(_GR_, _DA_(v), _DA_(x), _DA_(y), _DA_(z), _DA_(a), s, *sVal, o);\r
delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_contf3_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_contf3_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_contf3_val(_GR_, _DA_(v), _DA_(a), s, *sVal, o);\r
delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_contf3_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_contf3_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_contf3_xyz(_GR_, _DA_(x), _DA_(y), _DA_(z), _DA_(a), s, *sVal, o);\r
delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_contf3_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sVal, const char *opt,int l,int lo)\r
+void mgl_contf3_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sVal, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_contf3(_GR_, _DA_(a), s, *sVal, o);\r
for(long k=0;k<pc;k++) if(nn[k]==i) return k;\r
return -1;\r
}\r
-void mgl_axial_plot(mglBase *gr,long pc, mglPoint *ff, long *nn,char dir,float cc,bool wire)\r
+void mgl_axial_plot(mglBase *gr,long pc, mglPoint *ff, long *nn,char dir,mreal cc,bool wire)\r
{\r
mglPoint a(0,0,1),b,c,p,q1,q2;\r
if(dir=='x') a = mglPoint(1,0,0);\r
b = !a; c = a^b;\r
\r
register long i,j,k;\r
- float fi,si,co;\r
+ mreal fi,si,co;\r
long p1,p2,p3,p4;\r
if(wire) gr->Reserve(pc*82); else gr->Reserve(pc*82);\r
for(i=0;i<pc;i++)\r
}\r
//-----------------------------------------------------------------------------\r
// NOTE! All data MUST have the same size! Only first slice is used!\r
-void mgl_axial_gen(HMGL gr, float val, HCDT a, HCDT x, HCDT y, float c, char dir,long ak,bool wire)\r
+void mgl_axial_gen(HMGL gr, mreal val, HCDT a, HCDT x, HCDT y, mreal c, char dir,long ak,bool wire)\r
{\r
long n=a->GetNx(), m=a->GetNy();\r
if(n<2 || m<2 || x->GetNx()*x->GetNy()!=n*m || y->GetNx()*y->GetNy()!=n*m)\r
{ gr->SetWarn(mglWarnDim,"ContGen"); return; }\r
\r
mglPoint *kk = new mglPoint[2*n*m],*pp = new mglPoint[2*n*m],p;\r
- float d, kx, ky;\r
- register long i,j,k, pc=0;\r
+ mreal d, kx, ky;\r
+ register long i,j,k, pc=0,i0;\r
// Usually number of points is much smaller. So, there is no reservation.\r
// gr->Reserve(2*n*m);\r
\r
- // add intersection point of isoline and Y axis\r
- for(j=0;j<m;j++) for(i=0;i<n-1;i++)\r
+ // add intersection point of isoline and X or Y axis\r
+ const mglData *mx = dynamic_cast<const mglData *>(x);\r
+ const mglData *my = dynamic_cast<const mglData *>(y);\r
+ const mglData *ma = dynamic_cast<const mglData *>(a);\r
+ if(mx&&my&&ma) for(j=0;j<m;j++) for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete []kk; delete []pp; return; }\r
- d = mgl_d(val,a->v(i,j,ak),a->v(i+1,j,ak));\r
+ i0 = i+n*j;\r
+ d = (i<n-1)?mgl_d(val,ma->a[i0+n*m*ak],ma->a[i0+1+n*m*ak]):-1;\r
if(d>=0 && d<1)\r
{\r
- pp[pc] = mglPoint(x->v(i,j)*(1-d)+x->v(i+1,j)*d,\r
- y->v(i,j)*(1-d)+y->v(i+1,j)*d);\r
+ pp[pc] = mglPoint(mx->a[i0]*(1-d)+mx->a[i0+1]*d, my->a[i0]*(1-d)+my->a[i0+1]*d);\r
kk[pc] = mglPoint(i+d,j); pc++;\r
}\r
+ d = (j<m-1)?mgl_d(val,ma->a[i0+n*m*ak],ma->a[i0+n*m*ak+n]):-1;\r
+ if(d>=0 && d<1)\r
+ {\r
+ pp[pc] = mglPoint(mx->a[i0]*(1-d)+mx->a[i0+n]*d, my->a[i0]*(1-d)+my->a[i0+n]*d);\r
+ kk[pc] = mglPoint(i,j+d); pc++;\r
+ }\r
}\r
- // add intersection point of isoline and X axis\r
- for(j=0;j<m-1;j++) for(i=0;i<n;i++)\r
+ else for(j=0;j<m;j++) for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete []kk; delete []pp; return; }\r
- d = mgl_d(val,a->v(i,j,ak),a->v(i,j+1,ak));\r
+ register mreal va=a->v(i,j,ak),vx=x->v(i,j),vy=y->v(i,j);\r
+ d = (i<n-1)?mgl_d(val,va,a->v(i+1,j,ak)):-1;\r
+ if(d>=0 && d<1)\r
+ {\r
+ pp[pc] = mglPoint(vx*(1-d)+x->v(i+1,j)*d, vy*(1-d)+y->v(i+1,j)*d);\r
+ kk[pc] = mglPoint(i+d,j); pc++;\r
+ }\r
+ d = (j<m-1)?mgl_d(val,va,a->v(i,j+1,ak)):-1;\r
if(d>=0 && d<1)\r
{\r
- pp[pc] = mglPoint(x->v(i,j)*(1-d)+x->v(i,j+1)*d,\r
- y->v(i,j)*(1-d)+y->v(i,j+1)*d);\r
+ pp[pc] = mglPoint(vx*(1-d)+x->v(i,j+1)*d, vy*(1-d)+y->v(i,j+1)*d);\r
kk[pc] = mglPoint(i,j+d); pc++;\r
}\r
}\r
void mgl_axial_xy_val(HMGL gr, HCDT v, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Axial"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Axial"); return; }\r
- bool both = x->GetNx()*x->GetNy()==m*n && y->GetNx()*y->GetNy()==m*n;\r
- if(y->GetNx()!=z->GetNy() && !both) { gr->SetWarn(mglWarnDim, "Axial"); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,0,"Axial")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Axial",cgid++);\r
\r
if(sch && strchr(sch,'z')) dir = 'z';\r
\r
mglData xx, yy;\r
- if(!both) // make\r
+ if(x->GetNx()*x->GetNy()!=m*n || y->GetNx()*y->GetNy()!=m*n) // make\r
{\r
- xx.Create(z->GetNx(), z->GetNy());\r
- yy.Create(z->GetNx(), z->GetNy());\r
- for(j=0;j<m;j++) for(i=0;i<n;i++)\r
+ xx.Create(n, m); yy.Create(n, m);\r
+ const mglData *mx = dynamic_cast<const mglData *>(x);\r
+ const mglData *my = dynamic_cast<const mglData *>(y);\r
+ if(mx && my) for(i=0;i<n;i++) for(j=0;j<m;j++)\r
+ { xx.a[i+n*j] = mx->a[i]; yy.a[i+n*j] = my->a[j]; }\r
+ else for(i=0;i<n;i++) for(j=0;j<m;j++)\r
{ xx.a[i+n*j] = x->v(i); yy.a[i+n*j] = y->v(j); }\r
x = &xx; y = &yy;\r
}\r
// x, y -- have the same size z\r
- float v0;\r
+ mreal v0;\r
bool wire = sch && strchr(sch,'#');\r
for(j=0;j<z->GetNz();j++) for(i=0;i<v->GetNx();i++)\r
{\r
//-----------------------------------------------------------------------------\r
void mgl_axial_val(HMGL gr, HCDT v, HCDT a, const char *sch, const char *opt)\r
{\r
- if(a->GetNx()<2 || a->GetNy()<2) { gr->SetWarn(mglWarnLow,"Axial"); return; }\r
+ register long n=a->GetNx(), m=a->GetNy();\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Axial"); return; }\r
gr->SaveState(opt);\r
- mglData x(a->GetNx(),a->GetNy()), y(a->GetNx(),a->GetNy());\r
+ mglData x(n, m), y(n, m);\r
if(gr->Max.x*gr->Min.x>=0) x.Fill(gr->Min.x,gr->Max.x,'x');\r
else x.Fill(0,gr->Max.x,'x');\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_axial_xy_val(gr,v,&x,&y,a,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_axial_xy(HMGL gr, HCDT x, HCDT y, HCDT a, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?3:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Axial"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Axial"); gr->LoadState(); return; }\r
mglData v(Num);\r
- for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(Num+1);\r
+ for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_axial_xy_val(gr,&v,x,y,a,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_axial(HMGL gr, HCDT a, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long Num = mgl_isnan(r)?3:long(r+0.5);\r
- if(Num<1) { gr->SetWarn(mglWarnCnt,"Axial"); return; }\r
+ if(Num<1) { gr->SetWarn(mglWarnCnt,"Axial"); gr->LoadState(); return; }\r
mglData v(Num);\r
- for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(Num+1);\r
+ for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
mgl_axial_val(gr,&v,a,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_axial_xy_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
if(sch && strchr(sch,'x')) dir = 'x';\r
if(sch && strchr(sch,'z')) dir = 'z';\r
\r
- float c = gr->GetC(ss,gr->Min.c);\r
+ mreal c = gr->GetC(ss,gr->Min.c);\r
+ const mglData *mr = dynamic_cast<const mglData *>(r);\r
+ const mglData *mz = dynamic_cast<const mglData *>(z);\r
for(j=0;j<r->GetNy();j++)\r
{\r
- for(i=0;i<n;i++)\r
+ if(mr&&mz) for(i=0;i<n;i++)\r
+ {\r
+ nn[i] = i<n-1 ? i+1 : -1;\r
+ pp[i] = mglPoint(mr->a[i+n*j], mz->a[i+n*j]);\r
+ }\r
+ else for(i=0;i<n;i++)\r
{\r
nn[i] = i<n-1 ? i+1 : -1;\r
pp[i] = mglPoint(r->v(i,j), z->v(i,j));\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdlib.h>\r
#include <float.h>\r
#include "mgl2/other.h"\r
#include "mgl2/data.h"\r
void mgl_triplot_xyzc(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, const char *opt)\r
{\r
long n = x->GetNx(), m = nums->GetNy();\r
- if(y->GetNx()!=n || z->GetNx()!=n || nums->GetNx()<3) { gr->SetWarn(mglWarnLow,"TriPlot"); return; }\r
- if(a->GetNx()!=m && a->GetNx()!=n) { gr->SetWarn(mglWarnLow,"TriPlot"); return; }\r
+ if(mgl_check_trig(gr,nums,x,y,z,a,"TriPlot")) return;\r
+\r
long ss=gr->AddTexture(sch);\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("TriPlot",cgid++);\r
k2 = long(nums->v(1,i)+0.5);\r
k3 = long(nums->v(2,i)+0.5);\r
if(!wire)\r
+ {\r
q = mglPoint(x->v(k2)-x->v(k1), y->v(k2)-y->v(k1), z->v(k2)-z->v(k1)) ^\r
mglPoint(x->v(k3)-x->v(k1), y->v(k3)-y->v(k1), z->v(k3)-z->v(k1));\r
- // try be sure that in the same direction ... but it is so slow :(\r
- if(pp[k1]*q<0) q*=-1; pp[k1] += q;\r
- if(pp[k2]*q<0) q*=-1; pp[k2] += q;\r
- if(pp[k3]*q<0) q*=-1; pp[k3] += q;\r
+ q.Normalize();\r
+ // try be sure that in the same direction ... \r
+ if(q.z<0) q *= -1;\r
+ pp[k1] += q; pp[k2] += q; pp[k3] += q;\r
+ }\r
}\r
for(i=0;i<n;i++) // add points\r
{\r
void mgl_triplot_xy(HMGL gr, HCDT nums, HCDT x, HCDT y, const char *sch, const char *opt)\r
{\r
gr->SaveState(opt);\r
- mglData z(x->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
+ mglData z(x->GetNx());\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_triplot_xyzc(gr,nums,x,y,&z,&z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_triplot_xyzc_(uintptr_t *gr, uintptr_t *nums, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *c, const char *sch, const char *opt,int l,int lo)\r
void mgl_quadplot_xyzc(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, const char *opt)\r
{\r
long n = x->GetNx(), m = nums->GetNy();\r
- if(y->GetNx()!=n || z->GetNx()!=n || nums->GetNx()<4) { gr->SetWarn(mglWarnLow,"QuadPlot"); return; }\r
- if(a->GetNx()!=m && a->GetNx()!=n) { gr->SetWarn(mglWarnLow,"QuadPlot"); return; }\r
+ if(mgl_check_trig(gr,nums,x,y,z,a,"QuadPlot",4)) return;\r
+\r
long ss=gr->AddTexture(sch);\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("QuadPlot",cgid++);\r
if(wire) pp[k1]=pp[k2]=pp[k3]=pp[k4]=mglPoint(NAN,NAN);\r
else\r
{\r
- q = (p2-p1) ^ (p3-p1); if(pp[k1]*q<0) q*=-1; pp[k1] += q;\r
- q = (p2-p4) ^ (p3-p4); if(pp[k2]*q<0) q*=-1; pp[k2] += q;\r
- q = (p1-p2) ^ (p4-p2); if(pp[k3]*q<0) q*=-1; pp[k3] += q;\r
- q = (p1-p4) ^ (p4-p3); if(pp[k4]*q<0) q*=-1; pp[k4] += q;\r
+ q = (p2-p1) ^ (p3-p1); if(q.z<0) q*=-1; pp[k1] += q;\r
+ q = (p2-p4) ^ (p3-p4); if(q.z<0) q*=-1; pp[k2] += q;\r
+ q = (p1-p2) ^ (p4-p2); if(q.z<0) q*=-1; pp[k3] += q;\r
+ q = (p1-p4) ^ (p4-p3); if(q.z<0) q*=-1; pp[k4] += q;\r
}\r
}\r
for(i=0;i<n;i++) // add points\r
{\r
if(gr->Stop) { delete []kk; delete []pp; return; }\r
- q = mglPoint(x->v(i), y->v(i), z->v(i));\r
- kk[i] = gr->AddPnt(q,gr->GetC(ss,a->v(i)),pp[i]);\r
+ kk[i] = gr->AddPnt(mglPoint(x->v(i), y->v(i), z->v(i)),gr->GetC(ss,a->v(i)), pp[i]);\r
}\r
for(i=0;i<m;i++) // draw quads\r
{\r
gr->SaveState(opt);\r
mglData z(x->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_quadplot_xyzc(gr,nums,x,y,&z,&z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_quadplot_xyzc_(uintptr_t *gr, uintptr_t *nums, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *c, const char *sch, const char *opt,int l,int lo)\r
// TriCont series\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_tricont_line(HMGL gr, float val, long k1, long k2, long k3, HCDT x, HCDT y, HCDT z, HCDT a, bool zVal,float c)\r
+void mgl_tricont_line(HMGL gr, mreal val, long k1, long k2, long k3, HCDT x, HCDT y, HCDT z, HCDT a, bool zVal,mreal c)\r
{\r
- float d1,d2;\r
+ mreal d1,d2;\r
mglPoint p1,p2,n;\r
d1 = mgl_d(val,a->v(k1),a->v(k2));\r
d2 = mgl_d(val,a->v(k1),a->v(k3));\r
void mgl_tricont_xyzcv(HMGL gr, HCDT v, HCDT nums, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, const char *opt)\r
{\r
long n = x->GetNx(), m = nums->GetNy();\r
- if(y->GetNx()!=n || z->GetNx()!=n || nums->GetNx()<3) { gr->SetWarn(mglWarnLow,"TriCont"); return; }\r
- if(a->GetNx()!=m && a->GetNx()!=n) { gr->SetWarn(mglWarnLow,"TriCont"); return; }\r
+ if(mgl_check_trig(gr,nums,x,y,z,a,"TriCont")) return;\r
+\r
long ss=gr->AddTexture(sch);\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("TriCont",cgid++);\r
- float val;\r
+ mreal val;\r
register long i,k;\r
long k1,k2,k3;\r
bool zVal = (sch && strchr(sch,'_'));\r
k2 = long(nums->v(1,i)+0.1); if(k2<0 || k2>=n) continue;\r
k3 = long(nums->v(2,i)+0.1); if(k3<0 || k3>=n) continue;\r
val = v->v(k);\r
- float c = gr->GetC(ss,val);\r
+ mreal c = gr->GetC(ss,val);\r
mgl_tricont_line(gr,val, k1,k2,k3,x,y,z,a,zVal,c);\r
mgl_tricont_line(gr,val, k2,k1,k3,x,y,z,a,zVal,c);\r
mgl_tricont_line(gr,val, k3,k2,k1,x,y,z,a,zVal,c);\r
//-----------------------------------------------------------------------------\r
void mgl_tricont_xyzc(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long n = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);\r
mglData v(n);\r
- for(long i=0;i<n;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(n+1);\r
+ for(long i=0;i<n;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(n+1);\r
mgl_tricont_xyzcv(gr,&v,nums,x,y,z,a,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_tricont_xyc(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
// mglTriangulation\r
//\r
//-----------------------------------------------------------------------------\r
-long mgl_crust(long n,mglPoint *pp,long **nn,float ff);\r
-HMDT mgl_triangulation_3d(HCDT x, HCDT y, HCDT z, float er)\r
-{\r
+long mgl_crust(long n,mglPoint *pp,long **nn,mreal ff);\r
+HMDT mgl_triangulation_3d(HCDT x, HCDT y, HCDT z)\r
+{ // TODO: should be used s-hull or q-hull\r
mglData *nums=new mglData;\r
long n = x->GetNx(), m;\r
if(y->GetNx()!=n || z->GetNx()!=n) return nums;\r
mglPoint *pp = new mglPoint[n];\r
long *nn=0;\r
for(i=0;i<n;i++) pp[i] = mglPoint(x->v(i), y->v(i), z->v(i));\r
- m = mgl_crust(n,pp,&nn,er);\r
+ m = mgl_crust(n,pp,&nn,0);\r
\r
if(m>0)\r
{\r
delete []pp; free(nn); return nums;\r
}\r
//-----------------------------------------------------------------------------\r
-HMDT mgl_triangulation_2d(HCDT x, HCDT y, float er)\r
+#include "s_hull/s_hull_pro.h"\r
+HMDT mgl_triangulation_2d(HCDT x, HCDT y)\r
{\r
- mglData z(x->GetNx());\r
- return mgl_triangulation_3d(x,y,&z,er);\r
+ mglData *nums=new mglData;\r
+ register long n = x->GetNx(), m,i;\r
+ if(y->GetNx()!=n) return nums;\r
+ // use s-hull here\r
+ std::vector<Shx> pts;\r
+ Shx pt;\r
+\r
+ for(i=0;i<n;i++)\r
+ {\r
+ pt.r = x->v(i); pt.c = y->v(i);\r
+ pt.id = i; pts.push_back(pt);\r
+ }\r
+ std::vector<Triad> triads;\r
+ s_hull_pro(pts, triads);\r
+ m = triads.size();\r
+ nums->Create(3,m);\r
+ for(i=0;i<m;i++)\r
+ {\r
+ nums->a[3*i] = triads[i].a;\r
+ nums->a[3*i+1] = triads[i].b;\r
+ nums->a[3*i+2] = triads[i].c;\r
+ }\r
+ return nums;\r
}\r
//-----------------------------------------------------------------------------\r
-uintptr_t mgl_triangulation_3d_(uintptr_t *x, uintptr_t *y, uintptr_t *z, float *er)\r
-{ return uintptr_t(mgl_triangulation_3d(_DA_(x),_DA_(y),_DA_(z),*er)); }\r
-uintptr_t mgl_triangulation_2d_(uintptr_t *x, uintptr_t *y, float *er)\r
-{ return uintptr_t(mgl_triangulation_2d(_DA_(x),_DA_(y),*er)); }\r
+uintptr_t mgl_triangulation_3d_(uintptr_t *x, uintptr_t *y, uintptr_t *z)\r
+{ return uintptr_t(mgl_triangulation_3d(_DA_(x),_DA_(y),_DA_(z))); }\r
+uintptr_t mgl_triangulation_2d_(uintptr_t *x, uintptr_t *y)\r
+{ return uintptr_t(mgl_triangulation_2d(_DA_(x),_DA_(y))); }\r
+//-----------------------------------------------------------------------------\r
+//\r
+// DataGrid\r
+//\r
+//-----------------------------------------------------------------------------\r
+void *mgl_grid_t(void *par)\r
+{\r
+ mglThreadD *t=(mglThreadD *)par;\r
+ long nx=t->p[0],ny=t->p[1];\r
+ register long i0, k1,k2,k3;\r
+ mreal *b=t->a;\r
+ const mreal *x=t->b, *y=t->c, *d=t->d, *z=t->e;\r
+ for(i0=t->id;i0<t->n;i0+=mglNumThr)\r
+ {\r
+ k1 = long(d[3*i0]); k2 = long(d[3*i0+1]); k3 = long(d[3*i0+2]);\r
+ mreal dxu,dxv,dyu,dyv;\r
+ mglPoint d1=mglPoint(x[k2]-x[k1],y[k2]-y[k1],z[k2]-z[k1]), d2=mglPoint(x[k3]-x[k1],y[k3]-y[k1],z[k3]-z[k1]), p;\r
+\r
+ dxu = d2.x*d1.y - d1.x*d2.y;\r
+ if(fabs(dxu)<1e-5) continue; // points lies on the same line\r
+ dyv =-d1.x/dxu; dxv = d1.y/dxu;\r
+ dyu = d2.x/dxu; dxu =-d2.y/dxu;\r
+\r
+ long x1,y1,x2,y2;\r
+ x1 = long(fmin(fmin(x[k1],x[k2]),x[k3])); // bounding box\r
+ y1 = long(fmin(fmin(y[k1],y[k2]),y[k3]));\r
+ x2 = long(fmax(fmax(x[k1],x[k2]),x[k3]));\r
+ y2 = long(fmax(fmax(y[k1],y[k2]),y[k3]));\r
+ x1 = x1>0 ? x1:0; x2 = x2<nx ? x2:nx-1;\r
+ y1 = y1>0 ? y1:0; y2 = y2<ny ? y2:ny-1;\r
+ if((x1>x2) | (y1>y2)) continue;\r
+\r
+ register mreal u,v,xx,yy, x0 = x[k1], y0 = y[k1];\r
+ register long i,j;\r
+ for(i=x1;i<=x2;i++) for(j=y1;j<=y2;j++)\r
+ {\r
+ xx = (i-x0); yy = (j-y0);\r
+ u = dxu*xx+dyu*yy; v = dxv*xx+dyv*yy;\r
+ if((u<0) | (v<0) | (u+v>1)) continue;\r
+ b[i+nx*j] = z[k1] + d1.z*u + d2.z*v;\r
+ }\r
+ }\r
+ return 0;\r
+}\r
+void mgl_data_grid(HMGL gr, HMDT d, HCDT xdat, HCDT ydat, HCDT zdat, const char *opt)\r
+{ // NOTE: only for mglData\r
+ const mglData *x = dynamic_cast<const mglData *>(xdat);\r
+ const mglData *y = dynamic_cast<const mglData *>(ydat);\r
+ const mglData *z = dynamic_cast<const mglData *>(zdat);\r
+ if(!x | !y | !z) return;\r
+ long n=x->nx;\r
+ if((n<3) | (y->nx!=n) | (z->nx!=n)) return;\r
+\r
+ gr->SaveState(opt);\r
+ mglData *nums = mgl_triangulation_2d(x,y);\r
+ if(nums->nx<3) { delete nums; return; }\r
+ long nn = nums->ny, par[3]={d->nx,d->ny,d->nz};\r
+ mreal xx[4]={gr->Min.x,0, gr->Min.y,0};\r
+ if(d->nx>1) xx[1] = (d->nx-1.)/(gr->Max.x-gr->Min.x);\r
+ if(d->ny>1) xx[3] = (d->ny-1.)/(gr->Max.y-gr->Min.y);\r
+\r
+ register long i;\r
+ mreal *xc=new mreal[n], *yc=new mreal[n];\r
+ for(i=0;i<n;i++) { xc[i]=xx[1]*(x->a[i]-xx[0]); yc[i]=xx[3]*(y->a[i]-xx[2]); }\r
+ for(long i=0;i<d->nx*d->ny*d->nz;i++) d->a[i] = NAN;\r
+ \r
+ mglStartThread(mgl_grid_t,0,nn,d->a,xc,yc,par,0,nums->a,z->a);\r
+ gr->LoadState(); delete nums; delete []xc; delete []yc;\r
+}\r
+void mgl_data_grid_(uintptr_t *gr, uintptr_t *d, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *opt,int lo)\r
+{ char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
+ mgl_data_grid(_GR_,_DT_,_DA_(x),_DA_(y),_DA_(z),o); delete []o; }\r
//-----------------------------------------------------------------------------\r
//\r
// Crust series\r
{\r
if(y->GetNx()!=x->GetNx() || z->GetNx()!=x->GetNx())\r
{ gr->SetWarn(mglWarnDim,"Crust"); return; }\r
- HMDT nums = mgl_triangulation_3d(x, y, z, 0);\r
+ HMDT nums = mgl_triangulation_3d(x, y, z);\r
mgl_triplot_xyzc(gr,nums,x,y,z,z,sch,opt);\r
mgl_delete_data(nums);\r
}\r
long mgl_get_next(long k1,long n,long *,long *set,mglPoint *qq)\r
{\r
long i,j=-1;\r
- float r,rm=FLT_MAX;\r
+ mreal r,rm=FLT_MAX;\r
for(i=0;i<n;i++)\r
{\r
if(i==k1 || set[i]>0) continue;\r
return j;\r
}\r
//-----------------------------------------------------------------------------\r
-long mgl_crust(long n,mglPoint *pp,long **nn,float ff)\r
+long mgl_crust(long n,mglPoint *pp,long **nn,mreal ff)\r
{ // TODO: update to normal algorithm\r
register long i,j;\r
- register float r,rm,rs;\r
+ register mreal r,rm,rs;\r
if(ff<=0) ff=2;\r
for(rs=0,i=0;i<n;i++)\r
{\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdlib.h>\r
-#include <string.h>\r
-#include <unistd.h>\r
#include "mgl2/data.h"\r
#include "mgl2/eval.h"\r
\r
#endif\r
//-----------------------------------------------------------------------------\r
void mglStartThread(void *(*func)(void *), void (*post)(mglThreadD *,mreal *), long n, mreal *a,\r
- const mreal *b, const mreal *c, const long *p, void *v, const mreal *d, const mreal *e, char *s)\r
+ const mreal *b, const mreal *c, const long *p, void *v, const mreal *d, const mreal *e, const char *s)\r
{\r
if(!func) return;\r
#if MGL_HAVE_PTHREAD\r
}\r
return 0;\r
}\r
-void mgl_data_smooth(HMDT d, const char *dirs, float delta)\r
+void mgl_data_smooth(HMDT d, const char *dirs, mreal delta)\r
{\r
long Type = SMOOTH_QUAD_5;\r
if(strchr(dirs,'0') || strchr(dirs,'1')) return;\r
}\r
delete []b;\r
}\r
-void mgl_data_smooth_(uintptr_t *d, const char *dir, float *delta,int l)\r
+void mgl_data_smooth_(uintptr_t *d, const char *dir, mreal *delta,int l)\r
{ char *s=new char[l+1]; memcpy(s,dir,l); s[l]=0;\r
mgl_data_smooth(_DT_,s,*delta); delete []s; }\r
//-----------------------------------------------------------------------------\r
{ char *s=new char[l+1]; memcpy(s,dir,l); s[l]=0;\r
mgl_data_mirror(_DT_,s); delete []s; }\r
//-----------------------------------------------------------------------------\r
-float mgl_data_linear(HCDT d, float x,float y,float z)\r
+mreal mgl_data_linear(HCDT d, mreal x,mreal y,mreal z)\r
{\r
long kx=long(x), ky=long(y), kz=long(z);\r
mreal b0,b1;\r
return b0 + z*(b1-b0);\r
}\r
//-----------------------------------------------------------------------------\r
-float mgl_data_spline(HCDT d, float x,float y,float z)\r
+mreal mgl_data_spline(HCDT d, mreal x,mreal y,mreal z)\r
{\r
const mglData *dd=dynamic_cast<const mglData *>(d);\r
if(!d) return 0; // NOTE: don't support general arrays\r
_p[3]=s[0]+s[1]+2*(f[0]-f[1]);\r
}\r
//-----------------------------------------------------------------------------\r
-float mgl_data_spline_(uintptr_t *d, float *x,float *y,float *z)\r
+mreal mgl_data_spline_(uintptr_t *d, mreal *x,mreal *y,mreal *z)\r
{ return mgl_data_spline(_DA_(d),*x,*y,*z); }\r
-float mgl_data_linear_(uintptr_t *d, float *x,float *y,float *z)\r
+mreal mgl_data_linear_(uintptr_t *d, mreal *x,mreal *y,mreal *z)\r
{ return mgl_data_linear(_DA_(d),*x,*y,*z); }\r
//-----------------------------------------------------------------------------\r
void mgl_data_crop(HMDT d, long n1, long n2, char dir)\r
void mgl_data_crop_(uintptr_t *d, int *n1, int *n2, const char *dir,int)\r
{ mgl_data_crop(_DT_,*n1,*n2,*dir); }\r
//-----------------------------------------------------------------------------\r
-float mgl_data_last(HCDT d, const char *cond, long *i, long *j, long *k)\r
+mreal mgl_data_last(HCDT d, const char *cond, long *i, long *j, long *k)\r
{\r
long nx=d->GetNx(),ny=d->GetNy(),nz=d->GetNz();\r
if(!cond) cond = "u";\r
*i = i0%nx; *j = (i0/nx)%ny; *k = i0/(nx*ny);\r
return i0>=0 ? d->vthr(i0) : NAN; // NOTE: Return NAN if false\r
}\r
-float mgl_data_last_(uintptr_t *d, const char *cond, int *i, int *j, int *k, int l)\r
+mreal mgl_data_last_(uintptr_t *d, const char *cond, int *i, int *j, int *k, int l)\r
{ long ii,jj,kk; char *s=new char[l+1]; memcpy(s,cond,l); s[l]=0;\r
- float res = mgl_data_last(_DT_,s,&ii,&jj,&kk); *i=ii; *j=jj; *k=kk;\r
+ mreal res = mgl_data_last(_DT_,s,&ii,&jj,&kk); *i=ii; *j=jj; *k=kk;\r
delete []s; return res; }\r
//-----------------------------------------------------------------------------\r
-float mgl_data_first(HCDT d, const char *cond, long *i, long *j, long *k)\r
+mreal mgl_data_first(HCDT d, const char *cond, long *i, long *j, long *k)\r
{\r
long nx=d->GetNx(),ny=d->GetNy(),nz=d->GetNz();\r
if(!cond) cond = "u";\r
*i = i0%nx; *j = (i0/nx)%ny; *k = i0/(nx*ny);\r
return i0<nx*ny*nz ? d->vthr(i0) : NAN; // NOTE: Return NAN if false\r
}\r
-float mgl_data_first_(uintptr_t *d, const char *cond, int *i, int *j, int *k, int l)\r
+mreal mgl_data_first_(uintptr_t *d, const char *cond, int *i, int *j, int *k, int l)\r
{ long ii,jj,kk; char *s=new char[l+1]; memcpy(s,cond,l); s[l]=0;\r
- float res = mgl_data_first(_DT_,s,&ii,&jj,&kk); *i=ii; *j=jj; *k=kk;\r
+ mreal res = mgl_data_first(_DT_,s,&ii,&jj,&kk); *i=ii; *j=jj; *k=kk;\r
delete []s; return res; }\r
//-----------------------------------------------------------------------------\r
long mgl_data_find(HCDT d, const char *cond, char dir, long i, long j, long k)\r
{ char *s=new char[l+1]; memcpy(s,cond,l); s[l]=0;\r
int res = mgl_data_find_any(_DT_,s); delete []s; return res; }\r
//-----------------------------------------------------------------------------\r
-float mgl_data_momentum_val(HCDT dd, char dir, mreal *x, mreal *w, mreal *s, mreal *k)\r
+mreal mgl_data_momentum_val(HCDT dd, char dir, mreal *x, mreal *w, mreal *s, mreal *k)\r
{\r
long nx=dd->GetNx(),ny=dd->GetNy(),nz=dd->GetNz();\r
mreal i0=0,i1=0,i2=0,i3=0,i4=0,d,t,v;\r
register long i;\r
- switch(dir)\r
+ const mglData *md = dynamic_cast<const mglData *>(dd);\r
+ if(dd) switch(dir)\r
{\r
- case 'x':\r
- for(i=0;i<nx*ny*nz;i++)\r
- {\r
- d = i%nx; t = d*d;\r
- v = dd->vthr(i);i0+= v;\r
- i1+= v*d; i2+= v*t;\r
- i3+= v*d*t; i4+= v*t*t;\r
- }\r
- break;\r
- case 'y':\r
- for(i=0;i<nx*ny*nz;i++)\r
- {\r
- d = (i/nx)%ny; t = d*d;\r
- v = dd->vthr(i);i0+= v;\r
- i1+= v*d; i2+= v*t;\r
- i3+= v*d*t; i4+= v*t*t;\r
- }\r
- break;\r
- case 'z':\r
- for(i=0;i<nx*ny*nz;i++)\r
- {\r
- d = i/(nx*ny); t = d*d;\r
- v = dd->vthr(i);i0+= v;\r
- i1+= v*d; i2+= v*t;\r
- i3+= v*d*t; i4+= v*t*t;\r
- }\r
- break;\r
- default: // "self-dispersion"\r
- i0 = nx*ny*nz;\r
- for(i=0;i<nx*ny*nz;i++)\r
- {\r
- v=dd->vthr(i); t = v*v;\r
- i1+= v; i2+= t;\r
- i3+= v*t; i4+= t*t;\r
- }\r
+ case 'x':\r
+ for(i=0;i<nx*ny*nz;i++)\r
+ {\r
+ d = i%nx; t = d*d;\r
+ v = md->a[i];i0+= v;\r
+ i1+= v*d; i2+= v*t;\r
+ i3+= v*d*t; i4+= v*t*t;\r
+ }\r
+ break;\r
+ case 'y':\r
+ for(i=0;i<nx*ny*nz;i++)\r
+ {\r
+ d = (i/nx)%ny; t = d*d;\r
+ v = md->a[i];i0+= v;\r
+ i1+= v*d; i2+= v*t;\r
+ i3+= v*d*t; i4+= v*t*t;\r
+ }\r
+ break;\r
+ case 'z':\r
+ for(i=0;i<nx*ny*nz;i++)\r
+ {\r
+ d = i/(nx*ny); t = d*d;\r
+ v = md->a[i];i0+= v;\r
+ i1+= v*d; i2+= v*t;\r
+ i3+= v*d*t; i4+= v*t*t;\r
+ }\r
+ break;\r
+ default: // "self-dispersion"\r
+ i0 = nx*ny*nz;\r
+ for(i=0;i<nx*ny*nz;i++)\r
+ {\r
+ v=md->a[i]; t = v*v;\r
+ i1+= v; i2+= t;\r
+ i3+= v*t; i4+= t*t;\r
+ }\r
+ }\r
+ else switch(dir)\r
+ {\r
+ case 'x':\r
+ for(i=0;i<nx*ny*nz;i++)\r
+ {\r
+ d = i%nx; t = d*d;\r
+ v = dd->vthr(i);i0+= v;\r
+ i1+= v*d; i2+= v*t;\r
+ i3+= v*d*t; i4+= v*t*t;\r
+ }\r
+ break;\r
+ case 'y':\r
+ for(i=0;i<nx*ny*nz;i++)\r
+ {\r
+ d = (i/nx)%ny; t = d*d;\r
+ v = dd->vthr(i);i0+= v;\r
+ i1+= v*d; i2+= v*t;\r
+ i3+= v*d*t; i4+= v*t*t;\r
+ }\r
+ break;\r
+ case 'z':\r
+ for(i=0;i<nx*ny*nz;i++)\r
+ {\r
+ d = i/(nx*ny); t = d*d;\r
+ v = dd->vthr(i);i0+= v;\r
+ i1+= v*d; i2+= v*t;\r
+ i3+= v*d*t; i4+= v*t*t;\r
+ }\r
+ break;\r
+ default: // "self-dispersion"\r
+ i0 = nx*ny*nz;\r
+ for(i=0;i<nx*ny*nz;i++)\r
+ {\r
+ v=dd->vthr(i); t = v*v;\r
+ i1+= v; i2+= t;\r
+ i3+= v*t; i4+= t*t;\r
+ }\r
}\r
if(i0==0) return 0; d=i1/i0;\r
if(x) *x=d;\r
if(k) *k=i4/(i0*3);\r
return i0;\r
}\r
-float mgl_data_momentum_val_(uintptr_t *d, char *dir, float *m, float *w, float *s, float *k,int)\r
+mreal mgl_data_momentum_val_(uintptr_t *d, char *dir, mreal *m, mreal *w, mreal *s, mreal *k,int)\r
{ mreal mm,ww,ss,kk,aa;\r
aa = mgl_data_momentum_val(_DT_,*dir,&mm,&ww,&ss,&kk);\r
*m=mm; *w=ww; *s=ss; *k=kk; return aa; }\r
//-----------------------------------------------------------------------------\r
-void mgl_data_norm_slice(HMDT d, float v1,float v2,char dir,long keep_en,long sym)\r
+void mgl_data_norm_slice(HMDT d, mreal v1,mreal v2,char dir,long keep_en,long sym)\r
{\r
long nx=d->nx, ny=d->ny, nz=d->nz;\r
mreal *a=d->a;\r
}\r
memcpy(d->a, b.a, nx*ny*nz*sizeof(mreal));\r
}\r
-void mgl_data_norm_slice_(uintptr_t *d, float *v1,float *v2,char *dir,int *keep_en,int *sym,int )\r
+void mgl_data_norm_slice_(uintptr_t *d, mreal *v1,mreal *v2,char *dir,int *keep_en,int *sym,int )\r
{ mgl_data_norm_slice(_DT_,*v1,*v2,*dir,*keep_en,*sym); }\r
//-----------------------------------------------------------------------------\r
const char *mgl_data_info(HCDT d) // NOTE: Not thread safe function!\r
for(i=t->id;i<nn;i+=mglNumThr) mgl_omod(t->a+i*nx, t->b[0], nx, 1);\r
return 0;\r
}\r
-void mgl_data_sew(HMDT d, const char *dirs, float delta)\r
+void mgl_data_sew(HMDT d, const char *dirs, mreal delta)\r
{\r
long nx=d->nx, ny=d->ny, nz=d->nz;\r
long p[3]={nx,ny,nz};\r
if(strchr(dirs,'y') && ny>1) mglStartThread(mgl_sew_y,0,nz*nx,d->a,&da,0,p);\r
if(strchr(dirs,'z') && nz>1) mglStartThread(mgl_sew_z,0,nx*ny,d->a,&da,0,p);\r
}\r
-void mgl_data_sew_(uintptr_t *d, const char *dirs, float *da, int l)\r
+void mgl_data_sew_(uintptr_t *d, const char *dirs, mreal *da, int l)\r
{ char *s=new char[l+1]; memcpy(s,dirs,l); s[l]=0;\r
mgl_data_sew(_DT_,s,*da); delete []s; }\r
//-----------------------------------------------------------------------------\r
{\r
register long nx=d->nx, ny=d->ny, nz=d->nz;\r
if(xx>=nx || yy>=ny || zz>=nz) return;\r
+ const mglData *mv = dynamic_cast<const mglData *>(v);\r
mreal *a=d->a, vv=v->v(0);\r
+ const mreal *b = mv?mv->a:0;\r
long vx=v->GetNx(), vy=v->GetNy(), vz=v->GetNz();\r
register long i,j,k;\r
if(xx<0 && yy<0 && zz<0) // whole array\r
{\r
if(vx>=nx && vy>=ny && vz>=nz)\r
for(k=0;k<nz;k++) for(j=0;j<ny;j++) for(i=0;i<nx;i++)\r
- a[i+nx*(j+k*ny)] = v->v(i,j,k);\r
+ a[i+nx*(j+k*ny)] = b?b[i+vx*(j+k*vy)]:v->v(i,j,k);\r
else if(vx>=nx && vy>=ny)\r
for(k=0;k<nz;k++) for(j=0;j<ny;j++) for(i=0;i<nx;i++)\r
- a[i+nx*(j+k*ny)] = v->v(i,j);\r
+ a[i+nx*(j+k*ny)] = b?b[i+vx*j]:v->v(i,j);\r
else if(vx>=nx) for(k=0;k<ny*nz;k++) for(i=0;i<nx;i++)\r
- a[i+nx*k] = v->v(i);\r
+ a[i+nx*k] = b?b[i]:v->v(i);\r
else for(i=0;i<nx*ny*nz;i++) a[i] = vv;\r
}\r
else if(xx<0 && yy<0) // 2d\r
{\r
if(vx>=nx && vy>=ny) for(j=0;j<ny;j++) for(i=0;i<nx;i++)\r
- a[i+nx*(j+zz*ny)] = v->v(i,j);\r
+ a[i+nx*(j+zz*ny)] = b?b[i+vx*j]:v->v(i,j);\r
else if(vx>=nx) for(j=0;j<ny;j++) for(i=0;i<nx;i++)\r
- a[i+nx*(j+zz*ny)] = v->v(i);\r
+ a[i+nx*(j+zz*ny)] = b?b[i]:v->v(i);\r
else for(i=0;i<nx*ny;i++) a[i+nx*ny*zz] = vv;\r
}\r
else if(yy<0 && zz<0) // 2d\r
{\r
if(vx>=ny && vy>=nz) for(j=0;j<nz;j++) for(i=0;i<ny;i++)\r
- a[xx+nx*(i+j*ny)] = v->v(i,j);\r
+ a[xx+nx*(i+j*ny)] = b?b[i+vx*j]:v->v(i,j);\r
else if(vx>=ny) for(j=0;j<nz;j++) for(i=0;i<ny;i++)\r
- a[xx+nx*(i+j*ny)] = v->v(i);\r
+ a[xx+nx*(i+j*ny)] = b?b[i]:v->v(i);\r
else for(i=0;i<ny*nz;i++) a[xx+nx*i] = vv;\r
}\r
else if(xx<0 && zz<0) // 2d\r
{\r
if(vx>=nx && vy>=nz) for(j=0;j<nz;j++) for(i=0;i<nx;i++)\r
- a[i+nx*(yy+j*ny)] = v->v(i,j);\r
+ a[i+nx*(yy+j*ny)] = b?b[i+vx*j]:v->v(i,j);\r
else if(vx>=nx) for(j=0;j<nz;j++) for(i=0;i<nx;i++)\r
- a[i+nx*(yy+j*ny)] = v->v(i);\r
+ a[i+nx*(yy+j*ny)] = b?b[i]:v->v(i);\r
else for(j=0;j<nz;j++) for(i=0;i<nx;i++)\r
a[i+nx*(yy+j*ny)] = vv;\r
}\r
else if(xx<0)\r
{\r
- if(vx>=nx) for(i=0;i<nx;i++) a[i+nx*(yy+zz*ny)] = v->v(i);\r
+ if(vx>=nx) for(i=0;i<nx;i++) a[i+nx*(yy+zz*ny)] = b?b[i]:v->v(i);\r
else for(i=0;i<nx;i++) a[i+nx*(yy+zz*ny)] = vv;\r
}\r
else if(yy<0)\r
{\r
- if(vx>=ny) for(i=0;i<ny;i++) a[xx+nx*(i+zz*ny)] = v->v(i);\r
+ if(vx>=ny) for(i=0;i<ny;i++) a[xx+nx*(i+zz*ny)] = b?b[i]:v->v(i);\r
else for(i=0;i<ny;i++) a[xx+nx*(i+zz*ny)] = vv;\r
}\r
else if(zz<0)\r
{\r
- if(vx>=nz) for(i=0;i<nz;i++) a[xx+nx*(yy+i*ny)] = v->v(i);\r
+ if(vx>=nz) for(i=0;i<nz;i++) a[xx+nx*(yy+i*ny)] = b?b[i]:v->v(i);\r
else for(i=0;i<nz;i++) a[xx+nx*(yy+i*ny)] = vv;\r
}\r
else a[xx+nx*(yy+ny*zz)] = vv;\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_data_put_val_(uintptr_t *d, float *val, int *i, int *j, int *k)\r
+void mgl_data_put_val_(uintptr_t *d, mreal *val, int *i, int *j, int *k)\r
{ mgl_data_put_val(_DT_,*val, *i,*j,*k); }\r
void mgl_data_put_dat_(uintptr_t *d, uintptr_t *val, int *i, int *j, int *k)\r
{ mgl_data_put_dat(_DT_,_DA_(val), *i,*j,*k); }\r
void mgl_data_diff_par_(uintptr_t *d, uintptr_t *v1, uintptr_t *v2, uintptr_t *v3)\r
{ mgl_data_diff_par(_DT_,_DA_(v1),_DA_(v2),_DA_(v3)); }\r
//-----------------------------------------------------------------------------\r
-void mgl_data_set_value(HMDT dat, float v, long i, long j, long k)\r
-{ dat->a[i+dat->nx*(j+dat->ny*k)]=v; }\r
-void mgl_data_set_value_(uintptr_t *d, float *v, int *i, int *j, int *k)\r
+void mgl_data_set_value(HMDT dat, mreal v, long i, long j, long k)\r
+{ if(i>=0 && i<dat->nx && j>=0 && j<dat->ny && k>=0 && k<dat->nz) dat->a[i+dat->nx*(j+dat->ny*k)]=v; }\r
+void mgl_data_set_value_(uintptr_t *d, mreal *v, int *i, int *j, int *k)\r
{ mgl_data_set_value(_DT_,*v,*i,*j,*k); }\r
//-----------------------------------------------------------------------------\r
-float mgl_data_get_value(HCDT dat, long i, long j, long k)\r
-{ return dat->v(i,j,k); }\r
-float mgl_data_get_value_(uintptr_t *d, int *i, int *j, int *k)\r
+mreal mgl_data_get_value(HCDT dat, long i, long j, long k)\r
+{ return (i>=0 && i<dat->GetNx() && j>=0 && j<dat->GetNy() && k>=0 && k<dat->GetNz()) ? dat->v(i,j,k):NAN; }\r
+mreal mgl_data_get_value_(uintptr_t *d, int *i, int *j, int *k)\r
{ return mgl_data_get_value(_DA_(d),*i,*j,*k); }\r
//-----------------------------------------------------------------------------\r
mreal *mgl_data_data(HMDT dat) { return dat->a; }\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdlib.h>\r
#include <ctype.h>\r
-#include <math.h>\r
-#include <string.h>\r
-#include <zlib.h>\r
\r
#ifndef WIN32\r
#include <glob.h>\r
if(NX<1 || NY <1 || NZ<1) return;\r
mgl_data_create(d, NX,NY,NZ);\r
long nb = strlen(buf);\r
- register long i=0, j=0, k=0;\r
+ register long i=0, j=0;\r
while(j<nb)\r
{\r
while(buf[j]<=' ' && j<nb) j++;\r
while(!isn(buf[j]) && j<nb)\r
{\r
if(buf[j]>='a' && buf[j]<='z')\r
- d->id[k++] = buf[j];\r
+ d->id.push_back(buf[j]);\r
j++;\r
}\r
}\r
void mgl_data_rearrange_(uintptr_t *d, int *mx, int *my, int *mz)\r
{ mgl_data_rearrange(_DT_,*mx,*my,*mz); }\r
//-----------------------------------------------------------------------------\r
-void mgl_data_set_id(HMDT d, const char *ids)\r
-{\r
- d->NewId(); // clearing + be sure about correct length\r
- if(ids) for(long i=0;i<d->nx && ids[i]!=0;i++) d->id[i]=ids[i];\r
-}\r
+void mgl_data_set_id(HMDT d, const char *ids) { d->id = ids; }\r
void mgl_data_set_id_(uintptr_t *d, const char *eq,int l)\r
{ char *s=new char[l+1]; memcpy(s,eq,l); s[l]=0;\r
mgl_data_set_id(_DT_, s); delete []s; }\r
char *buf = mgl_read_gz(fp);\r
nb = strlen(buf); gzclose(fp);\r
\r
- bool first=false,com=false;\r
+ bool first=false;\r
register char ch;\r
for(i=nb-1;i>=0;i--) if(buf[i]>' ') break;\r
buf[i+1]=0; nb = i; // remove tailing spaces\r
if(ch=='#') while(!isn(buf[i]) && i<nb) i++;\r
if(isn(ch))\r
{\r
+ while(buf[i+1]==' ' || buf[i+1]=='\t') i++;\r
if(isn(buf[i+1])) {first=true; break; }\r
m++;\r
}\r
if(first) for(i=0;i<nb-1;i++) // determine nz\r
{\r
ch = buf[i];\r
- if(ch=='#') com = true; // comment\r
+ if(ch=='#') while(!isn(buf[i]) && i<nb) i++;\r
+// if(ch=='#') com = true; // comment\r
if(isn(ch))\r
{\r
- if(com) { com=false; continue; }\r
+// if(com) { com=false; continue; }\r
+ while(buf[i+1]==' ' || buf[i+1]=='\t') i++;\r
if(isn(buf[i+1])) l++;\r
}\r
}\r
void mgl_data_create(HMDT d,long mx,long my,long mz)\r
{\r
d->nx = mx>0 ? mx:1; d->ny = my>0 ? my:1; d->nz = mz>0 ? mz:1;\r
- if(d->a && d->id) delete []d->id;\r
- if(d->a && !d->link) delete []d->a;\r
+ if(d->a && !d->link) delete [](d->a);\r
d->a = new mreal[d->nx*d->ny*d->nz];\r
- d->id = new char[d->nx]; d->link=false;\r
+ d->id.clear(); d->link=false;\r
memset(d->a,0,d->nx*d->ny*d->nz*sizeof(mreal));\r
- memset(d->id,0,d->nx*sizeof(char));\r
}\r
void mgl_data_create_(uintptr_t *d, int *nx,int *ny,int *nz)\r
{ mgl_data_create(_DT_,*nx,*ny,*nz); }\r
void mgl_data_link(HMDT d, mreal *A, long mx,long my,long mz)\r
{\r
if(!A) return;\r
- if(d->id && d->a) delete []d->id;\r
- if(!d->link && d->a) delete []d->a;\r
+ if(!d->link && d->a) delete [](d->a);\r
d->nx = mx>0 ? mx:1; d->ny = my>0 ? my:1; d->nz = mz>0 ? mz:1;\r
- d->link=true; d->NewId();\r
+ d->link=true; d->a=A; d->NewId();\r
}\r
void mgl_data_link_(uintptr_t *d, mreal *A, int *nx,int *ny,int *nz)\r
{ mgl_data_link(_DT_,A,*nx,*ny,*nz); }\r
char *buf = mgl_read_gz(fp);\r
long nb = strlen(buf); gzclose(fp);\r
\r
- register long j=0;\r
+ register long j=0,i,l;\r
while(j<nb)\r
{\r
if(buf[j]=='#') while(!isn(buf[j])) j++; // skip comment\r
if(dim==1)\r
{\r
sscanf(buf+j,"%ld",&nx);\r
- while(buf[j]>' ') j++;\r
+ while(buf[j]!='\n' && j<nb) j++; j++;\r
+// while(buf[j]>' ') j++;\r
}\r
else if(dim==2)\r
{\r
sscanf(buf+j,"%ld%ld",&nx,&ny);\r
- while(buf[j]>' ' && j<nb) j++;\r
- while(buf[j]<=' ' && j<nb) j++;\r
- while(buf[j]>' ' && j<nb) j++;\r
+ while(buf[j]!='\n' && j<nb) j++; j++;\r
+ char *b=buf+j, ch;\r
+ for(i=l=0;b[i];i++)\r
+ {\r
+ while(b[i]=='#') { while(!isn(b[i]) && b[i]) i++; }\r
+ if(b[i]=='\n') l++;\r
+ }\r
+ if(l==nx*ny || l==nx*ny+1) // try to read 3d data (i.e. columns of matrix nx*ny)\r
+ {\r
+ nz=ny; ny=nx; nx=1;\r
+ bool first = false;\r
+ for(i=l=0;b[i] && !isn(b[i]);i++) // determine nx\r
+ {\r
+ while(b[i]=='#') { while(!isn(b[i]) && b[i]) i++; }\r
+ ch = b[i];\r
+ if(ch>' ' && !first) first=true;\r
+ if(first && (ch==' ' || ch=='\t' || ch==',') && b[i+1]>' ') nx++;\r
+ }\r
+ }\r
}\r
else if(dim==3)\r
{\r
sscanf(buf+j,"%ld%ld%ld",&nx,&ny,&nz);\r
- while(buf[j]>' ' && j<nb) j++;\r
+ while(buf[j]!='\n' && j<nb) j++; j++;\r
+/* while(buf[j]>' ' && j<nb) j++;\r
while(buf[j]<=' ' && j<nb) j++;\r
while(buf[j]>' ' && j<nb) j++;\r
while(buf[j]<=' ' && j<nb) j++;\r
- while(buf[j]>' ' && j<nb) j++;\r
+ while(buf[j]>' ' && j<nb) j++;*/\r
}\r
mglFromStr(d,buf+j,nx,ny,nz);\r
free(buf); return true;\r
{ char *s=new char[l+1]; memcpy(s,fname,l); s[l]=0;\r
int r = mgl_data_read_mat(_DT_,s,*dim); delete []s; return r; }\r
//-----------------------------------------------------------------------------\r
-float mgl_data_max(HCDT d)\r
+mreal mgl_data_max(HCDT d)\r
{\r
register mreal m=-1e10, v;\r
register long nn=d->GetNN();\r
{ v = d->vthr(i); if(!mgl_isnan(v)) m = m>v ? m:v; }\r
return m;\r
}\r
-float mgl_data_max_(uintptr_t *d) { return mgl_data_max(_DT_); }\r
+mreal mgl_data_max_(uintptr_t *d) { return mgl_data_max(_DT_); }\r
//-----------------------------------------------------------------------------\r
-float mgl_data_min(HCDT d)\r
+mreal mgl_data_min(HCDT d)\r
{\r
register mreal m=1e10, v;\r
register long nn=d->GetNN();\r
{ v = d->vthr(i); if(!mgl_isnan(v)) m = m<v ? m:v; }\r
return m;\r
}\r
-float mgl_data_min_(uintptr_t *d) { return mgl_data_min(_DT_); }\r
+mreal mgl_data_min_(uintptr_t *d) { return mgl_data_min(_DT_); }\r
//-----------------------------------------------------------------------------\r
-float mgl_data_max_int(HCDT d, long *i, long *j, long *k)\r
+mreal mgl_data_max_int(HCDT d, long *i, long *j, long *k)\r
{\r
register mreal m=-1e10, v;\r
long nx=d->GetNx(), ny=d->GetNy(), nn=d->GetNN();\r
}\r
return m;\r
}\r
-float mgl_data_max_int_(uintptr_t *d, int *i, int *j, int *k)\r
-{ long ii,jj,kk; float res=mgl_data_max_int(_DT_,&ii,&jj,&kk);\r
+mreal mgl_data_max_int_(uintptr_t *d, int *i, int *j, int *k)\r
+{ long ii,jj,kk; mreal res=mgl_data_max_int(_DT_,&ii,&jj,&kk);\r
*i=ii; *j=jj; *k=kk; return res; }\r
//-----------------------------------------------------------------------------\r
-float mgl_data_min_int(HCDT d, long *i, long *j, long *k)\r
+mreal mgl_data_min_int(HCDT d, long *i, long *j, long *k)\r
{\r
register mreal m=1e10, v;\r
long nx=d->GetNx(), ny=d->GetNy(), nn=d->GetNN();\r
}\r
return m;\r
}\r
-float mgl_data_min_int_(uintptr_t *d, int *i, int *j, int *k)\r
-{ long ii,jj,kk; float res=mgl_data_min_int(_DT_,&ii,&jj,&kk);\r
+mreal mgl_data_min_int_(uintptr_t *d, int *i, int *j, int *k)\r
+{ long ii,jj,kk; mreal res=mgl_data_min_int(_DT_,&ii,&jj,&kk);\r
*i=ii; *j=jj; *k=kk; return res; }\r
//-----------------------------------------------------------------------------\r
-float mgl_data_max_real(HCDT d, mreal *x, mreal *y, mreal *z)\r
+mreal mgl_data_max_real(HCDT d, mreal *x, mreal *y, mreal *z)\r
{\r
long im=-1,jm=-1,km=-1;\r
long nx=d->GetNx(), ny=d->GetNy(), nz=d->GetNz();\r
}\r
return m;\r
}\r
-float mgl_data_max_real_(uintptr_t *d, mreal *x, mreal *y, mreal *z)\r
+mreal mgl_data_max_real_(uintptr_t *d, mreal *x, mreal *y, mreal *z)\r
{ return mgl_data_max_real(_DT_,x,y,z); }\r
//-----------------------------------------------------------------------------\r
-float mgl_data_min_real(HCDT d, mreal *x, mreal *y, mreal *z)\r
+mreal mgl_data_min_real(HCDT d, mreal *x, mreal *y, mreal *z)\r
{\r
long im=-1,jm=-1,km=-1;\r
long nx=d->GetNx(), ny=d->GetNy(), nz=d->GetNz();\r
}\r
return m;\r
}\r
-float mgl_data_min_real_(uintptr_t *d, mreal *x, mreal *y, mreal *z)\r
+mreal mgl_data_min_real_(uintptr_t *d, mreal *x, mreal *y, mreal *z)\r
{ return mgl_data_min_real(_DT_,x,y,z); }\r
//-----------------------------------------------------------------------------\r
void *mgl_fill_x(void *par)\r
}\r
return 0;\r
}\r
-void mgl_data_fill(HMDT d, float x1,float x2,char dir)\r
+void mgl_data_fill(HMDT d, mreal x1,mreal x2,char dir)\r
{\r
if(mgl_isnan(x2)) x2=x1;\r
if(dir<'x' || dir>'z') dir='x';\r
if(dir=='z') b[1] *= d->nz>1 ? 1./(d->nz-1):0;\r
mglStartThread(mgl_fill_x,0,d->nx*d->ny*d->nz,d->a,b,0,par,0,0,0,&dir);\r
}\r
-void mgl_data_fill_(uintptr_t *d, float *x1,float *x2,const char *dir,int)\r
+void mgl_data_fill_(uintptr_t *d, mreal *x1,mreal *x2,const char *dir,int)\r
{ mgl_data_fill(_DT_,*x1,*x2,*dir); }\r
//-----------------------------------------------------------------------------\r
-void mgl_data_norm(HMDT d, float v1,float v2,long sym,long dim)\r
+void mgl_data_norm(HMDT d, mreal v1,mreal v2,long sym,long dim)\r
{\r
long i,s,nn=d->nx*d->ny*d->nz;\r
mreal a1=1e20,a2=-1e20,v,*a=d->a;\r
for(i=s;i<nn;i++) // normalize\r
a[i] = v1 + (v2-v1)*(a[i]-a1)/(a2-a1);\r
}\r
-void mgl_data_norm_(uintptr_t *d, float *v1,float *v2,int *sym,int *dim)\r
+void mgl_data_norm_(uintptr_t *d, mreal *v1,mreal *v2,int *sym,int *dim)\r
{ mgl_data_norm(_DT_,*v1,*v2,*sym,*dim); }\r
//-----------------------------------------------------------------------------\r
void mgl_data_squeeze(HMDT d, long rx,long ry,long rz,long smooth)\r
s += d->a[i1+nx*(j1+ny*k1)];\r
b[i+kx*(j+ky*k)] = s/dx*dy*dz;\r
}\r
- if(!d->link) delete []d->a;\r
+ if(!d->link) delete [](d->a);\r
d->a=b; d->nx = kx; d->ny = ky; d->nz = kz; d->NewId(); d->link=false;\r
}\r
void mgl_data_squeeze_(uintptr_t *d, int *rx,int *ry,int *rz,int *smooth)\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdlib.h>\r
#include <ctype.h>\r
-#include <math.h>\r
-#include <string.h>\r
-\r
#include "mgl2/data.h"\r
\r
#if MGL_HAVE_GSL\r
mglFormula f(eq);\r
mglData *r=new mglData(ny,nz);\r
const mglData *d=dynamic_cast<const mglData *>(dat);\r
- if(d) mglStartThread(mgl_column,0,ny*nz,r->a,d->a,0,&nx,&f,0,0,d->id);\r
+ if(d) mglStartThread(mgl_column,0,ny*nz,r->a,d->a,0,&nx,&f,0,0,d->id.c_str());\r
return r;\r
}\r
uintptr_t mgl_data_column_(uintptr_t *d, const char *eq,int l)\r
}\r
return 0;\r
}\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_resize_box(HCDT dat, long mx,long my,long mz, mreal x1,mreal x2, mreal y1,mreal y2, mreal z1,mreal z2)\r
{ // NOTE: only for mglData (for speeding up)\r
mx = mx<1 ? 1:mx; my = my<1 ? 1:my; mz = mz<1 ? 1:mz;\r
mglData *r=new mglData(mx,my,mz);\r
{ return mgl_data_resize_box(d, mx,my,mz,0,1,0,1,0,1); }\r
uintptr_t mgl_data_resize_(uintptr_t *d, int *mx,int *my,int *mz)\r
{ return uintptr_t(mgl_data_resize(_DT_,*mx,*my,*mz)); }\r
-uintptr_t mgl_data_resize_box_(uintptr_t *d, int *mx,int *my,int *mz, float *x1,float *x2, float *y1,float *y2, float *z1,float *z2)\r
+uintptr_t mgl_data_resize_box_(uintptr_t *d, int *mx,int *my,int *mz, mreal *x1,mreal *x2, mreal *y1,mreal *y2, mreal *z1,mreal *z2)\r
{ return uintptr_t(mgl_data_resize_box(_DT_,*mx,*my,*mz,*x1,*x2,*y1,*y2,*z1,*z2)); }\r
//-----------------------------------------------------------------------------\r
void *mgl_combine(void *par)\r
k = i*nx; memset(b,0,4*nx*sizeof(double)); b[0] = b[2*nx] = a[k];\r
for(j=1;j<nx;j++) { b[2*j] = a[k+j]; b[4*nx-2*j] = a[k+j]; }\r
gsl_fft_complex_transform(b, 1, 2*nx, wt, ws, forward);\r
- for(j=0;j<nx;j++) a[k+j] = b[2*j]/sqrt(2*nx);\r
+ for(j=0;j<nx;j++) a[k+j] = b[2*j]/sqrt(2.*nx);\r
}\r
}\r
if(strchr(dir,'y') && ny>1)\r
memset(b,0,4*ny*sizeof(double)); b[0] = b[2*ny] = a[i+nx*ny*k];\r
for(j=1;j<ny;j++) { b[2*j] = a[i+nx*(ny*k+j)]; b[4*ny-2*j] = a[i+nx*(ny*k+j)]; }\r
gsl_fft_complex_transform(b, 1, 2*ny, wt, ws, forward);\r
- for(j=0;j<ny;j++) a[i+nx*(ny*k+j)] = b[2*j]/sqrt(2*ny);\r
+ for(j=0;j<ny;j++) a[i+nx*(ny*k+j)] = b[2*j]/sqrt(2.*ny);\r
}\r
}\r
if(strchr(dir,'z') && nz>1)\r
memset(b,0,4*nz*sizeof(double)); b[0] = b[2*nx] = a[i];\r
for(j=1;j<nx;j++) { b[2*j] = a[i+k*j]; b[4*nx-2*j] = a[i+k*j]; }\r
gsl_fft_complex_transform(b, 1, 2*nz, wt, ws, forward);\r
- for(j=0;j<nz;j++) a[i+k*j] = b[2*j]/sqrt(2*nz);\r
+ for(j=0;j<nz;j++) a[i+k*j] = b[2*j]/sqrt(2.*nz);\r
}\r
}\r
if(b)\r
k = i*nx; memset(b,0,4*nx*sizeof(double)); b[0] = a[k]; b[2*nx] = -a[k];\r
for(j=1;j<nx;j++) { b[2*j] = a[k+j]; b[4*nx-2*j] = -a[k+j]; }\r
gsl_fft_complex_transform(b, 1, 2*nx, wt, ws, forward);\r
- for(j=0;j<nx;j++) a[k+j] = -b[2*j+1]/sqrt(2*nx);\r
+ for(j=0;j<nx;j++) a[k+j] = -b[2*j+1]/sqrt(2.*nx);\r
}\r
}\r
if(strchr(dir,'y') && ny>1)\r
memset(b,0,4*ny*sizeof(double)); b[0] = a[i+nx*ny*k]; b[2*ny] = -a[i+nx*ny*k];\r
for(j=1;j<ny;j++) { b[2*j] = a[i+nx*(ny*k+j)]; b[4*ny-2*j] = -a[i+nx*(ny*k+j)]; }\r
gsl_fft_complex_transform(b, 1, 2*ny, wt, ws, forward);\r
- for(j=0;j<ny;j++) a[i+nx*(ny*k+j)] = -b[2*j+1]/sqrt(2*ny);\r
+ for(j=0;j<ny;j++) a[i+nx*(ny*k+j)] = -b[2*j+1]/sqrt(2.*ny);\r
}\r
}\r
if(strchr(dir,'z') && nz>1)\r
memset(b,0,4*nz*sizeof(double)); b[0] = a[i]; b[2*nx] = -a[i];\r
for(j=1;j<nx;j++) { b[2*j] = a[i+k*j]; b[4*nx-2*j] = -a[i+k*j]; }\r
gsl_fft_complex_transform(b, 1, 2*nz, wt, ws, forward);\r
- for(j=0;j<nz;j++) a[i+k*j] = -b[2*j+1]/sqrt(2*nz);\r
+ for(j=0;j<nz;j++) a[i+k*j] = -b[2*j+1]/sqrt(2.*nz);\r
}\r
}\r
if(b)\r
if(nx*ny*nz != ph->GetNx()*ph->GetNy()*ph->GetNz() || !tr || tr[0]==0)\r
return (new mglData);\r
mglData re(nx,ny,nz), im(nx,ny,nz);\r
- for(long i=0;i<nx*ny*nz;i++)\r
+ const mglData *da=dynamic_cast<const mglData *>(am);\r
+ const mglData *dp=dynamic_cast<const mglData *>(ph);\r
+ if(da && dp) for(long i=0;i<nx*ny*nz;i++)\r
+ { re.a[i] = da->a[i]*cos(dp->a[i]);\r
+ im.a[i] = da->a[i]*sin(dp->a[i]); }\r
+ else for(long i=0;i<nx*ny*nz;i++)\r
{ re.a[i] = am->vthr(i)*cos(ph->vthr(i));\r
im.a[i] = am->vthr(i)*sin(ph->vthr(i)); }\r
return mgl_transform(&re, &im, tr);\r
d->a[i+nx*(j+ny*k)] *= a->v(i,j,k);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_data_mul_num(HMDT d, float a)\r
+void mgl_data_mul_num(HMDT d, mreal a)\r
{\r
long n=1, nx=d->nx, ny=d->ny, nz=d->nz; mreal aa=a;\r
mglStartThread(mgl_eqmul,0,nx*ny*nz,d->a,&aa,0,&n);\r
d->a[i+nx*(j+ny*k)] /= a->v(i,j,k);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_data_div_num(HMDT d, float a)\r
+void mgl_data_div_num(HMDT d, mreal a)\r
{\r
long n=1, nx=d->nx, ny=d->ny, nz=d->nz; mreal aa=a;\r
mglStartThread(mgl_eqdiv,0,nx*ny*nz,d->a,&aa,0,&n);\r
d->a[i+nx*(j+ny*k)] += a->v(i,j,k);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_data_add_num(HMDT d, float a)\r
+void mgl_data_add_num(HMDT d, mreal a)\r
{\r
long n=1, nx=d->nx, ny=d->ny, nz=d->nz; mreal aa=a;\r
mglStartThread(mgl_eqadd,0,nx*ny*nz,d->a,&aa,0,&n);\r
d->a[i+nx*(j+ny*k)] -= a->v(i,j,k);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_data_sub_num(HMDT d, float a)\r
+void mgl_data_sub_num(HMDT d, mreal a)\r
{\r
long n=1, nx=d->nx, ny=d->ny, nz=d->nz; mreal aa=a;\r
mglStartThread(mgl_eqsub,0,nx*ny*nz,d->a,&aa,0,&n);\r
void mgl_data_div_dat_(uintptr_t *d, uintptr_t *b) { mgl_data_div_dat(_DT_, _DA_(b)); }\r
void mgl_data_add_dat_(uintptr_t *d, uintptr_t *b) { mgl_data_add_dat(_DT_, _DA_(b)); }\r
void mgl_data_sub_dat_(uintptr_t *d, uintptr_t *b) { mgl_data_sub_dat(_DT_, _DA_(b)); }\r
-void mgl_data_mul_num_(uintptr_t *d, float *b) { mgl_data_mul_num(_DT_, *b); }\r
-void mgl_data_div_num_(uintptr_t *d, float *b) { mgl_data_div_num(_DT_, *b); }\r
-void mgl_data_add_num_(uintptr_t *d, float *b) { mgl_data_add_num(_DT_, *b); }\r
-void mgl_data_sub_num_(uintptr_t *d, float *b) { mgl_data_sub_num(_DT_, *b); }\r
+void mgl_data_mul_num_(uintptr_t *d, mreal *b) { mgl_data_mul_num(_DT_, *b); }\r
+void mgl_data_div_num_(uintptr_t *d, mreal *b) { mgl_data_div_num(_DT_, *b); }\r
+void mgl_data_add_num_(uintptr_t *d, mreal *b) { mgl_data_add_num(_DT_, *b); }\r
+void mgl_data_sub_num_(uintptr_t *d, mreal *b) { mgl_data_sub_num(_DT_, *b); }\r
//-----------------------------------------------------------------------------\r
void mgl_hist_p(mglThreadD *t,mreal *a)\r
{\r
register long i,j,n=t[0].p[0];\r
mreal *b;\r
+ memset(a,0,n*sizeof(mreal));\r
for(i=0;i<mglNumThr;i++)\r
{\r
b = t[i].a;\r
mglThreadD *t=(mglThreadD *)par;\r
register long i,k, nn=t->n, n = t->p[0];\r
mreal *b=new mreal[n], *v=(mreal *)t->v;\r
+ memset(b,0,n*sizeof(mreal));\r
const mreal *a=t->b, *c=t->c;\r
for(i=t->id;i<nn;i+=mglNumThr)\r
{\r
register long i,k, nn=t->n, n = t->p[0];\r
long ns=t->p[1], nx=t->p[2], ny=t->p[3], nz=t->p[4];\r
mreal *b=new mreal[n], *v=(mreal *)t->v, f,w=1, x,y,z, d=1./ns;\r
+ memset(b,0,n*sizeof(mreal));\r
const mreal *a=t->b, *c=t->c;\r
bool sp = n>0;\r
for(i=t->id;i<nn;i+=mglNumThr)\r
}\r
t->a = b; return 0;\r
}\r
-HMDT mgl_data_hist(HCDT dat, long n, float v1, float v2, long nsub)\r
+HMDT mgl_data_hist(HCDT dat, long n, mreal v1, mreal v2, long nsub)\r
{\r
mglData *b=new mglData; // NOTE: For mglData only!\r
const mglData *d = dynamic_cast<const mglData *>(dat);\r
return b;\r
}\r
//-----------------------------------------------------------------------------\r
-HMDT mgl_data_hist_w(HCDT dat, HCDT weight, long n, float v1, float v2, long nsub)\r
+HMDT mgl_data_hist_w(HCDT dat, HCDT weight, long n, mreal v1, mreal v2, long nsub)\r
{\r
mglData *b=new mglData; // NOTE: For mglData only!\r
const mglData *d = dynamic_cast<const mglData *>(dat);\r
return b;\r
}\r
//-----------------------------------------------------------------------------\r
-uintptr_t mgl_data_hist_(uintptr_t *d, int *n, float *v1, float *v2, int *nsub)\r
+uintptr_t mgl_data_hist_(uintptr_t *d, int *n, mreal *v1, mreal *v2, int *nsub)\r
{ return uintptr_t(mgl_data_hist(_DT_,*n,*v1,*v2,*nsub)); }\r
-uintptr_t mgl_data_hist_w_(uintptr_t *d, uintptr_t *w, int *n, float *v1, float *v2, int *nsub)\r
+uintptr_t mgl_data_hist_w_(uintptr_t *d, uintptr_t *w, int *n, mreal *v1, mreal *v2, int *nsub)\r
{ return uintptr_t(mgl_data_hist_w(_DT_,_DA_(w),*n,*v1,*v2,*nsub)); }\r
//-----------------------------------------------------------------------------\r
mreal mglLinear(const mreal *a, long nx, long ny, long nz, mreal x, mreal y, mreal z)\r
mreal b=0,dx,dy,dz,b1,b0;\r
if(x<0 || y<0 || z<0 || x>nx-1 || y>ny-1 || z>nz-1)\r
return 0;\r
- if(nz>1 && z!=long(z)) // 3d interpolation\r
+ if(nz>1 && z!=floor(z)) // 3d interpolation\r
{\r
kx=long(x); ky=long(y); kz=long(z);\r
dx = x-kx; dy = y-ky; dz = z-kz;\r
dy*(1-dx)*a[i0+nx] + dx*dy*a[i0+nx+1];\r
b = b0 + dz*(b1-b0);\r
}\r
- else if(ny>1 && y!=long(y)) // 2d interpolation\r
+ else if(ny>1 && y!=floor(y)) // 2d interpolation\r
{\r
kx=long(x); ky=long(y);\r
dx = x-kx; dy=y-ky;\r
b = a[i0]*(1-dx-dy+dx*dy) + dx*(1-dy)*a[i0+1] +\r
dy*(1-dx)*a[i0+nx] + dx*dy*a[i0+nx+1];\r
}\r
- else if(nx>1 && x!=long(x)) // 1d interpolation\r
+ else if(nx>1 && x!=floor(x)) // 1d interpolation\r
{\r
kx = long(x);\r
b = a[kx] + (x-kx)*(a[kx+1]-a[kx]);\r
+++ /dev/null
-/***************************************************************************\r
- * data_op.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 *
- * 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>\r
-#include <ctype.h>\r
-#include <math.h>\r
-#include <string.h>\r
-\r
-#include "mgl2/data.h"
-//-----------------------------------------------------------------------------\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 "mgl2/data.h"\r
+#if MGL_HAVE_PNG\r
+#include <png.h>\r
+#endif\r
//-----------------------------------------------------------------------------\r
long mgl_col_dif(unsigned char *c1,unsigned char *c2,bool sum)\r
{\r
return c;\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_data_import(HMDT d, const char *fname, const char *scheme,float v1,float v2)\r
+void mgl_data_import(HMDT d, const char *fname, const char *scheme,mreal v1,mreal v2)\r
{\r
+#if MGL_HAVE_PNG\r
if(v1>=v2) return;\r
long num=0;\r
FILE *fp = fopen(fname, "rb");\r
delete []c;\r
png_destroy_read_struct(&png_ptr, &info_ptr,&end_info);\r
fclose(fp);\r
+#endif\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_data_export(HCDT dd, const char *fname, const char *scheme,float v1,float v2,long ns)\r
+void mgl_data_export(HCDT dd, const char *fname, const char *scheme,mreal v1,mreal v2,long ns)\r
{\r
+#if MGL_HAVE_PNG\r
register long i,j,k;\r
long nx=dd->GetNx(), ny=dd->GetNy(), nz=dd->GetNz();\r
+ const mglData *md = dynamic_cast<const mglData *>(dd);\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
+ if(md) for(i=0;i<nx*ny*nz;i++)\r
+ { vv = md->a[i]; if(vv<v1) v1=vv; if(vv>v2) v2=vv; }\r
+ else 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
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
+ if(md) for(i=0;i<ny;i++) for(j=0;j<nx;j++)\r
+ {\r
+ k = long(num*(md->a[j+nx*(i+ny*nz)]-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
+ else 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
png_write_end(png_ptr, info_ptr);\r
png_destroy_write_struct(&png_ptr, &info_ptr);\r
fclose(fp); free(p); free(d);\r
+#endif\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
+void mgl_data_export_(uintptr_t *d, const char *fname, const char *scheme,mreal *v1,mreal *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
+void mgl_data_import_(uintptr_t *d, const char *fname, const char *scheme,mreal *v1,mreal *v2,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
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdlib.h>\r
#include <time.h>\r
-#include <math.h>\r
#include <ctype.h>\r
-#include <string.h>\r
\r
#include "mgl2/eval.h"\r
\r
int mglFindInText(char *str,const char *lst);\r
//-----------------------------------------------------------------------------\r
#if MGL_HAVE_GSL\r
-gsl_rng *mgl_rng=0;\r
+gsl_rng *mgl_rng=0; // TODO: should be deleted by gsl_rng_free() but I don't know where :(\r
#endif\r
void mgl_srnd(long seed)\r
{\r
mreal mglFormula::Calc(mreal x,mreal y,mreal t,mreal u) const\r
{\r
Error=0;\r
- mreal a1[MGL_VS]; memset(a1,0,MGL_VS*sizeof(float));\r
+ mreal a1[MGL_VS]; memset(a1,0,MGL_VS*sizeof(mreal));\r
a1['a'-'a'] = a1['c'-'a'] = a1['u'-'a'] = u;\r
a1['x'-'a'] = a1['r'-'a'] = x;\r
a1['y'-'a'] = a1['n'-'a'] = a1['v'-'a'] = y;\r
mreal mglFormula::Calc(mreal x,mreal y,mreal t,mreal u,mreal v,mreal w) const\r
{\r
Error=0;\r
- mreal a1[MGL_VS]; memset(a1,0,MGL_VS*sizeof(float));\r
+ mreal a1[MGL_VS]; memset(a1,0,MGL_VS*sizeof(mreal));\r
a1['c'-'a'] = a1['w'-'a'] = w;\r
a1['b'-'a'] = a1['v'-'a'] = v;\r
a1['a'-'a'] = a1['u'-'a'] = u;\r
mreal mglFormula::CalcD(char diff,mreal x,mreal y,mreal t,mreal u) const\r
{\r
Error=0;\r
- mreal a1[MGL_VS]; memset(a1,0,MGL_VS*sizeof(float));\r
+ mreal a1[MGL_VS]; memset(a1,0,MGL_VS*sizeof(mreal));\r
a1['a'-'a'] = a1['c'-'a'] = a1['u'-'a'] = u;\r
a1['x'-'a'] = a1['r'-'a'] = x;\r
a1['y'-'a'] = a1['n'-'a'] = a1['v'-'a'] = y;\r
mreal mglFormula::CalcD(char diff,mreal x,mreal y,mreal t,mreal u,mreal v,mreal w) const\r
{\r
Error=0;\r
- mreal a1[MGL_VS]; memset(a1,0,MGL_VS*sizeof(float));\r
+ mreal a1[MGL_VS]; memset(a1,0,MGL_VS*sizeof(mreal));\r
a1['c'-'a'] = a1['w'-'a'] = w;\r
a1['b'-'a'] = a1['v'-'a'] = v;\r
a1['a'-'a'] = a1['u'-'a'] = u;\r
double mgz1(double) {return 0;}\r
double mgz2(double,double) {return 0;}\r
#ifdef WIN32\r
-double asinh(double x) { return log(x+sqrt(x*x+1)); }\r
-double acosh(double x) { return x>1 ? log(x+sqrt(x*x-1)) : NAN; }\r
-double atanh(double x) { return fabs(x)<1 ? log((1+x)/(1-x))/2 : NAN; }\r
+double asinh(double x) { return log(x+sqrt(x*x+1.)); }\r
+double acosh(double x) { return x>1 ? log(x+sqrt(x*x-1.)) : NAN; }\r
+double atanh(double x) { return fabs(x)<1 ? log((1.+x)/(1.-x))/2 : NAN; }\r
#endif\r
//-----------------------------------------------------------------------------\r
typedef double (*func_1)(double);\r
// evaluation of embedded (included) expressions\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
+ mreal z2[22] = {3,3,3,3,0,3,3,0,0,0,0,0,NAN,0\r
#if MGL_HAVE_GSL\r
,3,NAN, 3,NAN, 0,0,3,1\r
#else\r
double llg2(double a,double b) {return -log(a)/(b*log(b)*log(b));}\r
double cos_d(double a) {return -sin(a);}\r
double tan_d(double a) {return 1./(cos(a)*cos(a));}\r
-double asin_d(double a) {return 1./sqrt(1-a*a);}\r
-double acos_d(double a) {return -1./sqrt(1-a*a);}\r
-double atan_d(double a) {return 1./(1+a*a);}\r
+double asin_d(double a) {return 1./sqrt(1.-a*a);}\r
+double acos_d(double a) {return -1./sqrt(1.-a*a);}\r
+double atan_d(double a) {return 1./(1.+a*a);}\r
double tanh_d(double a) {return 1./(cosh(a)*cosh(a));}\r
-double atanh_d(double a){return 1./(1-a*a);}\r
-double asinh_d(double a){return 1./sqrt(1+a*a);}\r
-double acosh_d(double a){return 1./sqrt(a*a-1);}\r
+double atanh_d(double a){return 1./(1.-a*a);}\r
+double asinh_d(double a){return 1./sqrt(1.+a*a);}\r
+double acosh_d(double a){return 1./sqrt(a*a-1.);}\r
double sqrt_d(double a) {return 0.5/sqrt(a);}\r
double log10_d(double a){return M_LN10/a;}\r
-double log_d(double a) {return 1/a;}\r
+double log_d(double a) {return 1./a;}\r
double erf_d(double a) {return 2*exp(-a*a)/sqrt(M_PI);}\r
-double dilog_d(double a){return log(a)/(1-a);}\r
+double dilog_d(double a){return log(a)/(1.-a);}\r
double ei_d(double a) {return exp(a)/a;}\r
double si_d(double a) {return a?sin(a)/a:1;}\r
double ci_d(double a) {return cos(a)/a;}\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
double gslKnuD(double a,double b) {return -(a*gsl_sf_bessel_Knu(a,b)/b +gsl_sf_bessel_Knu(a-1,b));}\r
double gslInuD(double a,double b) {return -(a*gsl_sf_bessel_Inu(a,b)/b -gsl_sf_bessel_Inu(a-1,b));}\r
-double gslEllE1(double a,double b) {return sqrt(1-sin(a)*sin(a)*b);}\r
-double gslEllE2(double a,double b) {return (gsl_sf_ellint_E(a,b,GSL_PREC_SINGLE) - gsl_sf_ellint_F(a,b,GSL_PREC_SINGLE))/(2*b);}\r
-double gslEllF1(double a,double b) {return 1./sqrt(1-sin(a)*sin(a)*b);}\r
-double gslEllF2(double a,double b) {return (gsl_sf_ellint_E(a,b,GSL_PREC_SINGLE) - gsl_sf_ellint_F(a,b,GSL_PREC_SINGLE)*(1-b))/(2*b*(1-b)) - sin(2*a)/(sqrt(1-sin(a)*sin(a)*b)*2*(1-b));}\r
-double gslE_d(double a) {return (gsl_sf_ellint_Ecomp(a,GSL_PREC_SINGLE) - gsl_sf_ellint_Kcomp(a,GSL_PREC_SINGLE))/(2*a);}\r
-double gslK_d(double a) {return (gsl_sf_ellint_Ecomp(a,GSL_PREC_SINGLE) - (1-a)*gsl_sf_ellint_Kcomp(a,GSL_PREC_SINGLE))/(2*a*(1-a));}\r
+double gslEllE1(double a,double b) {return sqrt(1.-sin(a)*sin(a)*b);}\r
+double gslEllE2(double a,double b) {return (gsl_sf_ellint_E(a,b,GSL_PREC_SINGLE) - gsl_sf_ellint_F(a,b,GSL_PREC_SINGLE))/(2.*b);}\r
+double gslEllF1(double a,double b) {return 1./sqrt(1.-sin(a)*sin(a)*b);}\r
+double gslEllF2(double a,double b) {return (gsl_sf_ellint_E(a,b,GSL_PREC_SINGLE) - gsl_sf_ellint_F(a,b,GSL_PREC_SINGLE)*(1.-b))/(2*b*(1.-b)) - sin(2.*a)/(sqrt(1.-sin(a)*sin(a)*b)*2.*(1.-b));}\r
+double gslE_d(double a) {return (gsl_sf_ellint_Ecomp(a,GSL_PREC_SINGLE) - gsl_sf_ellint_Kcomp(a,GSL_PREC_SINGLE))/(2.*a);}\r
+double gslK_d(double a) {return (gsl_sf_ellint_Ecomp(a,GSL_PREC_SINGLE) - (1.-a)*gsl_sf_ellint_Kcomp(a,GSL_PREC_SINGLE))/(2.*a*(1.-a));}\r
double gamma_d(double a) {return gsl_sf_psi(a)*gsl_sf_gamma(a);}\r
#endif\r
//-----------------------------------------------------------------------------\r
mgz1,mgz1,mgz1,mgz1,mgz1,mgz1,mgz1,mgz1,mgz1,mgz1,mgz1\r
#endif\r
};\r
-// if(Error) return 0;\r
if(Kod<EQ_LT) return (Kod==EQ_A && id==(int)Res)?1:0;\r
\r
double a = Left->CalcIn(a1), d = Left->CalcDIn(id,a1);\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdlib.h>\r
#include <time.h>\r
-#include <math.h>\r
-#include <string.h>\r
#include "mgl2/evalc.h"\r
#include "mgl2/addon.h"\r
-#include "mgl2/data.h"\r
#if MGL_HAVE_GSL\r
#include <gsl/gsl_sf.h>\r
#endif\r
//-----------------------------------------------------------------------------\r
+extern "C"{\r
+void mgl_srnd(long seed);\r
+double mgl_rnd();\r
+double mgl_ipow(double x,int n);\r
+}\r
+//-----------------------------------------------------------------------------\r
// ��������� ��� ������������� ���������\r
enum{\r
EQ_NUM=0, // a variable substitution\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 if(str[0]=='i') Res = dual(0,str[1]>' '?atof(str+1):1);\r
else Res=atof(str); // ��� �����\r
}\r
else\r
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#include <stdlib.h>
#include <time.h>
-#include <math.h>
-#include <wchar.h>
#include "mgl2/parser.h"
#if MGL_HAVE_GSL
#include <gsl/gsl_sf.h>
else res = mglApplyOper(Buf,Buf+n+1,arg, div);
delete []str; return res;
}
+ n=mglFindInText(str,"@"); // high priority -- combine
+ if(n>=0)
+ {
+ wcscpy(Buf,str); Buf[n]=0;
+ const mglData &a = mglFormulaCalc(Buf,arg), &b = mglFormulaCalc(Buf+n+1,arg);
+ delete []str; return a.Combine(b);
+ }
n=mglFindInText(str,"^"); // highest priority -- power
if(n>=0)
{
else if(!wcscmp(p,L"wa")) { d.Momentum('a',x,y); v=y; }
else if(!wcscmp(p,L"sa")) { d.Momentum('a',x,y,z,k);v=z; }
else if(!wcscmp(p,L"ka")) { d.Momentum('a',x,y,z,k);v=k; }
- // if this is valid suffix when finish parsing (it can be float number)
+ // if this is valid suffix when finish parsing (it can be mreal number)
if(!mgl_isnan(v)) { res.a[0] = v; delete []str; return res; }
}
for(n=0;n<len;n++) if(str[n]=='(') break;
//-----------------------------------------------------------------------------
void mgl_wcslwr(wchar_t *str)
{
- for(long k=0;k<(long)wcslen(str);k++) // ������� ��������� �������
+ for(size_t k=0;k<wcslen(str);k++) // ������� ��������� �������
str[k] = (str[k]>='A' && str[k]<='Z') ? str[k]+'a'-'A' : str[k];
}
//-----------------------------------------------------------------------------
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#include <stdio.h>
-#include <wchar.h>
#ifdef WIN32
#include <io.h>
#include <direct.h>
if(k[0]==1 && k[1]==1 && k[2]==1 && k[3]==1 && k[4]==3)
gr->Beam(*(a[0].d),*(a[1].d),*(a[2].d),*(a[3].d),a[4].v,
k[5]==2? a[5].s.c_str():"",k[6]==3?iint(a[6].v):0, iint(k[7]==3?a[7].v:3));
+ if(k[0]==3 && k[1]==1 && k[2]==1 && k[3]==1 && k[4]==1 && k[5]==3)
+ gr->Beam(a[0].v,*(a[1].d),*(a[2].d),*(a[3].d),*(a[4].d),a[5].v,
+ k[6]==2? a[6].s.c_str():"",k[7]==3?iint(a[7].v):0);
else return 1;
return 0;
}
else if(n==2) rr=a[0].d->Read(a[1].s.c_str());
else rr=a[0].d->Read(a[1].s.c_str(), k[2]==3?iint(a[2].v):1,
k[3]==3?iint(a[3].v):1, k[4]==3?iint(a[4].v):1);
- if(!rr) gr->SetWarn(mglWarnFile);
+ if(!rr) gr->SetWarn(mglWarnFile,"Read");
return 0;
}
void mglc_read(wchar_t out[1024], long n, mglArg *a, int k[10], const char *)
bool rr=true;
if(k[0]!=1 || k[1]!=2) return 1;
else rr=a[0].d->ReadMat(a[1].s.c_str(), k[2]==3?iint(a[2].v):2);
- if(!rr) gr->SetWarn(mglWarnFile);
+ if(!rr) gr->SetWarn(mglWarnFile,"ReadMat");
return 0;
}
void mglc_readmat(wchar_t out[1024], long , mglArg *a, int k[10], const char *)
int mgls_subplot(mglGraph *gr, long , mglArg *a, int k[10], const char *)
{
if(k[0]==3 && k[1]==3 && k[2]==3)
- gr->SubPlot(iint(a[0].v), iint(a[1].v), iint(a[2].v), k[3]==2?a[3].s.c_str():"<>_^", k[4]==3?a[3].v:0, k[5]==3?a[4].v:0);
+ gr->SubPlot(iint(a[0].v), iint(a[1].v), iint(a[2].v), k[3]==2?a[3].s.c_str():"<>_^", k[4]==3?a[4].v:0, k[5]==3?a[5].v:0);
else return 1;
return 0;
}
{
if(k[0]==1) gr->SetWarn(-1,a[0].d->PrintInfo());
else if(k[0]==2) gr->SetWarn(-1,a[0].s.c_str());
- else return 1;
+ else
+ { char buf[128]; sprintf(buf,"value = %g",a[0].v); gr->SetWarn(-1,buf); }
return 0;
}
void mglc_info(wchar_t out[1024], long , mglArg *a, int k[10], const char *)
{
if(k[0]==1) mglprintf(out,1024,L"gr->SetWarn(-1,%s.PrintInfo());", a[0].s.c_str());
if(k[0]==2) mglprintf(out,1024,L"gr->SetWarn(-1,\"%s\");",a[0].s.c_str());
+ else mglprintf(out,1024,L"gr->SetWarn(-1,\"value = %g\");",a[0].v);
}
//-----------------------------------------------------------------------------
int mgls_integrate(mglGraph *, long , mglArg *a, int k[10], const char *)
int mgls_chdir(mglGraph *gr, long , mglArg *a, int k[10], const char *)
{
if(k[0]==2)
- { int r=chdir(a[0].s.c_str()); if(r) gr->SetWarn(mglWarnFile); }
+ { int r=chdir(a[0].s.c_str()); if(r) gr->SetWarn(mglWarnFile,"chdir"); }
else return 1;
return 0;
}
if((k[0]==3 && k[1]==3 && k[2]==3 && k[3]==2) || (k[0]==3 && k[1]==3 && k[2]==2))
{
int i, j=k[2]==3?1:0, n = (k[j+3]==3?iint(a[j+3].v):0);
- float vv = k[2]==3 ? a[2].v:0;
+ mreal vv = k[2]==3 ? a[2].v:0;
fp = fopen(a[j+2].s.c_str(),"rt");
if(!fp)
{
a[0].s.c_str(), a[1].s.c_str()[0], iint(a[2].v));
}
//-----------------------------------------------------------------------------
+int mgls_datagrid(mglGraph *gr, long , mglArg *a, int k[10], const char *opt)
+{
+ if(k[0]==1 && k[1]==1 && k[2]==1 && k[3]==1)
+ gr->DataGrid(*(a[0].d), *(a[1].d), *(a[2].d), *(a[3].d), opt);
+ else return 1;
+ return 0;
+}
+void mglc_datagrid(wchar_t out[1024], long , mglArg *a, int k[10], const char *opt)
+{
+ if(k[0]==1 && k[1]==1 && k[2]==1 && k[3]==1)
+ mglprintf(out,1024,L"gr->DataGrid(%s, %s, %s, %s, \"%s\");",a[0].s.c_str(), a[1].s.c_str(), a[2].s.c_str(), a[3].s.c_str(),opt?opt:"");
+}
+//-----------------------------------------------------------------------------
int mgls_triangulate(mglGraph *, long , mglArg *a, int k[10], const char *)
{
if(k[0]==1 && k[1]==1 && k[2]==1 && k[3]==1)
- *(a[0].d) = mglTriangulation(*(a[1].d), *(a[2].d), *(a[3].d), k[4]==3?a[4].v:0);
+ *(a[0].d) = mglTriangulation(*(a[1].d), *(a[2].d), *(a[3].d));
else if(k[0]==1 && k[1]==1 && k[2]==1)
- *(a[0].d) = mglTriangulation(*(a[1].d), *(a[2].d), k[3]==3?a[3].v:0);
+ *(a[0].d) = mglTriangulation(*(a[1].d), *(a[2].d));
else return 1;
return 0;
}
void mglc_triangulate(wchar_t out[1024], long , mglArg *a, int k[10], const char *)
{
if(k[0]==1 && k[1]==1 && k[2]==1 && k[3]==1)
- mglprintf(out,1024,L"%s = mglTriangulation(%s, %s, %s, %g);",a[0].s.c_str(), a[1].s.c_str(), a[2].s.c_str(), a[3].s.c_str(), k[4]==3?a[4].v:0);
+ mglprintf(out,1024,L"%s = mglTriangulation(%s, %s, %s);",a[0].s.c_str(), a[1].s.c_str(), a[2].s.c_str(), a[3].s.c_str());
else if(k[0]==1 && k[1]==1 && k[2]==1)
- mglprintf(out,1024,L"%s = mglTriangulation(%s, %s, %g);",a[0].s.c_str(), a[1].s.c_str(), a[2].s.c_str(), k[3]==3?a[3].v:0);
+ mglprintf(out,1024,L"%s = mglTriangulation(%s, %s);",a[0].s.c_str(), a[1].s.c_str(), a[2].s.c_str());
}
//-----------------------------------------------------------------------------
mglCommand mgls_base_cmd[] = {
{"colorbar","Draw colorbar","colorbar ['fmt' pos]|Vdat ['fmt' pos]|'sch' pos x y w h|Vdat 'sch' pos x y w h", mgls_colorbar, mglc_colorbar,1},
{"column","Get data column filled by formula on column ids","column Res Dat 'eq'", mgls_column, mglc_column,4},
{"columnplot","Set position of plot inside cell of column", "columnplot num ind [d]", mgls_columnplot, mglc_columnplot,5},
- {"combine", "Direct multiplication of arrays", "combine Res Adat Bdat", mgls_combine, mglc_combine,3},
+ {"combine", "Direct multiplication of arrays", "combine Res Adat Bdat", mgls_combine, mglc_combine,4},
{"cone","Draw cone","cone x1 y1 z1 x2 y2 z2 r1 [r2 'fmt' edge]", mgls_cone, mglc_cone,1},
{"cones","Draw cones for 1D data","cones Ydat ['fmt' above]|Xdat Ydat ['fmt' above]|Xdat Ydat Zdat ['fmt' above]", mgls_cones, mglc_cones,0},
{"cont","Draw contour lines","cont Zdat ['fmt' num zpos]|Vdat Zdat ['fmt' zpos]|Xdat Ydat Zdat ['fmt' num zpos]|Vdat Xdat Ydat Zdat ['fmt' zpos]", mgls_cont, mglc_cont,0},
{"cumsum","Cumulative summation","cumsum Dat 'dir'", mgls_cumsum, mglc_cumsum,3},
{"curve","Draw curve","curve x1 y1 dx1 dy1 x2 y2 dx2 dy2 ['fmt']|x1 y1 z1 dx1 dy1 dz1 x2 y2 z2 dx2 dy2 dz2 ['fmt']", mgls_curve, mglc_curve,1},
{"cut","Setup plot points cutting","cut val|x1 y1 z1 x2 y2 z2|'cond'", mgls_cut, mglc_cut,2},
+ {"datagrid","Fill data by triangulated values","datagrid Var Xdat Ydat Zdat", mgls_datagrid, mglc_datagrid,3},
{"datas","Print list of data names in HDF file","datas 'fname'", mgls_datas, mglc_datas,3},
{"defchr","Define parameter as character","defchr $N val", 0, 0, 6},
{"define","Define constant or parameter","define $N sth | Var val", 0, 0, 6},
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
#include <time.h>
-#include <zlib.h>
#include <stdarg.h>
-#include <png.h>
#include "mgl2/canvas.h"
#include "mgl2/canvas_cf.h"
+#if MGL_HAVE_PNG
+#include <png.h>
+#endif
+
#if MGL_HAVE_JPEG
extern "C" {
#include <jpeglib.h>
//-----------------------------------------------------------------------------
int mgl_pnga_save(const char *fname, int w, int h, unsigned char **p)
{
+#if MGL_HAVE_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)
{
+#if MGL_HAVE_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)
char *f=new char[n+1]; memcpy(f,descr,n); f[n]=0;
mgl_write_frame(_GR_,s,f); delete []s; delete []f;}
//-----------------------------------------------------------------------------
+#ifdef WIN32
+#include <io.h>
+#include <direct.h>
+#endif
void mgl_show_image(HMGL gr, const char *viewer, int keep)
{
char fname[128], *cmd = new char [128];
mgl_write_png_solid(gr,fname,"MathGL ShowImage file");
if(!viewer || !viewer[0])
viewer = MGL_DEF_VIEWER;
- #ifdef WIN32
+#ifdef WIN32
if(keep)
{
sprintf(cmd,"%s %s &", viewer,fname);
sprintf(cmd,"del %s", fname);
}
else sprintf(cmd,"%s %s; del %s", viewer,fname,fname);
- #else
+#else
if(keep)
{
sprintf(cmd,"%s %s &", viewer,fname);
sprintf(cmd,"rm %s", fname);
}
else sprintf(cmd,"%s %s; rm %s", viewer,fname,fname);
- #endif
+#endif
if(system(cmd)==-1) printf("Error to call external viewer\n");
delete []cmd;
}
***************************************************************************/
#include "mgl2/canvas.h"
#include "mgl2/canvas_cf.h"
-#include <stdlib.h>
#include <time.h>
-#include <zlib.h>
+#include <algorithm>
+#include <vector>
#undef _GR_
#define _GR_ ((mglCanvas *)(*gr))
#define _Gr_ ((mglCanvas *)(gr))
void mgl_printf(void *fp, bool gz, const char *str, ...);
//-----------------------------------------------------------------------------
-char *mgl_get_dash(unsigned short d, float w)
+char *mgl_get_dash(unsigned short d, mreal w)
{
static char s[64],b[4];
if(d==0xffff) { strcpy(s,""); return s; }
return s;
}
//-----------------------------------------------------------------------------
-bool mgl_is_same(HMGL gr, const mglPrim &pr,float wp,mglColor cp,int st)
+bool mgl_is_same(HMGL gr, const mglPrim &pr,mreal wp,mglColor cp,int st)
{
if(abs(pr.type)!=1) return false;
if(pr.w>=1 && wp!=pr.w) return false;
return (cp==c);
}
//-----------------------------------------------------------------------------
-void put_line(HMGL gr, void *fp, bool gz, long i, float wp, mglColor cp,int st, const char *ifmt, const char *nfmt, bool neg, float fc)
+void put_line(HMGL gr, void *fp, bool gz, long i, mreal wp, mglColor cp,int st, const char *ifmt, const char *nfmt, bool neg, mreal fc)
{
- const mglPnt pp = gr->GetPnt(gr->GetPrm(i).n1);
- float x0=pp.x, y0=pp.y;
+ register long n1=gr->GetPrm(i).n1, n2=gr->GetPrm(i).n2;
+ if(n1<0 || n2<0) return;
+ const mglPnt &pp1 = gr->GetPnt(n1), &pp2 = gr->GetPnt(n2);
+ mreal x0=pp1.x, y0=pp1.y;
bool ok=true;
- register long k = i,j; // first point
- while(ok)
+ register long j; // first point
+ std::vector<long> ids;
+ while(ok) // try to find starting point
{
for(ok=false,j=i+1;j<gr->GetPrmNum();j++)
{
mglPrim &q = gr->GetPrm(j);
if(q.type>1) break;
- if(mgl_is_same(gr, q,wp,cp,st) && q.type==1) // previous point
+ if(mgl_is_same(gr, q,wp,cp,st) && q.type==1 && q.n1>=0 && q.n2>=0) // previous point
{
- const mglPnt p1 = gr->GetPnt(q.n1);
- const mglPnt p2 = gr->GetPnt(q.n2);
+ const mglPnt &p1 = gr->GetPnt(q.n1);
+ const mglPnt &p2 = gr->GetPnt(q.n2);
if(p2.x==x0 && p2.y==y0)
{
- k=j; ok=true; q.type = -2;
- x0 = p1.x; y0=p1.y;
+ ok = true; ids.push_back(q.n1);
+ x0 = p1.x; y0 = p1.y; q.type = -1;
}
else if(p1.x==x0 && p1.y==y0)
{
- k=j; ok=true; q.type = -2;
- x0 = p2.x; y0=p2.y;
+ ok = true; ids.push_back(q.n2);
+ x0 = p2.x; y0 = p2.y; q.type = -1;
}
}
}
}
- for(j=i;j<gr->GetPrmNum();j++)
+ std::reverse(ids.begin(),ids.end());
+ ids.push_back(n1); ids.push_back(n2);
+ x0 = pp2.x; y0 = pp2.y; ok = true;
+ while(ok) // try to find starting point
{
- mglPrim &q = gr->GetPrm(j);
- if(q.type==-2) q.type = 1;
- }
- mgl_printf(fp, gz, ifmt,fc*x0,(neg?_Gr_->GetHeight()-y0:y0)*fc); ok=true;
- long m=1;
- while(ok)
- {
- for(ok=false,j=i;j<gr->GetPrmNum();j++)
+ for(ok=false,j=i+1;j<gr->GetPrmNum();j++)
{
mglPrim &q = gr->GetPrm(j);
if(q.type>1) break;
- if(mgl_is_same(gr,q,wp,cp,st) && q.type==1)
+ if(mgl_is_same(gr, q,wp,cp,st) && q.type==1 && q.n1>=0 && q.n2>=0) // next point
{
- const mglPnt p1 = gr->GetPnt(q.n1);
- const mglPnt p2 = gr->GetPnt(q.n2);
- if(p1.x==x0 && p1.y==y0)
+ const mglPnt &p1 = gr->GetPnt(q.n1);
+ const mglPnt &p2 = gr->GetPnt(q.n2);
+ if(p2.x==x0 && p2.y==y0)
{
- k=j; q.type = -1; x0 = p2.x; y0=p2.y;
- mgl_printf(fp, gz, nfmt,fc*x0,(neg?_Gr_->GetHeight()-y0:y0)*fc);
- if(m>10) { m=0; mgl_printf(fp, gz, "\n"); }
- ok=true; m++;
+ ok = true; ids.push_back(q.n1);
+ x0 = p1.x; y0 = p1.y; q.type = -1;
}
- else if(p2.x==x0 && p2.y==y0)
+ else if(p1.x==x0 && p1.y==y0)
{
- k=j; q.type = -1; x0 = p1.x; y0=p1.y;
- mgl_printf(fp, gz, nfmt,fc*x0,(neg?_Gr_->GetHeight()-y0:y0)*fc);
- if(m>10) { m=0; mgl_printf(fp, gz, "\n"); }
- ok=true; m++;
+ ok = true; ids.push_back(q.n2);
+ x0 = p2.x; y0 = p2.y; q.type = -1;
}
}
}
}
+ for(j=0;j<ids.size();j++)
+ {
+ const mglPnt &p = gr->GetPnt(ids[j]);
+ x0 = p.x; y0 = p.y;
+ mgl_printf(fp, gz, j>0?nfmt:ifmt,fc*x0,(neg?_Gr_->GetHeight()-y0:y0)*fc);
+ }
}
//-----------------------------------------------------------------------------
//put_desc(fp,"%c%c%c_%04x {", "np %d %d mt %d %d ll %d %d ll cp fill\n",
// write definition for all glyphs
put_desc(gr,fp,gz,"/%c%c_%04x { np\n", "\t%d %d mt ", "%d %d ll ", "cp\n", "} def\n");
// write primitives
- float wp=-1;
+ mreal wp=-1;
mglColor cp;
int st=0;
char str[256]="";
if(q.type==0) // mark
{
- float x0 = p1.x,y0 = p1.y;
+ mreal x0 = p1.x,y0 = p1.y;
sprintf(str,"1 lw %.2g %.2g %.2g rgb ", cp.r,cp.g,cp.b);
wp=1;
if(q.s!=gr->mark_size()/gr->FontFactor())
}
else if(q.type==4) // glyph
{
- float ss = q.s/2, xx = p1.u, yy = p1.v, zz = p1.w;
+ mreal ss = q.s/2, xx = p1.u, yy = p1.v, zz = p1.w;
mgl_printf(fp, gz, "gsave\t%g %g translate %g %g scale %g rotate %s\n",
p1.x, p1.y, ss, ss, -q.w, str);
if(q.n3&8) // this is "line"
{
- float dy = 0.004,f=fabs(zz);
+ mreal dy = 0.004,f=fabs(zz);
mgl_printf(fp, gz, "np %g %g mt %g %g ll %g %g ll %g %g ll cp ",
xx,yy+dy, xx+f,yy+dy, xx+f,yy-dy, xx,yy-dy);
}
// currentColor -> inherit ???
mgl_printf(fp, gz, "<g fill=\"none\" stroke=\"none\" stroke-width=\"0.5\">\n");
// write primitives
- float wp=-1;
+ mreal wp=-1;
register long i;
int st=0;
mglColor cp;
const mglPnt p1=gr->GetPnt(q.n1);
if(q.type==0)
{
- float x=p1.x,y=p1.y,s=0.4*gr->FontFactor()*q.s;
+ mreal x=p1.x,y=hh-p1.y,s=0.4*gr->FontFactor()*q.s;
if(!strchr("xsSoO",q.n4)) s *= 1.1;
wp = 1;
if(strchr("SDVTLR",q.n4))
switch(q.n4)
{
case 'P':
- mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g M %g %g L %g %g M %g %g L %g %g L %g %g L %g %g L %g %g\"/>\n", x-s,y,x+s,y,x,y-s,x,y+s, x-s,y-s,x+s,y-s,x+s,y+s,x-s,y+s,x-s,y-s); break;
+ mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g M %g %g L %g %g M %g %g L %g %g L %g %g L %g %g L %g %g\"/>\n",
+ x-s,y,x+s,y,x,y-s,x,y+s, x-s,y-s,x+s,y-s,x+s,y+s,x-s,y+s,x-s,y-s); break;
case '+':
mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g M %g %g L %g %g\"/>\n", x-s,y,x+s,y,x,y-s,x,y+s); break;
case 'X':
- mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g M %g %g L %g %g M %g %g L %g %g L %g %g L %g %g L %g %g\"/>\n", x-s,y-s,x+s,y+s,x+s,y-s,x-s,y+s, x-s,y-s,x+s,y-s,x+s,y+s,x-s,y+s,x-s,y-s); break;
+ mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g M %g %g L %g %g M %g %g L %g %g L %g %g L %g %g L %g %g\"/>\n",
+ x-s,y-s,x+s,y+s,x+s,y-s,x-s,y+s, x-s,y-s,x+s,y-s,x+s,y+s,x-s,y+s,x-s,y-s); break;
case 'x':
mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g M %g %g L %g %g\"/>\n", x-s,y-s,x+s,y+s,x+s,y-s,x-s,y+s); break;
case 's':
mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g L %g %g L %g %gZ\"/>\n", x-s,y,x,y-s,x+s,y,x,y+s); break;
case '^':
case 'T':
- mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g L %g %gZ\"/>\n", x-s,y+s/2,x+s,y+s/2,x,y-s); break;
+ mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g L %g %gZ\"/>\n", x-s,y-s/2,x+s,y-s/2,x,y+s); break;
case 'v':
case 'V':
- mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g L %g %gZ\"/>\n", x-s,y-s/2,x+s,y-s/2,x,y+s); break;
+ mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g L %g %gZ\"/>\n", x-s,y+s/2,x+s,y+s/2,x,y-s); break;
case '<':
case 'L':
mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g L %g %gZ\"/>\n", x+s/2,y+s,x+s/2,y-s,x-s,y); break;
case 'R':
mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g L %g %gZ\"/>\n", x-s/2,y+s,x-s/2,y-s,x+s,y); break;
case 'Y':
- mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g L %g %g M %g %g L %g %g\"/>\n", x,y+s, x,y, x+s,y-s, x,y, x-s,y-s); break;
+ mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g L %g %g M %g %g L %g %g\"/>\n", x,y-s, x,y, x+s,y+s, x,y, x-s,y+s); break;
case 'C':
- mgl_printf(fp, gz, "<circle style=\"fill:#%02x%02x%02x\" cx=\"%g\" cy=\"%g\" r=\"0.15\"/>\n<circle cx=\"%g\" cy=\"%g\" r=\"%g\"/>\n", int(255*cp.r),int(255*cp.g),int(255*cp.b),x,y,x,y,s); break;
+ mgl_printf(fp, gz, "<circle style=\"fill:#%02x%02x%02x\" cx=\"%g\" cy=\"%g\" r=\"0.15\"/>\n<circle cx=\"%g\" cy=\"%g\" r=\"%g\"/>\n",
+ int(255*cp.r),int(255*cp.g),int(255*cp.b),x,y,x,y,s); break;
case 'o':
mgl_printf(fp, gz, "<circle cx=\"%g\" cy=\"%g\" r=\"%g\"/>\n", x,y,s); break;
case 'O':
- mgl_printf(fp, gz, "<circle style=\"fill:#%02x%02x%02x\" cx=\"%g\" cy=\"%g\" r=\"%g\"/>\n", int(255*cp.r),int(255*cp.g),int(255*cp.b),x,y,s); break;
+ mgl_printf(fp, gz, "<circle style=\"fill:#%02x%02x%02x\" cx=\"%g\" cy=\"%g\" r=\"%g\"/>\n",
+ int(255*cp.r),int(255*cp.g),int(255*cp.b),x,y,s); break;
case '*':
- mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g M %g %g L %g %g M %g %g L %g %g\"/>\n", x-s,y,x+s,y,x-0.6*s,y-0.8*s,x+0.6*s,y+0.8*s,x+0.6*s,y-0.8*s,x-0.6*s,y+0.8*s); break;
+ mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g M %g %g L %g %g M %g %g L %g %g\"/>\n",
+ x-s,y,x+s,y,x-0.6*s,y-0.8*s,x+0.6*s,y+0.8*s,x+0.6*s,y-0.8*s,x-0.6*s,y+0.8*s); break;
default:
- mgl_printf(fp, gz, "<circle style=\"fill:#%02x%02x%02x\" cx=\"%g\" cy=\"%g\" r=\"0.15\"/>\n", int(255*cp.r),int(255*cp.g),int(255*cp.b),x,y); break;
+ mgl_printf(fp, gz, "<circle style=\"fill:#%02x%02x%02x\" cx=\"%g\" cy=\"%g\" r=\"0.15\"/>\n",
+ int(255*cp.r),int(255*cp.g),int(255*cp.b),x,y); break;
}
mgl_printf(fp, gz, "</g>\n");
}
}
else if(q.type==4)
{
- float ss = q.s/2, xx = p1.u, yy = p1.v, zz = p1.w;
+ mreal ss = q.s/2, xx = p1.u, yy = p1.v, zz = p1.w;
if(q.n3&8) // this is "line"
{
mgl_printf(fp, gz, "<g transform=\"translate(%g,%g) scale(%.3g,%.3g) rotate(%g)\"", p1.x, hh-p1.y, ss, -ss, -q.w);
mgl_printf(fp, gz, " stroke=\"#%02x%02x%02x\">", int(255*cp.r),int(255*cp.g),int(255*cp.b));
else
mgl_printf(fp, gz, " fill=\"#%02x%02x%02x\">", int(255*cp.r),int(255*cp.g),int(255*cp.b));
- float dy = 0.004,f=fabs(zz);
+ mreal dy = 0.004,f=fabs(zz);
mgl_printf(fp, gz, "<path d=\"M %g %g L %g %g L %g %g L %g %g\"/></g>\n", xx,yy+dy, xx+f,yy+dy, xx+f,yy-dy, xx,yy-dy);
}
else
mgl_write_svg(_GR_,s,d); delete []s; delete []d; }
//-----------------------------------------------------------------------------
/// Color names easely parsed by LaTeX
-struct mglSVGName { const char *name; float r,g,b; };
+struct mglSVGName { const char *name; mreal r,g,b; };
mglSVGName mgl_names[]={{"AliceBlue",.94,.972,1},
{"Apricot", 0.984, 0.725, 0.51},
{"Aquamarine", 0, 0.71, 0.745},
const char *mglColorName(mglColor c) // return closest SVG color
{
register long i;
- register float d, dm=10;
+ register mreal d, dm=10;
const char *name="";
for(i=0;mgl_names[i].name[0];i++)
{
if(!fp) { gr->SetWarn(mglWarnOpen,fname); return; }
fprintf(fp, "%% Created by MathGL library\n%% Title: %s\n",descr?descr:fname);
fprintf(fp, "\\input{mglcolors.tex}\n\\begin{tikzpicture}\n");
- float ms=0.4*gr->mark_size()/100;
+ mreal ms=0.4*gr->mark_size()/100;
// write primitives
- float wp=-1;
+ mreal wp=-1;
register long i;
int st=0;
mglColor cp;
sprintf(cname,"mgl_%d",ii+6*(jj+6*kk));
// cname = mglColorName(cp);
const mglPnt p1=gr->GetPnt(q.n1);
- float x=p1.x/100,y=p1.y/100,s=0.4*gr->FontFactor()*q.s/100;
+ mreal x=p1.x/100,y=p1.y/100,s=0.4*gr->FontFactor()*q.s/100;
if(q.type==0)
{
if(!strchr("xsSoO",q.n4)) s *= 1.1;
else if(q.type==6) // text
{
const mglText &t = gr->GetPtx(q.n3);
- float ftet = mgl_isnan(p1.v)||mgl_isnan(p1.u) ? 0:-180*atan2(p1.v,p1.u)/M_PI;
+ mreal ftet = mgl_isnan(p1.v)||mgl_isnan(p1.u) ? 0:-180*atan2(p1.v,p1.u)/M_PI;
int f,a; mglGetStyle(t.stl.c_str(), &f, &a);
std::string ss=cname;
if((a&3)==2) ss.append(",west"); if((a&3)==0) ss.append(",east");
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdio.h>\r
#include <time.h>\r
-#include <zlib.h>\r
#include "mgl2/canvas.h"\r
#include "mgl2/canvas_cf.h"\r
#undef _GR_\r
}\r
}*/\r
//-----------------------------------------------------------------------------\r
-void mgl_obj_prim(const mglPrim &q, const mglPnt &p, FILE *fp, float size)\r
+void mgl_obj_prim(const mglPrim &q, const mglPnt &p, FILE *fp, mreal size)\r
{\r
- char type = q.n4; float ss=size*0.35;\r
+ char type = q.n4; mreal ss=size*0.35;\r
register long i=q.n1+1,j;\r
register long n1=q.n1+1,n2=q.n2+1,n3=q.n3+1,n4=q.n4+1;\r
switch(q.type)\r
char *d=new char[n+1]; memcpy(d,descr,n); d[n]=0;\r
mgl_write_off(_GR_,s,d,*colored); delete []s; delete []d; }\r
//-----------------------------------------------------------------------------\r
-void mgl_write_idtf(HMGL gr, const char *fname,const char *descr)\r
+void mgl_write_idtf(HMGL /*gr*/, const char */*fname*/,const char */*descr*/)\r
{ /*_Gr_->WriteIDTF(fname,descr);*/ } // TODO: Add idtf support later\r
void mgl_write_idtf_(uintptr_t *gr, const char *fname,const char *descr,int l,int n)\r
{ char *s=new char[l+1]; memcpy(s,fname,l); s[l]=0;\r
long n1,n2,n3,n4; ///< coordinates of corners\r
int type; ///< primitive type (0-point, 1-line, 2-trig, 3-quad, 4-glyph, 6-text)\r
int id; ///< object id\r
- float z; ///< z-position\r
- float s; ///< size (if applicable) or fscl\r
- float w; ///< width (if applicable) or ftet\r
- float p;\r
+ mreal z; ///< z-position\r
+ mreal s; ///< size (if applicable) or fscl\r
+ mreal w; ///< width (if applicable) or ftet\r
+ mreal p;\r
};*/\r
bool mglCanvas::ExportMGLD(const char *fname, const char *descr)\r
{\r
FILE *fp=fopen(fname,"wt");\r
if(!fp) return true;\r
// NOTE: I'll save Ptx. So prim type=6 is useless,and no LaTeX\r
- fprintf(fp,"MGLD %lu %lu %lu\n# %s\n", Pnt.size(), Prm.size(), Txt.size(), (descr && *descr) ? descr : fname);\r
+ fprintf(fp,"MGLD %lu %lu %lu\n# %s\n", (unsigned long)Pnt.size(), (unsigned long)Prm.size(), (unsigned long)Txt.size(), (descr && *descr) ? descr : fname);\r
register size_t i;\r
fprintf(fp,"# Vertexes: x y z c t ta u v w r g b a\n");\r
for(i=0;i<Pnt.size();i++)\r
if(!fgets(buf,512,fp)) *buf=0;\r
if(strncmp(buf,"MGLD",4)) { delete []buf; fclose(fp); return true; }\r
register size_t i;\r
- size_t n,m,l, npnt;\r
+ unsigned long n,m,l, npnt=0;\r
sscanf(buf+5,"%lu%lu%lu",&n,&m,&l);\r
if(n<=0 || m<=0 || l<=0) { delete []buf; fclose(fp); return true; }\r
if(!add) { Clf(); Txt.clear(); }\r
{ char *s=new char[l+1]; memcpy(s,fname,l); s[l]=0;\r
mgl_import_mgld(_GR_,s,*add); delete []s; }\r
//-----------------------------------------------------------------------------\r
-/*void mgl_xgl_prim(const mglPrim &q, const mglPnt &p, FILE *fp, float size)\r
+/*void mgl_xgl_prim(const mglPrim &q, const mglPnt &p, FILE *fp, mreal size)\r
{\r
- char type = q.n4; float ss=size*0.35;\r
+ char type = q.n4; mreal ss=size*0.35;\r
register long i=q.n1,j;\r
switch(q.type)\r
{\r
mgl_printf(fp, gz, "\n");\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_x3d_prim(const mglPrim &q, const mglPnt &p, const long *pnt, void *fp,bool gz, float size)\r
+void mgl_x3d_prim(const mglPrim &q, const mglPnt &p, const long *pnt, void *fp,bool gz, mreal size)\r
{\r
// <ProtoInstance name='EmissiveMaterial'/>\r
/* if(q.type==0) // mark\r
{\r
- float x0 = p1.x,y0 = p1.y;\r
+ mreal x0 = p1.x,y0 = p1.y;\r
sprintf(str,"1 lw %.2g %.2g %.2g rgb ", cp.r,cp.g,cp.b);\r
wp=1;\r
if(q.s!=gr->mark_size()/gr->FontFactor())\r
}\r
else if(q.type==4) // glyph\r
{\r
- float ss = q.s/2, xx = p1.u, yy = p1.v, zz = p1.w;\r
+ mreal ss = q.s/2, xx = p1.u, yy = p1.v, zz = p1.w;\r
mgl_printf(fp, gz, "gsave\t%g %g translate %g %g scale %g rotate %s\n",\r
p1.x, p1.y, ss, ss, -q.w, str);\r
if(q.n3&8) // this is "line"\r
{\r
- float dy = 0.004,f=fabs(zz);\r
+ mreal dy = 0.004,f=fabs(zz);\r
mgl_printf(fp, gz, "np %g %g mt %g %g ll %g %g ll %g %g ll cp ",\r
xx,yy+dy, xx+f,yy+dy, xx+f,yy-dy, xx,yy-dy);\r
}\r
***************************************************************************/\r
#include <ctype.h>\r
#include "mgl2/fit.h"\r
+#include "mgl2/prim.h"\r
#include "mgl2/eval.h"\r
#include "mgl2/data.h"\r
\r
int mglFitPnts=100; ///< Number of output points in fitting\r
char mglFitRes[1024]; ///< Last fitted formula\r
//-----------------------------------------------------------------------------\r
+void mgl_puts_fit(HMGL gr, mreal x, mreal y, mreal z, const char *pre, const char *font, mreal size)\r
+{\r
+ long n = strlen(mglFitRes)+(pre?strlen(pre):0)+1;\r
+ char *buf = new char[n];\r
+ if(pre) sprintf(buf,"%s%s",pre,mglFitRes);\r
+ else strcpy(buf,mglFitRes);\r
+ mgl_puts(gr,x,y,z,buf,font,size);\r
+ delete []buf;\r
+}\r
+void mgl_puts_fit_(uintptr_t* gr, mreal *x, mreal *y, mreal *z, const char *prefix, const char *font, mreal *size, int l, int n)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,prefix,l); s[l]=0;\r
+ char *d=new char[n+1]; memcpy(d,font,n); d[n]=0;\r
+ mgl_puts_fit(_GR_, *x,*y,*z, s, d, *size);\r
+ delete []s; delete []d;\r
+}\r
+//-----------------------------------------------------------------------------\r
/// Structure for keeping data and precompiled fitted formula\r
struct mglFitData\r
{\r
{\r
mglData *fit=new mglData;\r
long m = yy->GetNx();\r
- if(xx->GetNx()!=m) { gr->SetWarn(mglWarnDim,"Fit[S]"); return fit; }\r
- if(m<2) { gr->SetWarn(mglWarnLow,"Fit[S]"); return fit; }\r
+ long nn = long(0.5+gr->SaveState(opt));\r
+ if(xx->GetNx()!=m)\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return fit; }\r
+ if(m<2)\r
+ { gr->SetWarn(mglWarnLow,"Fit[S]"); return fit; }\r
if(ss->GetNx()*ss->GetNy()*ss->GetNz() != m*yy->GetNy()*yy->GetNz())\r
- { gr->SetWarn(mglWarnDim,"FitS"); return fit; }\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return fit; }\r
\r
- long nn = long(0.5+gr->SaveState(opt));\r
if(nn<mglFitPnts) nn = mglFitPnts;\r
mglData x(xx), y(yy), s(ss);\r
mglFitData fd;\r
{\r
mglData *fit=new mglData;\r
long m=zz->GetNx(),n=zz->GetNy();\r
- if(xx->GetNx()!=m) { gr->SetWarn(mglWarnDim,"Fit[S]"); return fit; }\r
+ long nn = long(0.5+gr->SaveState(opt));\r
+ if(xx->GetNx()!=m)\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return fit; }\r
if(ss->GetNx()*ss->GetNy()*ss->GetNz() != m*n*zz->GetNz())\r
- { gr->SetWarn(mglWarnDim,"FitS"); return fit; }\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return fit; }\r
if(yy->GetNx()!=n && (xx->GetNy()!=n || yy->GetNx()!=m || yy->GetNy()!=n))\r
- { gr->SetWarn(mglWarnDim); return fit; }\r
- if(m<2|| n<2) { gr->SetWarn(mglWarnLow,"Fit[S]"); return fit; }\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return fit; }\r
+ if(m<2|| n<2)\r
+ { gr->SetWarn(mglWarnLow,"Fit[S]"); return fit; }\r
\r
- long nn = long(0.5+gr->SaveState(opt));\r
if(nn<mglFitPnts) nn = mglFitPnts;\r
mglData x(m, n), y(m, n), z(zz), s(ss);\r
register long i,j;\r
register long i,j,k,i0;\r
long m=aa->GetNx(), n=aa->GetNy(), l=aa->GetNz();\r
i = n*m*l;\r
- if(m<2 || n<2 || l<2) { gr->SetWarn(mglWarnLow,"Fit[S]"); return fit; }\r
- if(ss->GetNx()*ss->GetNy()*ss->GetNz() != i) { gr->SetWarn(mglWarnDim,"FitS"); return fit; }\r
+ long nn = long(0.5+gr->SaveState(opt));\r
+ if(m<2 || n<2 || l<2)\r
+ { gr->SetWarn(mglWarnLow,"Fit[S]"); return fit; }\r
+ if(ss->GetNx()*ss->GetNy()*ss->GetNz() != i)\r
+ { gr->SetWarn(mglWarnDim,"Fit[S]"); return fit; }\r
bool both = xx->GetNx()*xx->GetNy()*xx->GetNz()==i && yy->GetNx()*yy->GetNy()*yy->GetNz()==i && zz->GetNx()*zz->GetNy()*zz->GetNz()==i;\r
if(!(both || (xx->GetNx()==m && yy->GetNx()==n && zz->GetNx()==l)))\r
{ gr->SetWarn(mglWarnDim,"Fit[S]"); return fit; }\r
\r
- long nn = long(0.5+gr->SaveState(opt));\r
if(nn<mglFitPnts) nn = mglFitPnts;\r
mglData x(aa), y(aa), z(aa), a(aa), s(ss);\r
for(i=0;i<m;i++) for(j=0;j<n;j++) for(k=0;k<l;k++) // ñîçäàåì ìàññèâ òî÷åê\r
{\r
long nn=a->GetNx()*a->GetNy()*a->GetNz();\r
if(nn!=x->GetNx()*x->GetNy()*x->GetNz())\r
- { gr->SetWarn(mglWarnDim); return (new mglData); }\r
+ { gr->SetWarn(mglWarnDim,"Hist"); return (new mglData); }\r
long n = long(0.5+gr->SaveState(opt));\r
if(n<mglFitPnts) n = mglFitPnts;\r
mglData *res = new mglData(n);\r
register long i,j1;\r
- for(i=0;i<nn;i++)\r
+\r
+ const mglData *dx = dynamic_cast<const mglData *>(x);\r
+ const mglData *da = dynamic_cast<const mglData *>(a);\r
+ mreal vx = n/(gr->Max.x-gr->Min.x);\r
+ if(dx && da) for(i=0;i<nn;i++)\r
+ {\r
+ j1 = long((dx->a[i]-gr->Min.x)*vx);\r
+ if(j1>=0 && j1<n) res->a[j1] += da->a[i];\r
+ }\r
+ else for(i=0;i<nn;i++)\r
{\r
- if(gr->Stop) { delete res; return 0; }\r
- j1 = long(n*(x->v(i)-gr->Min.x)/(gr->Max.x-gr->Min.x));\r
- if(j1>=0 && j1<n) res->a[j1] += a->v(i);\r
+ j1 = long((x->vthr(i)-gr->Min.x)*vx);\r
+ if(j1>=0 && j1<n) res->a[j1] += a->vthr(i);\r
}\r
gr->LoadState(); return res;\r
}\r
{\r
long nn=a->GetNx()*a->GetNy()*a->GetNz();\r
if(nn!=x->GetNx()*x->GetNy()*x->GetNz() || nn!=y->GetNx()*y->GetNy()*y->GetNz())\r
- { gr->SetWarn(mglWarnDim); return (new mglData); }\r
+ { gr->SetWarn(mglWarnDim,"Hist"); return (new mglData); }\r
long n = long(0.5+gr->SaveState(opt));\r
if(n<mglFitPnts) n = mglFitPnts;\r
mglData *res = new mglData(n, n);\r
register long i,j1,j2;\r
- for(i=0;i<nn;i++)\r
+ const mglData *dx = dynamic_cast<const mglData *>(x);\r
+ const mglData *dy = dynamic_cast<const mglData *>(y);\r
+ const mglData *da = dynamic_cast<const mglData *>(a);\r
+ mreal vx = n/(gr->Max.x-gr->Min.x);\r
+ mreal vy = n/(gr->Max.y-gr->Min.y);\r
+ if(dx && dy && da) for(i=0;i<nn;i++)\r
+ {\r
+ j1 = long((dx->a[i]-gr->Min.x)*vx);\r
+ j2 = long((dy->a[i]-gr->Min.y)*vy);\r
+ if(j1>=0 && j1<n && j2>=0 && j2<n) res->a[j1+n*j2] += da->a[i];\r
+ }\r
+ else for(i=0;i<nn;i++)\r
{\r
- if(gr->Stop) { delete res; return 0; }\r
- j1 = long(n*(x->v(i)-gr->Min.x)/(gr->Max.x-gr->Min.x));\r
- j2 = long(n*(y->v(i)-gr->Min.y)/(gr->Max.y-gr->Min.y));\r
- if(j1>=0 && j1<n && j2>=0 && j2<n)\r
- res->a[j1+n*j2] += a->v(i);\r
+ j1 = long((x->vthr(i)-gr->Min.x)*vx);\r
+ j2 = long((y->vthr(i)-gr->Min.y)*vy);\r
+ if(j1>=0 && j1<n && j2>=0 && j2<n) res->a[j1+n*j2] += a->vthr(i);\r
}\r
gr->LoadState(); return res;\r
}\r
{\r
long nn=a->GetNx()*a->GetNy()*a->GetNz();\r
if(nn!=x->GetNx()*x->GetNy()*x->GetNz() || nn!=y->GetNx()*y->GetNy()*y->GetNz() || nn!=z->GetNx()*z->GetNy()*z->GetNz())\r
- { gr->SetWarn(mglWarnDim); return (new mglData); }\r
+ { gr->SetWarn(mglWarnDim,"Hist"); return (new mglData); }\r
long n = long(0.5+gr->SaveState(opt));\r
if(n<mglFitPnts) n = mglFitPnts;\r
mglData *res = new mglData(n, n, n);\r
register long i,j1,j2,j3;\r
- for(i=0;i<nn;i++)\r
+ const mglData *dx = dynamic_cast<const mglData *>(x);\r
+ const mglData *dy = dynamic_cast<const mglData *>(y);\r
+ const mglData *dz = dynamic_cast<const mglData *>(z);\r
+ const mglData *da = dynamic_cast<const mglData *>(a);\r
+ mreal vx = n/(gr->Max.x-gr->Min.x), vy = n/(gr->Max.y-gr->Min.y), vz = n/(gr->Max.z-gr->Min.z);\r
+ if(dx && dy && dz && da) for(i=0;i<nn;i++)\r
+ {\r
+ j1 = long((dx->a[i]-gr->Min.x)*vx);\r
+ j2 = long((dy->a[i]-gr->Min.y)*vy);\r
+ j3 = long((dz->a[i]-gr->Min.z)*vz);\r
+ if(j1>=0 && j1<n && j2>=0 && j2<n && j3>=0 && j3<n)\r
+ res->a[j1+n*(j2+n*j3)] += da->a[i];\r
+ }\r
+ else for(i=0;i<nn;i++)\r
{\r
- if(gr->Stop) { delete res; return 0; }\r
- j1 = long(n*(x->v(i)-gr->Min.x)/(gr->Max.x-gr->Min.x));\r
- j2 = long(n*(y->v(i)-gr->Min.y)/(gr->Max.y-gr->Min.y));\r
- j3 = long(n*(z->v(i)-gr->Min.z)/(gr->Max.z-gr->Min.z));\r
+ if(gr->Stop) { res->Create(1,1,1); return res; }\r
+ j1 = long((x->vthr(i)-gr->Min.x)*vx);\r
+ j2 = long((y->vthr(i)-gr->Min.y)*vy);\r
+ j3 = long((z->vthr(i)-gr->Min.z)*vz);\r
if(j1>=0 && j1<n && j2>=0 && j2<n && j3>=0 && j3<n)\r
- res->a[j1+n*(j2+n*j3)] += a->v(i);\r
+ res->a[j1+n*(j2+n*j3)] += a->vthr(i);\r
}\r
gr->LoadState(); return res;\r
}\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdlib.h>\r
#include <locale.h>\r
#include <ctype.h>\r
#include <wctype.h>\r
-#include <zlib.h>\r
\r
-#ifdef WIN32\r
-#include <windows.h>\r
-#else\r
-#include <wchar.h>\r
-#endif\r
+// #ifdef WIN32\r
+// #include <windows.h>\r
+// #else\r
+// #include <wchar.h>\r
+// #endif\r
\r
#include "mgl2/base.h"\r
#include "mgl2/font.h"\r
//-----------------------------------------------------------------------------\r
float mglFont::Puts(const wchar_t *str,int font,int align, float col) const\r
{\r
- if(numg==0) return 0;\r
+ if(numg==0 || !str || *str==0) return 0;\r
float ww=0,w=0,h = (align&4) ? 500./fact[0] : 0;\r
size_t size = wcslen(str)+1,i,num=0;\r
if(parse)\r
//-----------------------------------------------------------------------------\r
float mglFont::Width(const wchar_t *str,int font) const\r
{\r
- if(numg==0) return 0;\r
+ if(numg==0 || !str || *str==0) return 0;\r
float ww=0,w=0;\r
unsigned size = wcslen(str)+1,i;\r
if(parse)\r
void mglFont::Convert(const wchar_t *str, unsigned *res) const\r
{\r
register unsigned r,i,j,k,i0;\r
- wchar_t s[128], ch; // TeX command and current char\r
+ wchar_t s[128]=L"", ch; // TeX command and current char\r
for(i=j=0;str[i];i++)\r
{\r
ch = str[i];\r
parse = true; numg=0; gr=0;\r
// if(this==&mglDefFont) Load(name, path); else Copy(&mglDefFont);\r
if(this!=&mglDefFont) Copy(&mglDefFont);\r
- if(this==&mglDefFont && (!name || name[0]==0)) Load(MGL_DEF_FONT_NAME,0);\r
- else if(name && name[0]) Load(name, path);\r
+ else if(name && *name) Load(name, path);\r
+ else Load(MGL_DEF_FONT_NAME,0);\r
}\r
mglFont::~mglFont() { Clear(); }\r
void mglFont::Restore() { Copy(&mglDefFont); }\r
if(numg)\r
{\r
delete []id; free(Buf); numg = 0;\r
- delete []width[0]; delete []width[1]; delete []width[2]; delete []width[3];\r
- delete []tr[0]; delete []tr[1]; delete []tr[2]; delete []tr[3];\r
- delete []ln[0]; delete []ln[1]; delete []ln[2]; delete []ln[3];\r
- delete []numt[0]; delete []numt[1]; delete []numt[2]; delete []numt[3];\r
- delete []numl[0]; delete []numl[1]; delete []numl[2]; delete []numl[3];\r
+ delete [](width[0]); delete [](width[1]); delete [](width[2]); delete [](width[3]);\r
+ delete [](tr[0]); delete [](tr[1]); delete [](tr[2]); delete [](tr[3]);\r
+ delete [](ln[0]); delete [](ln[1]); delete [](ln[2]); delete [](ln[3]);\r
+ delete [](numt[0]); delete [](numt[1]); delete [](numt[2]); delete [](numt[3]);\r
+ delete [](numl[0]); delete [](numl[1]); delete [](numl[2]); delete [](numl[3]);\r
}\r
}\r
//-----------------------------------------------------------------------------\r
glEnableClientState(GL_COLOR_ARRAY);\r
\r
int pdef=PDef;\r
- float ss=pPos, ww=PenWidth;\r
+ mreal ss=pPos, ww=PenWidth;\r
mglPrim p;\r
for(unsigned long i=0;i<Prm.size();i++)\r
{\r
return mglCanvas::Alpha(enable);\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvasGL::AddLight(int n,mglPoint r,mglPoint d,char cc, float br,float /*ap*/)\r
+void mglCanvasGL::AddLight(int n,mglPoint r,mglPoint d,char cc, mreal br,mreal /*ap*/)\r
{\r
mglColor c(cc);\r
mglColor AmbLight = mglColor(AmbBr,AmbBr,AmbBr);\r
GL_LIGHT5,GL_LIGHT6,GL_LIGHT7};\r
float amb[4], pos[4],dif[4],dir[4];\r
bool inf = mgl_isnan(r.x);\r
- if(n<0 || n>7) { SetWarn(mglWarnLId); return; }\r
+ if(n<0 || n>7) { SetWarn(mglWarnLId,"AddLight"); return; }\r
if(c.Valid())\r
{\r
DifLight = c*br;\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvasGL::View(float TetX,float TetY,float TetZ)\r
+void mglCanvasGL::View(mreal TetX,mreal TetY,mreal TetZ)\r
{\r
glMatrixMode(GL_PROJECTION);//GL_PROJECTION GL_VIEWPORT GL_MODELVIEW\r
glRotated(TetX,1.,0.,0.);\r
glRotated(TetZ,0.,0.,1.);\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvasGL::Fog(float d, float)\r
+void mglCanvasGL::Fog(mreal d, mreal)\r
{\r
if(d>0) // TODO: Check fog to OpenGL mode\r
{\r
- float back[4]={BDef[0]/255.,BDef[1]/255.,BDef[2]/255.,BDef[3]/255.};\r
+ float back[4]={BDef[0]/255.f,BDef[1]/255.f,BDef[2]/255.f,BDef[3]/255.f};\r
glFogf(GL_FOG_MODE,GL_EXP);\r
glFogf(GL_FOG_DENSITY,5*d);\r
glFogfv(GL_FOG_COLOR,back);\r
glTranslated(-0.5,-0.5,-0.5);\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvasGL::set_pen(unsigned style,float width)\r
+void mglCanvasGL::set_pen(unsigned style,mreal width)\r
{\r
if(style==0) return;\r
if(style!=0xffff)\r
* other.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 *
- * 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. *
- ***************************************************************************/
+ * 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 "mgl2/other.h"\r
#include "mgl2/surf.h"\r
#include "mgl2/cont.h"\r
-#include "mgl2/eval.h"
-#include "mgl2/data.h"
-#include <stdlib.h>
+#include "mgl2/eval.h"\r
+#include "mgl2/data.h"\r
+//-----------------------------------------------------------------------------\r
+//\r
+// DensX, DensY, DensZ series\r
+//\r
//-----------------------------------------------------------------------------\r
-//
-// DensX, DensY, DensZ series
-//
-//-----------------------------------------------------------------------------
-void mgl_dens_x(HMGL gr, HCDT a, const char *sch, float sv, const char *opt)
-{
- register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();
- if(mgl_isnan(sv)) sv = gr->GetOrgX('x');
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"DensX"); return; }
- if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"DensX"); return; }
- mglData xx,yy,zz,aa;
+void mgl_dens_x(HMGL gr, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
+ if(mgl_isnan(sv)) sv = gr->GetOrgX('x');\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"DensX"); return; }\r
+ if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"DensX"); return; }\r
+ mglData xx,yy,zz,aa;\r
gr->SaveState(opt);\r
-
- if(l>1)
- {
- aa.Create(m,l); xx.Create(m,l); yy.Create(m,l); zz.Create(m,l);
- float d = (n-1)*(sv - gr->Min.x)/(gr->Max.x - gr->Min.x);
- k = long(d); d = d - k;
- if(k>n-2) { k=n-2; d=1; }
- if(k<0) { k=0; d=0; }
- for(j=0;j<l;j++) for(i=0;i<m;i++)
- aa.a[i+m*j] = a->v(k,i,j)*(1-d) + d*a->v(k+1,i,j);
- a = &aa;
- }
- else
- { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }
- xx.Fill(sv, sv);
- yy.Fill(gr->Min.y, gr->Max.y,'x');
- zz.Fill(gr->Min.z, gr->Max.z,'y');
- mgl_surfc_xy(gr,&xx,&yy,&zz,a,sch,0);
-}
-//-----------------------------------------------------------------------------
-void mgl_dens_y(HMGL gr, HCDT a, const char *sch, float sv, const char *opt)
-{
- register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();
- if(mgl_isnan(sv)) sv = gr->GetOrgX('x');
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"DensY"); return; }
- if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"DensY"); return; }
- mglData xx,yy,zz,aa;
+\r
+ if(l>1)\r
+ {\r
+ aa.Create(m,l); xx.Create(m,l); yy.Create(m,l); zz.Create(m,l);\r
+ mreal d = (n-1)*(sv - gr->Min.x)/(gr->Max.x - gr->Min.x);\r
+ k = long(d); d = d - k;\r
+ if(k>n-2) { k=n-2; d=1; }\r
+ if(k<0) { k=0; d=0; }\r
+ const mglData *ma=dynamic_cast<const mglData *>(a);\r
+ if(ma) for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = ma->a[k+n*(i+m*j)]*(1-d) + d*ma->a[k+1+n*(i+m*j)];\r
+ else for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = a->v(k,i,j)*(1-d) + d*a->v(k+1,i,j);\r
+ a = &aa;\r
+ }\r
+ else\r
+ { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }\r
+ xx.Fill(sv, sv);\r
+ yy.Fill(gr->Min.y, gr->Max.y,'x');\r
+ zz.Fill(gr->Min.z, gr->Max.z,'y');\r
+ mgl_surfc_xy(gr,&xx,&yy,&zz,a,sch,0);\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_dens_y(HMGL gr, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
+ if(mgl_isnan(sv)) sv = gr->GetOrgX('x');\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"DensY"); return; }\r
+ if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"DensY"); return; }\r
+ mglData xx,yy,zz,aa;\r
gr->SaveState(opt);\r
-
- if(l>1)
- {
- aa.Create(n,l); xx.Create(n,l); yy.Create(n,l); zz.Create(n,l);
- float d = (m-1)*(sv - gr->Min.y)/(gr->Max.y - gr->Min.y);
- k = long(d); d = d - k;
- if(k>m-2) { k=m-2; d=1; }
- if(k<0) { k=0; d=0; }
- for(j=0;j<l;j++) for(i=0;i<n;i++)
- aa.a[i+n*j] = a->v(i,k,j)*(1-d) + d*a->v(i,k+1,j);
- a = &aa;
- }
- else
- { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }
- yy.Fill(sv, sv);
- xx.Fill(gr->Min.x, gr->Max.x,'x');
- zz.Fill(gr->Min.z, gr->Max.z,'y');
- mgl_surfc_xy(gr,&xx,&yy,&zz,a,sch,0);
-}
-//-----------------------------------------------------------------------------
-void mgl_dens_z(HMGL gr, HCDT a, const char *sch, float sv, const char *opt)
-{
- register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();
- if(mgl_isnan(sv)) sv = gr->GetOrgX('x');
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"DensZ"); return; }
- if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"DensZ"); return; }
- mglData xx,yy,zz,aa;
+\r
+ if(l>1)\r
+ {\r
+ aa.Create(n,l); xx.Create(n,l); yy.Create(n,l); zz.Create(n,l);\r
+ mreal d = (m-1)*(sv - gr->Min.y)/(gr->Max.y - gr->Min.y);\r
+ k = long(d); d = d - k;\r
+ if(k>m-2) { k=m-2; d=1; }\r
+ if(k<0) { k=0; d=0; }\r
+ const mglData *ma=dynamic_cast<const mglData *>(a);\r
+ if(ma) for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = ma->a[k+n*(i+m*j)]*(1-d) + d*ma->a[k+n+n*(i+m*j)];\r
+ else for(j=0;j<l;j++) for(i=0;i<n;i++)\r
+ aa.a[i+n*j] = a->v(i,k,j)*(1-d) + d*a->v(i,k+1,j);\r
+ a = &aa;\r
+ }\r
+ else\r
+ { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }\r
+ yy.Fill(sv, sv);\r
+ xx.Fill(gr->Min.x, gr->Max.x,'x');\r
+ zz.Fill(gr->Min.z, gr->Max.z,'y');\r
+ mgl_surfc_xy(gr,&xx,&yy,&zz,a,sch,0);\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_dens_z(HMGL gr, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
+ if(mgl_isnan(sv)) sv = gr->GetOrgX('x');\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"DensZ"); return; }\r
+ if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"DensZ"); return; }\r
+ mglData xx,yy,zz,aa;\r
gr->SaveState(opt);\r
-
- xx.Create(n,m); yy.Create(n,m); zz.Create(n,m);
- if(l>1)
- {
- aa.Create(n,m);
- float d = (l-1)*(sv - gr->Min.z)/(gr->Max.z - gr->Min.z);
- k = long(d); d = d - k;
- if(k>l-2) { k=l-2; d=1; }
- if(k<0) { k=0; d=0; }
- for(j=0;j<m;j++) for(i=0;i<n;i++)
- aa.a[i+n*j] = a->v(i,j,k)*(1-d) + d*a->v(i,j,k+1);
- a = &aa;
- }
- zz.Fill(sv, sv);
- yy.Fill(gr->Min.y, gr->Max.y,'y');
- xx.Fill(gr->Min.x, gr->Max.x,'x');
- mgl_surfc_xy(gr,&xx,&yy,&zz,a,sch,0);
-}
-//-----------------------------------------------------------------------------
-void mgl_dens_x_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+\r
+ xx.Create(n,m); yy.Create(n,m); zz.Create(n,m);\r
+ if(l>1)\r
+ {\r
+ aa.Create(n,m);\r
+ mreal d = (l-1)*(sv - gr->Min.z)/(gr->Max.z - gr->Min.z);\r
+ k = long(d); d = d - k;\r
+ if(k>l-2) { k=l-2; d=1; }\r
+ if(k<0) { k=0; d=0; }\r
+ const mglData *ma=dynamic_cast<const mglData *>(a);\r
+ if(ma) for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = ma->a[k+n*(i+m*j)]*(1-d) + d*ma->a[k+n*m+n*(i+m*j)];\r
+ else for(j=0;j<m;j++) for(i=0;i<n;i++)\r
+ aa.a[i+n*j] = a->v(i,j,k)*(1-d) + d*a->v(i,j,k+1);\r
+ a = &aa;\r
+ }\r
+ zz.Fill(sv, sv);\r
+ yy.Fill(gr->Min.y, gr->Max.y,'y');\r
+ xx.Fill(gr->Min.x, gr->Max.x,'x');\r
+ mgl_surfc_xy(gr,&xx,&yy,&zz,a,sch,0);\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_dens_x_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_dens_x(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }
-//-----------------------------------------------------------------------------
-void mgl_dens_y_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{
- char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_dens_x(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+//-----------------------------------------------------------------------------\r
+void mgl_dens_y_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_dens_y(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }
-//-----------------------------------------------------------------------------
-void mgl_dens_z_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{
- char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_dens_y(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+//-----------------------------------------------------------------------------\r
+void mgl_dens_z_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{\r
+ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_dens_z(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }
-//-----------------------------------------------------------------------------
-//
-// ContX, ContY, ContZ series
-//
-//-----------------------------------------------------------------------------
-void mgl_cont_gen(HMGL gr, float val, HCDT a, HCDT x, HCDT y, HCDT z, float c, int text,long ak);
-void mgl_cont_x_val(HMGL gr, HCDT v, HCDT a, const char *sch, float sv, const char *opt)
-{
- register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();
- if(mgl_isnan(sv)) sv = gr->GetOrgX('x');
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContX"); return; }
- if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContX"); return; }
+ mgl_dens_z(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+//-----------------------------------------------------------------------------\r
+//\r
+// ContX, ContY, ContZ series\r
+//\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_gen(HMGL gr, mreal val, HCDT a, HCDT x, HCDT y, HCDT z, mreal c, int text,long ak);\r
+void mgl_cont_x_val(HMGL gr, HCDT v, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
+ if(mgl_isnan(sv)) sv = gr->GetOrgX('x');\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContX"); return; }\r
+ if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContX"); return; }\r
gr->SaveState(opt);\r
- static int cgid=1; gr->StartGroup("ContX",cgid++);
- mglData xx,yy,zz,aa;
-
- bool text=(sch && strchr(sch,'t'));
- long ss=gr->AddTexture(sch);
- gr->SetPenPal(sch);
-
- if(l>1)
- {
- aa.Create(m,l); xx.Create(m,l); yy.Create(m,l); zz.Create(m,l);
- float d = (n-1)*(sv - gr->Min.x)/(gr->Max.x - gr->Min.x);
- k = long(d); d = d - k;
- if(k>n-2) { k=n-2; d=1; }
- if(k<0) { k=0; d=0; }
- for(j=0;j<l;j++) for(i=0;i<m;i++)
- aa.a[i+m*j] = a->v(k,i,j)*(1-d) + d*a->v(k+1,i,j);
- a = &aa;
- }
- else
- { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }
- xx.Fill(sv, sv);
- yy.Fill(gr->Min.y, gr->Max.y,'x');
- zz.Fill(gr->Min.z, gr->Max.z,'y');
- for(i=0;i<v->GetNx();i++)
- {
- register float v0 = v->v(i);
- mgl_cont_gen(gr,v0,a,&xx,&yy,&zz,gr->GetC(ss,v0),text,0);
- }
- gr->EndGroup();
-}
-//-----------------------------------------------------------------------------
-void mgl_cont_y_val(HMGL gr, HCDT v, HCDT a, const char *sch, float sv, const char *opt)
-{
- register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();
- if(mgl_isnan(sv)) sv = gr->GetOrgX('x');
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContY"); return; }
- if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContY"); return; }
+ static int cgid=1; gr->StartGroup("ContX",cgid++);\r
+ mglData xx,yy,zz,aa;\r
+\r
+ bool text=(sch && strchr(sch,'t'));\r
+ long ss=gr->AddTexture(sch);\r
+ gr->SetPenPal(sch);\r
+\r
+ if(l>1)\r
+ {\r
+ aa.Create(m,l); xx.Create(m,l); yy.Create(m,l); zz.Create(m,l);\r
+ mreal d = (n-1)*(sv - gr->Min.x)/(gr->Max.x - gr->Min.x);\r
+ k = long(d); d = d - k;\r
+ if(k>n-2) { k=n-2; d=1; }\r
+ if(k<0) { k=0; d=0; }\r
+ const mglData *ma=dynamic_cast<const mglData *>(a);\r
+ if(ma) for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = ma->a[k+n*(i+m*j)]*(1-d) + d*ma->a[k+1+n*(i+m*j)];\r
+ else for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = a->v(k,i,j)*(1-d) + d*a->v(k+1,i,j);\r
+ a = &aa;\r
+ }\r
+ else\r
+ { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }\r
+ xx.Fill(sv, sv);\r
+ yy.Fill(gr->Min.y, gr->Max.y,'x');\r
+ zz.Fill(gr->Min.z, gr->Max.z,'y');\r
+ for(i=0;i<v->GetNx();i++)\r
+ {\r
+ register mreal v0 = v->v(i);\r
+ mgl_cont_gen(gr,v0,a,&xx,&yy,&zz,gr->GetC(ss,v0),text,0);\r
+ }\r
+ gr->EndGroup();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_y_val(HMGL gr, HCDT v, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
+ if(mgl_isnan(sv)) sv = gr->GetOrgX('x');\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContY"); return; }\r
+ if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContY"); return; }\r
gr->SaveState(opt);\r
- static int cgid=1; gr->StartGroup("ContY",cgid++);
- mglData xx,yy,zz,aa;
-
- bool text=(sch && strchr(sch,'t'));
- long ss=gr->AddTexture(sch);
- gr->SetPenPal(sch);
-
- if(l>1)
- {
- aa.Create(n,l); xx.Create(n,l); yy.Create(n,l); zz.Create(n,l);
- float d = (m-1)*(sv - gr->Min.y)/(gr->Max.y - gr->Min.y);
- k = long(d); d = d - k;
- if(k>m-2) { k=m-2; d=1; }
- if(k<0) { k=0; d=0; }
- for(j=0;j<l;j++) for(i=0;i<n;i++)
- aa.a[i+n*j] = a->v(i,k,j)*(1-d) + d*a->v(i,k+1,j);
- a = &aa;
- }
- else
- { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }
- yy.Fill(sv, sv);
- xx.Fill(gr->Min.x, gr->Max.x,'x');
- zz.Fill(gr->Min.z, gr->Max.z,'y');
- for(i=0;i<v->GetNx();i++)
- {
- register float v0 = v->v(i);
- mgl_cont_gen(gr,v0,a,&xx,&yy,&zz,gr->GetC(ss,v0),text,0);
- }
- gr->EndGroup();
-}
-//-----------------------------------------------------------------------------
-void mgl_cont_z_val(HMGL gr, HCDT v, HCDT a, const char *sch, float sv, const char *opt)
-{
- register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();
- if(mgl_isnan(sv)) sv = gr->GetOrgX('x');
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContZ"); return; }
- if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContZ"); return; }
+ static int cgid=1; gr->StartGroup("ContY",cgid++);\r
+ mglData xx,yy,zz,aa;\r
+\r
+ bool text=(sch && strchr(sch,'t'));\r
+ long ss=gr->AddTexture(sch);\r
+ gr->SetPenPal(sch);\r
+\r
+ if(l>1)\r
+ {\r
+ aa.Create(n,l); xx.Create(n,l); yy.Create(n,l); zz.Create(n,l);\r
+ mreal d = (m-1)*(sv - gr->Min.y)/(gr->Max.y - gr->Min.y);\r
+ k = long(d); d = d - k;\r
+ if(k>m-2) { k=m-2; d=1; }\r
+ if(k<0) { k=0; d=0; }\r
+ const mglData *ma=dynamic_cast<const mglData *>(a);\r
+ if(ma) for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = ma->a[k+n*(i+m*j)]*(1-d) + d*ma->a[k+n+n*(i+m*j)];\r
+ else for(j=0;j<l;j++) for(i=0;i<n;i++)\r
+ aa.a[i+n*j] = a->v(i,k,j)*(1-d) + d*a->v(i,k+1,j);\r
+ a = &aa;\r
+ }\r
+ else\r
+ { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }\r
+ yy.Fill(sv, sv);\r
+ xx.Fill(gr->Min.x, gr->Max.x,'x');\r
+ zz.Fill(gr->Min.z, gr->Max.z,'y');\r
+ for(i=0;i<v->GetNx();i++)\r
+ {\r
+ register mreal v0 = v->v(i);\r
+ mgl_cont_gen(gr,v0,a,&xx,&yy,&zz,gr->GetC(ss,v0),text,0);\r
+ }\r
+ gr->EndGroup();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_z_val(HMGL gr, HCDT v, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
+ if(mgl_isnan(sv)) sv = gr->GetOrgX('x');\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContZ"); return; }\r
+ if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContZ"); return; }\r
gr->SaveState(opt);\r
- static int cgid=1; gr->StartGroup("ContZ",cgid++);
- mglData xx,yy,zz,aa;
-
- bool text=(sch && strchr(sch,'t'));
- long ss=gr->AddTexture(sch);
- gr->SetPenPal(sch);
-
- xx.Create(n,m); yy.Create(n,m); zz.Create(n,m);
- if(l>1)
- {
- aa.Create(n,m);
- float d = (l-1)*(sv - gr->Min.z)/(gr->Max.z - gr->Min.z);
- k = long(d); d = d - k;
- if(k>l-2) { k=l-2; d=1; }
- if(k<0) { k=0; d=0; }
- for(j=0;j<m;j++) for(i=0;i<n;i++)
- aa.a[i+n*j] = a->v(i,j,k)*(1-d) + d*a->v(i,j,k+1);
- a = &aa;
- }
- zz.Fill(sv, sv);
- yy.Fill(gr->Min.y, gr->Max.y,'y');
- xx.Fill(gr->Min.x, gr->Max.x,'x');
- for(i=0;i<v->GetNx();i++)
- {
- register float v0 = v->v(i);
- mgl_cont_gen(gr,v0,a,&xx,&yy,&zz,gr->GetC(ss,v0),text,0);
- }
- gr->EndGroup();
-}
-//-----------------------------------------------------------------------------
-void mgl_cont_x(HMGL gr, HCDT a, const char *sch, float sv, const char *opt)
-{
- float r = gr->SaveState(opt);
- long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);
- mglData v(Num);
- for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(Num+1);
- mgl_cont_x_val(gr,&v,a,sch,sv,0);
-}
-//-----------------------------------------------------------------------------
-void mgl_cont_y(HMGL gr, HCDT a, const char *sch, float sv, const char *opt)
-{
- float r = gr->SaveState(opt);
- long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);
- mglData v(Num);
- for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(Num+1);
- mgl_cont_y_val(gr,&v,a,sch,sv,0);
-}
-//-----------------------------------------------------------------------------
-void mgl_cont_z(HMGL gr, HCDT a, const char *sch, float sv, const char *opt)
-{
- float r = gr->SaveState(opt);
- long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);
- mglData v(Num);
- for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*float(i+1)/(Num+1);
- mgl_cont_z_val(gr,&v,a,sch,sv,0);
-}
-//-----------------------------------------------------------------------------
-void mgl_cont_x_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ static int cgid=1; gr->StartGroup("ContZ",cgid++);\r
+ mglData xx,yy,zz,aa;\r
+\r
+ bool text=(sch && strchr(sch,'t'));\r
+ long ss=gr->AddTexture(sch);\r
+ gr->SetPenPal(sch);\r
+\r
+ xx.Create(n,m); yy.Create(n,m); zz.Create(n,m);\r
+ if(l>1)\r
+ {\r
+ aa.Create(n,m);\r
+ mreal d = (l-1)*(sv - gr->Min.z)/(gr->Max.z - gr->Min.z);\r
+ k = long(d); d = d - k;\r
+ if(k>l-2) { k=l-2; d=1; }\r
+ if(k<0) { k=0; d=0; }\r
+ const mglData *ma=dynamic_cast<const mglData *>(a);\r
+ if(ma) for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = ma->a[k+n*(i+m*j)]*(1-d) + d*ma->a[k+n*m+n*(i+m*j)];\r
+ else for(j=0;j<m;j++) for(i=0;i<n;i++)\r
+ aa.a[i+n*j] = a->v(i,j,k)*(1-d) + d*a->v(i,j,k+1);\r
+ a = &aa;\r
+ }\r
+ zz.Fill(sv, sv);\r
+ yy.Fill(gr->Min.y, gr->Max.y,'y');\r
+ xx.Fill(gr->Min.x, gr->Max.x,'x');\r
+ for(i=0;i<v->GetNx();i++)\r
+ {\r
+ register mreal v0 = v->v(i);\r
+ mgl_cont_gen(gr,v0,a,&xx,&yy,&zz,gr->GetC(ss,v0),text,0);\r
+ }\r
+ gr->EndGroup();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_x(HMGL gr, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ mreal r = gr->SaveState(opt);\r
+ long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);\r
+ mglData v(Num);\r
+ for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
+ mgl_cont_x_val(gr,&v,a,sch,sv,0);\r
+ gr->LoadState();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_y(HMGL gr, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ mreal r = gr->SaveState(opt);\r
+ long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);\r
+ mglData v(Num);\r
+ for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
+ mgl_cont_y_val(gr,&v,a,sch,sv,0);\r
+ gr->LoadState();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_z(HMGL gr, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ mreal r = gr->SaveState(opt);\r
+ long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);\r
+ mglData v(Num);\r
+ for(long i=0;i<Num;i++) v.a[i] = gr->Min.c + (gr->Max.c-gr->Min.c)*mreal(i+1)/(Num+1);\r
+ mgl_cont_z_val(gr,&v,a,sch,sv,0);\r
+ gr->LoadState();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_x_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_cont_x(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }
-//-----------------------------------------------------------------------------
-void mgl_cont_y_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_cont_x(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_y_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_cont_y(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }
-//-----------------------------------------------------------------------------
-void mgl_cont_z_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_cont_y(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_z_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_cont_z(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }
-//-----------------------------------------------------------------------------
-void mgl_cont_x_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_cont_z(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_x_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_cont_x_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s; }
-//-----------------------------------------------------------------------------
-void mgl_cont_y_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_cont_x_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_y_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_cont_y_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s; }
-//-----------------------------------------------------------------------------
-void mgl_cont_z_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_cont_y_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+//-----------------------------------------------------------------------------\r
+void mgl_cont_z_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_cont_z_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s; }
-//-----------------------------------------------------------------------------
-//
-// ContFX, ContFY, ContFZ series
-//
-//-----------------------------------------------------------------------------
-void mgl_contf_gen(HMGL gr, float v1, float v2, HCDT a, HCDT x, HCDT y, HCDT z, float c, long ak);
-void mgl_contf_x_val(HMGL gr, HCDT v, HCDT a, const char *sch, float sv, const char *opt)
-{
- register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();
- if(mgl_isnan(sv)) sv = gr->GetOrgX('x');
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContFX"); return; }
- if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContFX"); return; }
- gr->SaveState(opt);
- static int cgid=1; gr->StartGroup("ContFX",cgid++);
- mglData xx,yy,zz,aa;
- long ss=gr->AddTexture(sch);
-
- if(l>1)
- {
- aa.Create(m,l); xx.Create(m,l); yy.Create(m,l); zz.Create(m,l);
- float d = (n-1)*(sv - gr->Min.x)/(gr->Max.x - gr->Min.x);
- k = long(d); d = d - k;
- if(k>n-2) { k=n-2; d=1; }
- if(k<0) { k=0; d=0; }
- for(j=0;j<l;j++) for(i=0;i<m;i++)
- aa.a[i+m*j] = a->v(k,i,j)*(1-d) + d*a->v(k+1,i,j);
- a = &aa;
- }
- else
- { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }
- xx.Fill(sv, sv);
- yy.Fill(gr->Min.y, gr->Max.y,'x');
- zz.Fill(gr->Min.z, gr->Max.z,'y');
- for(i=0;i<v->GetNx()-1;i++)
- {
- register float v0 = v->v(i);
- mgl_contf_gen(gr,v0,v->v(i+1),a,&xx,&yy,&zz,gr->GetC(ss,v0),0);
- }
- gr->EndGroup();
-}
-//-----------------------------------------------------------------------------
-void mgl_contf_y_val(HMGL gr, HCDT v, HCDT a, const char *sch, float sv, const char *opt)
-{
- register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();
- if(mgl_isnan(sv)) sv = gr->GetOrgX('x');
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContFY"); return; }
- if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContFY"); return; }
- gr->SaveState(opt);
- static int cgid=1; gr->StartGroup("ContFY",cgid++);
- mglData xx,yy,zz,aa;
- long ss=gr->AddTexture(sch);
-
- if(l>1)
- {
- aa.Create(n,l); xx.Create(n,l); yy.Create(n,l); zz.Create(n,l);
- float d = (m-1)*(sv - gr->Min.y)/(gr->Max.y - gr->Min.y);
- k = long(d); d = d - k;
- if(k>m-2) { k=m-2; d=1; }
- if(k<0) { k=0; d=0; }
- for(j=0;j<l;j++) for(i=0;i<n;i++)
- aa.a[i+n*j] = a->v(i,k,j)*(1-d) + d*a->v(i,k+1,j);
- a = &aa;
- }
- else
- { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }
- yy.Fill(sv, sv);
- xx.Fill(gr->Min.x, gr->Max.x,'x');
- zz.Fill(gr->Min.z, gr->Max.z,'y');
- for(i=0;i<v->GetNx()-1;i++)
- {
- register float v0 = v->v(i);
- mgl_contf_gen(gr,v0,v->v(i+1),a,&xx,&yy,&zz,gr->GetC(ss,v0),0);
- }
- gr->EndGroup();
-}
-//-----------------------------------------------------------------------------
-void mgl_contf_z_val(HMGL gr, HCDT v, HCDT a, const char *sch, float sv, const char *opt)
-{
- register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();
- if(mgl_isnan(sv)) sv = gr->GetOrgX('x');
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContFZ"); return; }
- if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContFZ"); return; }
- gr->SaveState(opt);
- static int cgid=1; gr->StartGroup("ContFZ",cgid++);
- mglData xx,yy,zz,aa;
- long ss=gr->AddTexture(sch);
-
- xx.Create(n,m); yy.Create(n,m); zz.Create(n,m);
- if(l>1)
- {
- aa.Create(n,m);
- float d = (l-1)*(sv - gr->Min.z)/(gr->Max.z - gr->Min.z);
- k = long(d); d = d - k;
- if(k>l-2) { k=l-2; d=1; }
- if(k<0) { k=0; d=0; }
- for(j=0;j<m;j++) for(i=0;i<n;i++)
- aa.a[i+n*j] = a->v(i,j,k)*(1-d) + d*a->v(i,j,k+1);
- a = &aa;
- }
- zz.Fill(sv, sv);
- yy.Fill(gr->Min.y, gr->Max.y,'y');
- xx.Fill(gr->Min.x, gr->Max.x,'x');
- for(i=0;i<v->GetNx()-1;i++)
- {
- register float v0 = v->v(i);
- mgl_contf_gen(gr,v0,v->v(i+1),a,&xx,&yy,&zz,gr->GetC(ss,v0),0);
- }
- gr->EndGroup();
-}
-//-----------------------------------------------------------------------------
-void mgl_contf_x(HMGL gr, HCDT a, const char *sch, float sv, const char *opt)
-{
- float r = gr->SaveState(opt);
- long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);
- mglData v(Num); v.Fill(gr->Min.c, gr->Max.c);
- mgl_contf_x_val(gr,&v,a,sch,sv,0);
-}
-//-----------------------------------------------------------------------------
-void mgl_contf_y(HMGL gr, HCDT a, const char *sch, float sv, const char *opt)
-{
- float r = gr->SaveState(opt);
- long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);
- mglData v(Num); v.Fill(gr->Min.c, gr->Max.c);
- mgl_contf_y_val(gr,&v,a,sch,sv,0);
-}
-//-----------------------------------------------------------------------------
-void mgl_contf_z(HMGL gr, HCDT a, const char *sch, float sv, const char *opt)
-{
- float r = gr->SaveState(opt);
- long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);
- mglData v(Num); v.Fill(gr->Min.c, gr->Max.c);
- mgl_contf_z_val(gr,&v,a,sch,sv,0);
-}
-//-----------------------------------------------------------------------------
-void mgl_contf_x_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_cont_z_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+//-----------------------------------------------------------------------------\r
+//\r
+// ContFX, ContFY, ContFZ series\r
+//\r
+//-----------------------------------------------------------------------------\r
+void mgl_contf_gen(HMGL gr, mreal v1, mreal v2, HCDT a, HCDT x, HCDT y, HCDT z, mreal c, long ak);\r
+void mgl_contf_x_val(HMGL gr, HCDT v, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
+ if(mgl_isnan(sv)) sv = gr->GetOrgX('x');\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContFX"); return; }\r
+ if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContFX"); return; }\r
+ gr->SaveState(opt);\r
+ static int cgid=1; gr->StartGroup("ContFX",cgid++);\r
+ mglData xx,yy,zz,aa;\r
+ long ss=gr->AddTexture(sch);\r
+\r
+ if(l>1)\r
+ {\r
+ aa.Create(m,l); xx.Create(m,l); yy.Create(m,l); zz.Create(m,l);\r
+ mreal d = (n-1)*(sv - gr->Min.x)/(gr->Max.x - gr->Min.x);\r
+ k = long(d); d = d - k;\r
+ if(k>n-2) { k=n-2; d=1; }\r
+ if(k<0) { k=0; d=0; }\r
+ const mglData *ma=dynamic_cast<const mglData *>(a);\r
+ if(ma) for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = ma->a[k+n*(i+m*j)]*(1-d) + d*ma->a[k+1+n*(i+m*j)];\r
+ else for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = a->v(k,i,j)*(1-d) + d*a->v(k+1,i,j);\r
+ a = &aa;\r
+ }\r
+ else\r
+ { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }\r
+ xx.Fill(sv, sv);\r
+ yy.Fill(gr->Min.y, gr->Max.y,'x');\r
+ zz.Fill(gr->Min.z, gr->Max.z,'y');\r
+ for(i=0;i<v->GetNx()-1;i++)\r
+ {\r
+ register mreal v0 = v->v(i);\r
+ mgl_contf_gen(gr,v0,v->v(i+1),a,&xx,&yy,&zz,gr->GetC(ss,v0),0);\r
+ }\r
+ gr->EndGroup();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_contf_y_val(HMGL gr, HCDT v, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
+ if(mgl_isnan(sv)) sv = gr->GetOrgX('x');\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContFY"); return; }\r
+ if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContFY"); return; }\r
+ gr->SaveState(opt);\r
+ static int cgid=1; gr->StartGroup("ContFY",cgid++);\r
+ mglData xx,yy,zz,aa;\r
+ long ss=gr->AddTexture(sch);\r
+\r
+ if(l>1)\r
+ {\r
+ aa.Create(n,l); xx.Create(n,l); yy.Create(n,l); zz.Create(n,l);\r
+ mreal d = (m-1)*(sv - gr->Min.y)/(gr->Max.y - gr->Min.y);\r
+ k = long(d); d = d - k;\r
+ if(k>m-2) { k=m-2; d=1; }\r
+ if(k<0) { k=0; d=0; }\r
+ const mglData *ma=dynamic_cast<const mglData *>(a);\r
+ if(ma) for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = ma->a[k+n*(i+m*j)]*(1-d) + d*ma->a[k+n+n*(i+m*j)];\r
+ else for(j=0;j<l;j++) for(i=0;i<n;i++)\r
+ aa.a[i+n*j] = a->v(i,k,j)*(1-d) + d*a->v(i,k+1,j);\r
+ a = &aa;\r
+ }\r
+ else\r
+ { xx.Create(n,m); yy.Create(n,m); zz.Create(n,m); }\r
+ yy.Fill(sv, sv);\r
+ xx.Fill(gr->Min.x, gr->Max.x,'x');\r
+ zz.Fill(gr->Min.z, gr->Max.z,'y');\r
+ for(i=0;i<v->GetNx()-1;i++)\r
+ {\r
+ register mreal v0 = v->v(i);\r
+ mgl_contf_gen(gr,v0,v->v(i+1),a,&xx,&yy,&zz,gr->GetC(ss,v0),0);\r
+ }\r
+ gr->EndGroup();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_contf_z_val(HMGL gr, HCDT v, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ register long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
+ if(mgl_isnan(sv)) sv = gr->GetOrgX('x');\r
+ if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"ContFZ"); return; }\r
+ if(sv<gr->Min.x || sv>gr->Max.x) { gr->SetWarn(mglWarnSlc,"ContFZ"); return; }\r
+ gr->SaveState(opt);\r
+ static int cgid=1; gr->StartGroup("ContFZ",cgid++);\r
+ mglData xx,yy,zz,aa;\r
+ long ss=gr->AddTexture(sch);\r
+\r
+ xx.Create(n,m); yy.Create(n,m); zz.Create(n,m);\r
+ if(l>1)\r
+ {\r
+ aa.Create(n,m);\r
+ mreal d = (l-1)*(sv - gr->Min.z)/(gr->Max.z - gr->Min.z);\r
+ k = long(d); d = d - k;\r
+ if(k>l-2) { k=l-2; d=1; }\r
+ if(k<0) { k=0; d=0; }\r
+ const mglData *ma=dynamic_cast<const mglData *>(a);\r
+ if(ma) for(j=0;j<l;j++) for(i=0;i<m;i++)\r
+ aa.a[i+m*j] = ma->a[k+n*(i+m*j)]*(1-d) + d*ma->a[k+n*m+n*(i+m*j)];\r
+ else for(j=0;j<m;j++) for(i=0;i<n;i++)\r
+ aa.a[i+n*j] = a->v(i,j,k)*(1-d) + d*a->v(i,j,k+1);\r
+ a = &aa;\r
+ }\r
+ zz.Fill(sv, sv);\r
+ yy.Fill(gr->Min.y, gr->Max.y,'y');\r
+ xx.Fill(gr->Min.x, gr->Max.x,'x');\r
+ for(i=0;i<v->GetNx()-1;i++)\r
+ {\r
+ register mreal v0 = v->v(i);\r
+ mgl_contf_gen(gr,v0,v->v(i+1),a,&xx,&yy,&zz,gr->GetC(ss,v0),0);\r
+ }\r
+ gr->EndGroup();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_contf_x(HMGL gr, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ mreal r = gr->SaveState(opt);\r
+ long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);\r
+ mglData v(Num); v.Fill(gr->Min.c, gr->Max.c);\r
+ mgl_contf_x_val(gr,&v,a,sch,sv,0);\r
+ gr->LoadState();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_contf_y(HMGL gr, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ mreal r = gr->SaveState(opt);\r
+ long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);\r
+ mglData v(Num); v.Fill(gr->Min.c, gr->Max.c);\r
+ mgl_contf_y_val(gr,&v,a,sch,sv,0);\r
+ gr->LoadState();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_contf_z(HMGL gr, HCDT a, const char *sch, mreal sv, const char *opt)\r
+{\r
+ mreal r = gr->SaveState(opt);\r
+ long Num = (mgl_isnan(r) || r<=0) ? 7:long(r+0.5);\r
+ mglData v(Num); v.Fill(gr->Min.c, gr->Max.c);\r
+ mgl_contf_z_val(gr,&v,a,sch,sv,0);\r
+ gr->LoadState();\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_contf_x_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_contf_x(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }
-/// Draw several contour plots for data a at y = *sv
-void mgl_contf_y_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_contf_x(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+/// Draw several contour plots for data a at y = *sv\r
+void mgl_contf_y_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_contf_y(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }
-/// Draw several contour plots for data a at z = *sv
-void mgl_contf_z_(uintptr_t *gr, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_contf_y(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+/// Draw several contour plots for data a at z = *sv\r
+void mgl_contf_z_(uintptr_t *gr, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_contf_z(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }
-/// Draw contour plots for data a at x = *sv
-void mgl_contf_x_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_contf_z(_GR_, _DA_(a), s, *sv, o); delete []o; delete []s; }\r
+/// Draw contour plots for data a at x = *sv\r
+void mgl_contf_x_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_contf_x_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s;}
-/// Draw contour plots for data a at y = *sv
-void mgl_contf_y_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_contf_x_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s;}\r
+/// Draw contour plots for data a at y = *sv\r
+void mgl_contf_y_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_contf_y_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s;}
-/// Draw contour plots for data a at z = *sv
-void mgl_contf_z_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, float *sv, const char *opt,int l,int lo)
-{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;
+ mgl_contf_y_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s;}\r
+/// Draw contour plots for data a at z = *sv\r
+void mgl_contf_z_val_(uintptr_t *gr, uintptr_t *v, uintptr_t *a, const char *sch, mreal *sv, const char *opt,int l,int lo)\r
+{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
- mgl_contf_z_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s;}
-//-----------------------------------------------------------------------------
+ mgl_contf_z_val(_GR_, _DA_(v), _DA_(a), s, *sv, o); delete []o; delete []s;}\r
+//-----------------------------------------------------------------------------\r
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#include <stdlib.h>
#include <ctype.h>
-#include <wchar.h>
-//-----------------------------------------------------------------------------
#include "mgl2/parser.h"
#include "mgl2/canvas_cf.h"
//-----------------------------------------------------------------------------
void mgl_ask_gets(const wchar_t *quest, wchar_t *res)
{ printf("%ls\n",quest); if(!fgetws(res,1024,stdin)) *res=0; }
//-----------------------------------------------------------------------------
-mglFunc::mglFunc(long p, const wchar_t *f, mglFunc *prev)
+mglFunc::mglFunc(const mglFunc &f)
+{ pos=f.pos; narg=f.narg; wcsncpy(func,f.func,64); }
+mglFunc::mglFunc(long p, const wchar_t *f)
{
- pos = p; next = prev;
- register long i;
- for(i=0;(isalnum(f[i]) || f[i]=='_') && i<31;i++) func[i]=f[i];
- func[i]=0;
- narg = wcstol(f+i+1,0,0);
+ pos = p;
+ register size_t i;
+ for(i=0;(isalnum(f[i]) || f[i]=='_') && i<63;i++) func[i]=f[i];
+ func[i]=0; narg = wcstol(f+i+1,0,0);
if(narg<0 || narg>9) narg=0;
}
//-----------------------------------------------------------------------------
long mglParser::IsFunc(const wchar_t *name, int *na)
{
- mglFunc *f=func;
- while(f)
+ register size_t i;
+ for(i=0;i<func.size();i++)
{
- if(!wcscmp(f->func.c_str(), name))
- { if(na) *na=f->narg; return f->pos; }
- f = f->next;
+ const mglFunc &f = func[i];
+ if(!wcscmp(f.func, name))
+ { if(na) *na=f.narg; return f.pos; }
}
return 0;
}
{
static long num=0;
if(!line)
- { if(func) delete func;
- num=0; func=0; return; }
+ { func.clear(); num=0; return; }
num++;
if(wcsncmp(line,L"func",4) || line[4]>' ') return;
register long i;
for(i=4;line[i]<=' ' || line[i]=='\'';i++);
- func = new mglFunc(num-1, line+i, func);
+ func.push_back(mglFunc(num-1, line+i));
}
//-----------------------------------------------------------------------------
wchar_t *mgl_str_copy(const char *s)
//-----------------------------------------------------------------------------
mglParser::mglParser(bool setsize)
{
- DataList=0; NumList=0; func=0; fn_stack=0;
+ DataList=0; NumList=0; fn_stack=0;
// wchar_t *par[40]; ///< Parameter for substituting instead of $1, ..., $9
out=0; *leg=0; InUse = 1;
Skip=Stop=for_br=false;
}
for(long i=0;i<40;i++) if(par[i]) delete [](par[i]);
delete []op1; delete []op2; delete []fval;
- if(Cmd!=mgls_base_cmd) delete []Cmd;
+ if(Cmd && Cmd!=mgls_base_cmd) delete []Cmd;
if(fn_stack) free(fn_stack);
}
//-----------------------------------------------------------------------------
if(str[i]=='\'') l++;
if(str[i]=='{') k++;
if(str[i]=='}') k--;
- if(l%2==0 && k==0 && (str[i]=='#' || str[i]==';')) return -i;
- if(l%2==0 && k==0 && (str[i]<=' ')) return i;
+ if(l%2==0 && k==0)
+ {
+ if(str[i]=='#' || str[i]==';') return -i;
+ if(str[i]<=' ') return i;
+ }
}
return 0;
}
for(n=0;n<long(wcslen(str));n++)
{
if(str[n]=='\'' && (n==0 || str[n-1]!='\\')) k++;
- if(str[n]=='(' && k%2==0) m++;
- if(str[n]==')' && k%2==0) m--;
- if(str[n]=='{' && k%2==0) mm++;
- if(str[n]=='}' && k%2==0) mm--;
- if(str[n]=='#' && k%2==0) break;
+ if(k%2) continue;
+ if(str[n]=='(') m++;
+ if(str[n]==')') m--;
+ if(str[n]=='{') mm++;
+ if(str[n]=='}') mm--;
+ if(str[n]=='#') break;
if((str[n]==':' || str[n]=='\n') && k%2==0 && m==0 && mm==0)
{
str[n]=0;
fn_stack[fn_pos].pos = pos; fn_pos++; n--;
}
else
- {
+ { // TODO check bugfix here!!!
FILE *fp = fopen(a[0].s.c_str(),"rt");
- if(fp) { Execute(gr,fp); fclose(fp); }
+ if(fp)
+ {
+ register int i;
+ mglParser *prs = new mglParser(AllowSetSize);
+ prs->DataList=DataList; prs->NumList=NumList; prs->Cmd=Cmd;
+ for(i=10;i<30;i++) prs->AddParam(i,par[i]);
+ prs->Execute(gr,fp);
+ for(i=10;i<30;i++) AddParam(i,prs->par[i]);
+ DataList=prs->DataList; prs->DataList=0;
+ NumList =prs->NumList; prs->NumList=0;
+ prs->Cmd=0; delete prs; fclose(fp);
+ }
else n=1;
}
}
for(i=0;i<n;i++) ScanFunc(text[i]);
for(i=0;i<n;i++)
{
- gr->SetWarn(-1, NULL);
+ gr->SetWarn(-1, "");
gr->SetObjId(i+1);
r = Parse(gr,text[i],i+1);
if(r<0) { i = -r-2; continue; }
memcpy(wcs, text, s*sizeof(wchar_t));
str[0] = wcs; n=1;
long next=0;
+ Stop = false;
for(i=0;i<s;i++)
{
if(text[i]=='\\') next = i;
return 0;\r
}\r
// Solve equation du/dz = ham(p,q,x,y,z,|u|)[u] where p=d/dx, q=d/dy. At this moment simplified form of ham is supported: ham = f(p,q,z) + g(x,y,z,'u'), where variable 'u'=|u| (for allowing solve nonlinear problems). You may specify imaginary part like ham = p^2 + i*x*(x>0) but only if dependence on variable 'i' is linear (i.e. ham = hre+i*him).\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_pde_solve(HMGL gr, const char *ham, HCDT ini_re, HCDT ini_im, mreal dz, mreal k0, const char *opt)\r
{\r
gr->SaveState(opt);\r
mglPoint Min=gr->Min, Max=gr->Max;\r
}\r
//-----------------------------------------------------------------------------\r
// Solve GO ray equation like dr/dt = d ham/dp, dp/dt = -d ham/dr where ham = ham(x,y,z,p,q,v,t) and px=p, py=q, pz=v. The starting point (at t=0) is r0, p0. Result is array of {x,y,z,p,q,v,t}\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_ray_trace(const char *ham, mreal x0, mreal y0, mreal z0, mreal px, mreal py, mreal pz, mreal dt, mreal tmax)\r
{\r
mglData *res=new mglData;\r
if(tmax<dt) return res; // nothing to do\r
}\r
return 0;\r
}\r
-HMDT mgl_qo2d_solve(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray_dat, float r, float k0, HMDT xx, HMDT yy)\r
+HMDT mgl_qo2d_solve(const char *ham, HCDT ini_re, HCDT ini_im, HCDT ray_dat, mreal r, mreal k0, HMDT xx, HMDT yy)\r
{\r
mglData *res=new mglData;\r
const mglData *ray=dynamic_cast<const mglData *>(ray_dat); // NOTE: Ray must be mglData!\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdlib.h>\r
-#include <math.h>\r
#include <algorithm>\r
#include "mgl2/canvas.h"\r
//-----------------------------------------------------------------------------\r
void mglCanvas::SetSize(int w,int h)\r
{\r
if(w<=0 || h<=0) { SetWarn(mglWarnSize,"SetSize"); return; }\r
- Width = w; Height = h; Depth = long(sqrt(w*h));\r
+ Width = w; Height = h; Depth = long(sqrt(double(w*h)));\r
if(G) { delete []G; delete []C; delete []Z; delete []G4;delete []OI; }\r
G = new unsigned char[w*h*3];\r
G4= new unsigned char[w*h*4];\r
{\r
mglPoint q=p/(2*B.pf);\r
p.x = B.x + q.x*B.b[0] + q.y*B.b[1] + q.z*B.b[2];\r
- p.y = B.y+ q.x*B.b[3] + q.y*B.b[4] + q.z*B.b[5];\r
- p.z = B.z+ q.x*B.b[6] + q.y*B.b[7] + q.z*B.b[8];\r
+ p.y = B.y + q.x*B.b[3] + q.y*B.b[4] + q.z*B.b[5];\r
+ p.z = B.z + q.x*B.b[6] + q.y*B.b[7] + q.z*B.b[8];\r
/* if(Persp)\r
{\r
- register float d = (1-Persp*Depth/2)/(1-Persp*p.z);\r
+ register mreal d = (1-Persp*Depth/2)/(1-Persp*p.z);\r
p.x = Width/2 + d*(p.x-Width/2);\r
p.y = Height/2 + d*(p.y-Height/2);\r
}*/\r
if(TernAxis&4) return res;\r
PostScale(p);\r
\r
- mglPoint y=n/(2*B.pf);\r
- n.x = y.x*B.b[0] + y.y*B.b[1] + y.z*B.b[2];\r
+ mglPoint y=n;\r
+// n.x = (B.b[4]*B.b[8]-B.b[5]*B.b[7])*y.x-(B.b[3]*B.b[8]-B.b[5]*B.b[6])*y.y+(B.b[3]*B.b[7]-B.b[4]*B.b[6])*y.z;\r
+// n.y = (B.b[2]*B.b[7]-B.b[1]*B.b[8])*y.x+(B.b[0]*B.b[8]-B.b[2]*B.b[6])*y.y-(B.b[0]*B.b[7]-B.b[1]*B.b[6])*y.z;\r
+// n.y = (B.b[1]*B.b[5]-B.b[2]*B.b[4])*y.x-(B.b[0]*B.b[5]-B.b[2]*B.b[3])*y.y+(B.b[0]*B.b[4]-B.b[1]*B.b[3])*y.z;\r
+ n.x = y.x*B.b[0] + y.y*B.b[1] + y.z*B.b[2]; // simpler for rotation only\r
n.y = y.x*B.b[3] + y.y*B.b[4] + y.z*B.b[5];\r
n.z = y.x*B.b[6] + y.y*B.b[7] + y.z*B.b[8];\r
n.Normalize();\r
/* if(Persp)\r
{\r
- register float d = (1-Persp*Depth/2)/(1-Persp*p.z);\r
+ register mreal d = (1-Persp*Depth/2)/(1-Persp*p.z);\r
// NOTE: No d* since I use transformed p here.\r
- register float dd = Persp*n.z/(1-Persp*p.z);\r
+ register mreal dd = Persp*n.z/(1-Persp*p.z);\r
n.x = d*n.x + dd*(p.x-Width/2);\r
n.y = d*n.y + dd*(p.y-Height/2);\r
}*/\r
mglPoint pp(p0.x,p0.y,p0.z), nn(p0.u,p0.v,p0.w);\r
if(mgl_isnan(pp.x)) return -1;\r
mglPoint q=pp/(2*B.pf), p, n=nn;\r
- register float w=B1.b[0]/2, h=B1.b[4]/2, d=B1.b[8]/2, xx=B1.x-w/2, yy=B1.y-h/2;\r
+ mreal w=B1.b[0]/2, h=B1.b[4]/2, d=B1.b[8]/2, xx=B1.x-w/2, yy=B1.y-h/2;\r
if(TernAxis&1) // usual ternary axis\r
{\r
if(nf==0)\r
// NOTE: Perspective, transformation formulas and lists are not support just now !!! Also it use LAST InPlot parameters!!!\r
mglPoint mglCanvas::CalcXYZ(int xs, int ys) const\r
{\r
- float s3 = 2*B.pf, x, y, z; // TODO: Take into account z-value of z-buffer\r
+ mreal s3 = 2*B.pf, x, y, z; // TODO: Take into account z-value of z-buffer\r
ys = Height - ys;\r
- float xx = xs-B.x, yy = ys-B.y;\r
- float d1=B.b[0]*B.b[4]-B.b[1]*B.b[3], d2=B.b[1]*B.b[5]-B.b[2]*B.b[4], d3=B.b[0]*B.b[5]-B.b[2]*B.b[3];\r
+ mreal xx = xs-B.x, yy = ys-B.y;\r
+ mreal d1=B.b[0]*B.b[4]-B.b[1]*B.b[3], d2=B.b[1]*B.b[5]-B.b[2]*B.b[4], d3=B.b[0]*B.b[5]-B.b[2]*B.b[3];\r
if(fabs(d1) > fabs(d2) && fabs(d1) > fabs(d3)) // x-y plane\r
{\r
z = 0;\r
register unsigned long i;\r
if(id<unsigned(mglNumThr))\r
{\r
- for(i=1;i<=unsigned(sqrt(mglNumThr)+0.5);i++)\r
+ for(i=1;i<=unsigned(sqrt(double(mglNumThr))+0.5);i++)\r
if(mglNumThr%i==0) ny=i;\r
nx = mglNumThr/ny;\r
}\r
else { nx=ny=1; id=0; }\r
mglDrawReg d; d.set(this,nx,ny,id);\r
- float ss=pPos, ww=PenWidth;\r
+ mreal ss=pPos, ww=PenWidth;\r
mglPrim p;\r
for(i=0;i<n;i++)\r
{\r
//-----------------------------------------------------------------------------\r
void mglCanvas::ClfZB()\r
{\r
+ if(Quality&4) return;\r
register long i,n=Width*Height;\r
memset(C,0,12*n); memset(OI,0,n*sizeof(int));\r
for(i=0;i<3*n;i++) Z[i] = -1e20f; // TODO: Parallelization ?!?\r
//-----------------------------------------------------------------------------\r
void mglCanvas::Clf(mglColor Back)\r
{\r
- Fog(0); PDef = 0xffff; pPos = 0; StartAutoGroup(NULL);\r
+ Fog(0); PDef = 0xffff; pPos = 0; StartAutoGroup(NULL);\r
Pnt.clear(); Prm.clear(); Ptx.clear();\r
Sub.clear(); Leg.clear(); Grp.clear();\r
\r
mglStartThread(&mglCanvas::pxl_other,this,Width*Height,gr);\r
}\r
//-----------------------------------------------------------------------------\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
+#if MGL_HAVE_MPI\r
+#include <mpi.h>\r
+#define MCW MPI_COMM_WORLD\r
+#define TAG_DATA_Z 0\r
+#define TAG_DATA_C 1\r
+void mglCanvas::MPI_Send(int id)\r
+{\r
+ ::MPI_Send(Z,3*Width*Height,MPI_FLOAT,id,TAG_DATA_Z,MCW);\r
+ ::MPI_Send(C,12*Width*Height,MPI_CHAR,id,TAG_DATA_C,MCW);\r
+}\r
+void mglCanvas::MPI_Recv(int id)\r
+{\r
+ Finish();\r
+ MPI_Status status;\r
+ long n = Width*Height;\r
+ float *zz = new float[3*n];\r
+ unsigned char *cc = new unsigned char[12*n];\r
+ ::MPI_Recv(Z,3*n,MPI_FLOAT,id,TAG_DATA_Z,MCW,&status);\r
+ ::MPI_Recv(C,12*n,MPI_CHAR,id,TAG_DATA_C,MCW,&status);\r
+ // TODO check status for errors\r
+ register long i,j,k;\r
+ for(k=0;k<n;k++)\r
+ {\r
+ i = k%Width; j = Height-1-(k/Width);\r
+ if(Quality&2)\r
+ {\r
+ pnt_plot(i,j,zz[3*k+2],cc+12*k+8);\r
+ pnt_plot(i,j,zz[3*k+1],cc+12*k+4);\r
+ }\r
+ pnt_plot(i,j,zz[3*k],cc+12*k);\r
+ }\r
+ set(MGL_FINISHED);\r
+}\r
+#else\r
+void mglCanvas::MPI_Send(int /*id*/) {}\r
+void mglCanvas::MPI_Recv(int /*id*/) {}\r
#endif\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::pnt_plot(long x,long y,float z,const unsigned char ci[4])\r
+void mglCanvas::pnt_plot(long x,long y,mreal z,const unsigned char ci[4])\r
{\r
long i0=x+Width*(Height-1-y);\r
if(ci[3]==0) return;\r
if(!light[i].n) continue;\r
if(mgl_isnan(light[i].q.x)) // source at infinity\r
{\r
- nn = 2*(p.u*light[i].p.x+p.v*light[i].p.y+p.w*light[i].p.z) /\r
- (p.u*p.u+p.v*p.v+p.w*p.w+1e-6);\r
+ nn = 2*(p.u*light[i].p.x+p.v*light[i].p.y+p.w*light[i].p.z) / (p.u*p.u+p.v*p.v+p.w*p.w+1e-6);\r
d0 = light[i].p.x - p.u*nn;\r
d1 = light[i].p.y - p.v*nn;\r
d2 = light[i].p.z - p.w*nn;\r
mglPoint nr = mglPoint(p2.x-p1.x,p2.y-p1.y,p2.z-p1.z)^mglPoint(p3.x-p1.x,p3.y-p1.y,p3.z-p1.z);\r
\r
register float u,v,xx,yy;\r
- register long i,j,g;\r
+ register long i,j;\r
float x0 = p1.x, y0 = p1.y;\r
for(i=x1;i<=x2;i++) for(j=y1;j<=y2;j++)\r
{\r
xx = (i-x0); yy = (j-y0);\r
u = dxu*xx+dyu*yy; v = dxv*xx+dyv*yy;\r
- g = u<0 || v<0 || u+v>1;\r
- if(g) continue;\r
+ if(u<0 || v<0 || u+v>1) continue;\r
if(Quality&2) // slow but accurate\r
{\r
p = p1+d1*u+d2*v;\r
y1=y1>dr->y1?y1:dr->y1; y2=y2<dr->y2?y2:dr->y2-1;\r
if(x1>x2 || y1>y2) return;\r
\r
- register long i;\r
+ register long i, c;\r
if(hor) for(i=x1;i<=x2;i++)\r
- pnt_plot(i, p1.y+d.y*(i-p1.x)/d.x, p1.z+d.z*(i-p1.x)/d.x+pw, r);\r
+ {\r
+ c = long(p1.y+d.y*(i-p1.x)/d.x);\r
+ if(c>=y1 && c<=y2)\r
+ pnt_plot(i, c, p1.z+d.z*(i-p1.x)/d.x+pw, r);\r
+ }\r
else for(i=y1;i<=y2;i++)\r
- pnt_plot(p1.x+d.x*(i-p1.y)/d.y, i, p1.z+d.z*(i-p1.y)/d.y+pw, r);\r
+ {\r
+ c = long(p1.x+d.x*(i-p1.y)/d.y);\r
+ if(c>=x1 && c<=x2)\r
+ pnt_plot(c, i, p1.z+d.z*(i-p1.y)/d.y+pw, r);\r
+ }\r
}\r
//-----------------------------------------------------------------------------\r
void mglCanvas::pnt_draw(long k, mglDrawReg *dr)\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::mark_draw(long k, char type, float size, mglDrawReg *d)\r
+void mglCanvas::mark_draw(long k, char type, mreal size, mglDrawReg *d)\r
{\r
const mglPnt &q=Pnt[k];\r
unsigned char cs[4]; col2int(q,cs); cs[3] = size>0 ? 255 : 255*q.t;\r
unsigned long pos = Pnt.size(), qos=pos;\r
mglPnt p=q;\r
- float ss=fabs(size)*0.35*font_factor;\r
+ mreal ss=fabs(size)*0.35*font_factor;\r
register long i,j;\r
#if MGL_HAVE_PTHREAD\r
pthread_mutex_lock(&mutexPnt);\r
if(type=='.' || ss==0) pnt_draw(k,d);\r
else\r
{\r
- float pw = PenWidth; PenWidth = 1;\r
+ mreal pw = PenWidth; PenWidth = 1;\r
int pd = PDef; PDef = 0xffff;\r
if(!strchr("xsSoO",type)) ss *= 1.1;\r
switch(type)\r
void mglCanvas::glyph_draw(const mglPrim *P, mglDrawReg *d)\r
{\r
mglPnt p=Pnt[P->n1];\r
- float f = p.w;\r
+ mreal f = p.w;\r
#if MGL_HAVE_PTHREAD\r
pthread_mutex_lock(&mutexPnt);\r
#endif\r
#endif\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::glyph_fill(const mglPnt &pp, float f, int nt, const short *trig, mglDrawReg *d)\r
+void mglCanvas::glyph_fill(const mglPnt &pp, mreal f, int nt, const short *trig, mglDrawReg *d)\r
{\r
if(!trig || nt<=0) return;\r
long ik,ii,pos=Pnt.size();\r
mglPnt p=pp; p.u=p.v=NAN;\r
- float pw = Width>2 ? fabs(PenWidth) : 1e-5*Width;\r
+ mreal pw = Width>2 ? fabs(PenWidth) : 1e-5*Width;\r
\r
mglPoint p1,p2,p3;\r
for(ik=0;ik<nt;ik++)\r
Pnt.erase(Pnt.begin()+pos,Pnt.end());\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::glyph_wire(const mglPnt &pp, float f, int nl, const short *line, mglDrawReg *d)\r
+void mglCanvas::glyph_wire(const mglPnt &pp, mreal f, int nl, const short *line, mglDrawReg *d)\r
{\r
if(!line || nl<=0) return;\r
long ik,ii,il=0,pos=Pnt.size();\r
mglPnt p=pp; p.u=p.v=NAN;\r
unsigned pdef=PDef; PDef = 0xffff;\r
- float opw=PenWidth; PenWidth=0.75;\r
+ mreal opw=PenWidth; PenWidth=0.75;\r
mglPoint p1,p2;\r
for(ik=0;ik<nl;ik++)\r
{\r
Pnt.erase(Pnt.begin()+pos,Pnt.end());\r
}\r
//-----------------------------------------------------------------------------\r
-void mglCanvas::glyph_line(const mglPnt &pp, float f, bool solid, mglDrawReg *d)\r
+void mglCanvas::glyph_line(const mglPnt &pp, mreal f, bool solid, mglDrawReg *d)\r
{\r
mglPnt p=pp; p.u=p.v=NAN;\r
- float pw = Width>2 ? fabs(PenWidth) : 1e-5*Width;\r
+ mreal pw = Width>2 ? fabs(PenWidth) : 1e-5*Width;\r
unsigned pdef=PDef; PDef = 0xffff;\r
- float opw=PenWidth; PenWidth=1;\r
+ mreal opw=PenWidth; PenWidth=1;\r
mglPoint p1,p2,p3,p4;\r
long pos=Pnt.size();\r
\r
- float dy = 0.004;\r
+ mreal dy = 0.004;\r
p1 = mglPoint(pp.u,pp.v-dy,0); PostScale(p1);\r
p2 = mglPoint(pp.u,pp.v+dy,0); PostScale(p2);\r
p3 = mglPoint(fabs(f)+pp.u,pp.v+dy,0); PostScale(p3);\r
#include "mgl2/plot.h"\r
#include "mgl2/eval.h"\r
#include "mgl2/data.h"\r
-#include <stdlib.h>\r
//-----------------------------------------------------------------------------\r
//\r
// Plot by formulas series\r
void mgl_fplot(HMGL gr, const char *eqY, const char *pen, const char *opt)\r
{\r
if(eqY==0 || eqY[0]==0) return; // nothing to plot\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long n = (mgl_isnan(r) || r<=0) ? 100:long(r+0.5);\r
\r
- float *x = (float *)malloc(n*sizeof(float));\r
- float *y = (float *)malloc(n*sizeof(float));\r
+ mreal *x = (mreal *)malloc(n*sizeof(mreal));\r
+ mreal *y = (mreal *)malloc(n*sizeof(mreal));\r
mglFormula *eq = new mglFormula(eqY);\r
register int i;\r
- float d = (gr->Max.x - gr->Min.x)/(n-1.), xs, ys, yr, ym=fabs(gr->Max.y - gr->Min.y)/1000;\r
+ mreal d = (gr->Max.x - gr->Min.x)/(n-1.), xs, ys, yr, ym=fabs(gr->Max.y - gr->Min.y)/1000;\r
#define islog(a, b) (((a)>0 && (b)>10*(a)) || ((b)<0 && (a)<10*(b)))\r
// initial data filling\r
if(gr->Min.x>0 && gr->Max.x>100*gr->Min.x) for(i=0,d=log(2*gr->Max.x/gr->Min.x)/(n-1);i<n;i++)\r
ys=(y[i]+y[i+1])/2; yr=eq->Calc(xs);\r
if(fabs(yr-ys)>ym) // bad approximation here\r
{\r
- x = (float *)realloc(x,(n+1)*sizeof(float));\r
- y = (float *)realloc(y,(n+1)*sizeof(float));\r
- memmove(x+i+2,x+i+1,(n-i-1)*sizeof(float));\r
- memmove(y+i+2,y+i+1,(n-i-1)*sizeof(float));\r
+ x = (mreal *)realloc(x,(n+1)*sizeof(mreal));\r
+ y = (mreal *)realloc(y,(n+1)*sizeof(mreal));\r
+ memmove(x+i+2,x+i+1,(n-i-1)*sizeof(mreal));\r
+ memmove(y+i+2,y+i+1,(n-i-1)*sizeof(mreal));\r
x[i+1] = xs; y[i+1] = yr; n++;\r
}\r
else i++;\r
//-----------------------------------------------------------------------------\r
void mgl_fplot_xyz(HMGL gr, const char *eqX, const char *eqY, const char *eqZ, const char *pen, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long n = (mgl_isnan(r) || r<=0) ? 100:long(r+0.5);\r
\r
- float *x = (float *)malloc(n*sizeof(float));\r
- float *y = (float *)malloc(n*sizeof(float));\r
- float *z = (float *)malloc(n*sizeof(float));\r
- float *t = (float *)malloc(n*sizeof(float));\r
+ mreal *x = (mreal *)malloc(n*sizeof(mreal));\r
+ mreal *y = (mreal *)malloc(n*sizeof(mreal));\r
+ mreal *z = (mreal *)malloc(n*sizeof(mreal));\r
+ mreal *t = (mreal *)malloc(n*sizeof(mreal));\r
mglFormula *ex, *ey, *ez;\r
ex = new mglFormula(eqX ? eqX : "0");\r
ey = new mglFormula(eqY ? eqY : "0");\r
ez = new mglFormula(eqZ ? eqZ : "0");\r
register int i;\r
- float ts, xs, ys, zs, xr, yr, zr, xm=fabs(gr->Max.x - gr->Min.x)/1000, ym=fabs(gr->Max.y - gr->Min.y)/1000, zm=fabs(gr->Max.z - gr->Min.z)/1000;\r
+ mreal ts, xs, ys, zs, xr, yr, zr, xm=fabs(gr->Max.x - gr->Min.x)/1000, ym=fabs(gr->Max.y - gr->Min.y)/1000, zm=fabs(gr->Max.z - gr->Min.z)/1000;\r
for(i=0;i<n;i++) // initial data filling\r
{\r
if(gr->Stop) { delete ex; delete ey; delete ez; return; }\r
zs=(z[i]+z[i+1])/2; zr=ez->Calc(0,0,ts);\r
if(fabs(xr-xs)>xm || fabs(yr-ys)>ym || fabs(zr-zs)>zm) // bad approximation here\r
{\r
- z = (float *)realloc(z,(n+1)*sizeof(float));\r
- t = (float *)realloc(t,(n+1)*sizeof(float));\r
- x = (float *)realloc(x,(n+1)*sizeof(float));\r
- y = (float *)realloc(y,(n+1)*sizeof(float));\r
- memmove(x+i+2,x+i+1,(n-i-1)*sizeof(float));\r
- memmove(y+i+2,y+i+1,(n-i-1)*sizeof(float));\r
- memmove(z+i+2,z+i+1,(n-i-1)*sizeof(float));\r
- memmove(t+i+2,t+i+1,(n-i-1)*sizeof(float));\r
+ z = (mreal *)realloc(z,(n+1)*sizeof(mreal));\r
+ t = (mreal *)realloc(t,(n+1)*sizeof(mreal));\r
+ x = (mreal *)realloc(x,(n+1)*sizeof(mreal));\r
+ y = (mreal *)realloc(y,(n+1)*sizeof(mreal));\r
+ memmove(x+i+2,x+i+1,(n-i-1)*sizeof(mreal));\r
+ memmove(y+i+2,y+i+1,(n-i-1)*sizeof(mreal));\r
+ memmove(z+i+2,z+i+1,(n-i-1)*sizeof(mreal));\r
+ memmove(t+i+2,t+i+1,(n-i-1)*sizeof(mreal));\r
t[i+1]=ts; x[i+1]=xr; y[i+1]=yr; z[i+1]=zr; n++;\r
}\r
else i++;\r
long n = a->GetNx(), ny=a->GetNy();\r
if(n<2) { gr->SetWarn(mglWarnLow,"Radar"); return; }\r
mglData x(n+1,ny), y(n+1,ny);\r
- float m=a->Minimal(), r=gr->SaveState(opt);\r
+ mreal m=a->Minimal(), r=gr->SaveState(opt);\r
if(mgl_isnan(r) || r<0) r = m<0 ? -m:0;\r
register long i,j;\r
for(j=0;j<ny;j++)\r
{\r
for(i=0;i<n;i++)\r
{\r
- x.a[i+(n+1)*j] = (r+a->v(i,j))*cos(2*i*M_PI/n);\r
- y.a[i+(n+1)*j] = (r+a->v(i,j))*sin(2*i*M_PI/n);\r
+ register mreal v = a->v(i,j);\r
+ x.a[i+(n+1)*j] = (r+v)*cos(2*i*M_PI/n);\r
+ y.a[i+(n+1)*j] = (r+v)*sin(2*i*M_PI/n);\r
}\r
x.a[n+(n+1)*j] = r+a->v(0,j); y.a[n+(n+1)*j] = 0;\r
}\r
bool sh = pen && strchr(pen,'!');\r
\r
long n1,n2,n3,n4;\r
- float m1,m2,xx,x1,x2,d;\r
+ mreal m1,m2,xx,x1,x2,d;\r
+ mreal zm = gr->AdjustZMin();\r
for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { if(d1) delete y1; if(d2) delete y2; return; }\r
d = i<nx-1 ? x->v(i+1)-xx : xx-x->v(i-1);\r
x1 = xx + d/2*(1-gr->BarWidth);\r
x2 = x1 + gr->BarWidth*d; xx = (x1+x2)/2;\r
- n1 = gr->AddPnt(mglPoint(xx,y1->v(i),gr->Min.z));\r
- n2 = gr->AddPnt(mglPoint(xx,m1,gr->Min.z));\r
+ n1 = gr->AddPnt(mglPoint(xx,y1->v(i),zm));\r
+ n2 = gr->AddPnt(mglPoint(xx,m1,zm));\r
gr->line_plot(n1,n2);\r
- n3 = gr->AddPnt(mglPoint(xx,y2->v(i),gr->Min.z));\r
- n4 = gr->AddPnt(mglPoint(xx,m2,gr->Min.z));\r
+ n3 = gr->AddPnt(mglPoint(xx,y2->v(i),zm));\r
+ n4 = gr->AddPnt(mglPoint(xx,m2,zm));\r
gr->line_plot(n3,n4);\r
\r
- n1 = gr->AddPnt(mglPoint(x1,m1,gr->Min.z));\r
- n2 = gr->AddPnt(mglPoint(x2,m1,gr->Min.z));\r
- n3 = gr->AddPnt(mglPoint(x1,m2,gr->Min.z));\r
- n4 = gr->AddPnt(mglPoint(x2,m2,gr->Min.z));\r
+ n1 = gr->AddPnt(mglPoint(x1,m1,zm));\r
+ n2 = gr->AddPnt(mglPoint(x2,m1,zm));\r
+ n3 = gr->AddPnt(mglPoint(x1,m2,zm));\r
+ n4 = gr->AddPnt(mglPoint(x2,m2,zm));\r
gr->line_plot(n1,n2); gr->line_plot(n1,n3);\r
gr->line_plot(n4,n2); gr->line_plot(n4,n3);\r
if(m1>m2) gr->quad_plot(n1,n2,n3,n4);\r
//-----------------------------------------------------------------------------\r
void mgl_candle_yv(HMGL gr, HCDT v1, HCDT v2, HCDT y1, HCDT y2, const char *pen, const char *opt)\r
{\r
- if(v1->GetNx()<2) { gr->SetWarn(mglWarnLow,"Candle"); return; }\r
gr->SaveState(opt);\r
mglData x(v1->GetNx()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_candle_xyv(gr,&x,v1,v2,y1,y2,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_candle(HMGL gr, HCDT v1, HCDT y1, HCDT y2, const char *pen, const char *opt)\r
void mgl_plot_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *pen, const char *opt)\r
{\r
long j,m,mx,my,mz,n=y->GetNx(),pal;\r
- if(x->GetNx()!=n || z->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Plot"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Plot"); return; }\r
+ if(mgl_check_dim1(gr,x,y,z,0,"Plot")) return;\r
+\r
static int cgid=1; gr->StartGroup("Plot",cgid++);\r
gr->SaveState(opt);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy(); m = z->GetNy() > m ? z->GetNy() : m;\r
char mk=gr->SetPenPal(pen,&pal); gr->Reserve(2*n*m);\r
bool t1,t2,t3;\r
- mglPoint p1,p2,p3,nn;\r
+ mglPoint p1,nn,p2,pt;\r
long n1=-1,n2=-1,n3=-1;\r
bool sh = pen && strchr(pen,'!');\r
\r
for(i=0;i<n;i++)\r
{\r
if(gr->Stop) return;\r
- if(i>0) { n2=n1; p2=p1; t2=t1; }\r
+ if(i>0) { n2=n1; p2 = p1; t2=t1; }\r
p1 = mglPoint(x->v(i,mx), y->v(i,my), z->v(i,mz));\r
n1 = gr->AddPnt(p1); t1 = n1>=0;\r
if(mk && t1) gr->mark_plot(n1,mk);\r
\r
if(i>0 && ((t1 && !t2) || (t2 && !t1))) // do smoothing\r
{\r
- float i1=0, i2=1, ii;\r
- p3=p1; t3=t1; n3=n1; // copy current\r
+ mreal i1=0, i2=1, ii;\r
+ t3=t1; n3=n1; // copy current\r
do {\r
ii = (i1+i2)/2;\r
- p1.x = x->v(i,mx)*ii+x->v(i-1,mx)*(1-ii);\r
- p1.y = y->v(i,my)*ii+y->v(i-1,my)*(1-ii);\r
- p1.z = z->v(i,mz)*ii+z->v(i-1,mz)*(1-ii);\r
- n1 = gr->AddPnt(p1); t1 = n1>=0;\r
+ pt.x = p1.x*ii+p2.x*(1-ii);\r
+ pt.y = p1.y*ii+p2.y*(1-ii);\r
+ pt.z = p1.z*ii+p2.z*(1-ii);\r
+ n1 = gr->AddPnt(pt); t1 = n1>=0;\r
if((t1 && t3) || (t2 && !t1)) i2 = ii;\r
else i1 = ii;\r
} while(fabs(i2-i1)>1e-3);\r
{\r
gr->SaveState(opt);\r
mglData z(y->GetNx());\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_plot_xyz(gr,x,y,&z,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_plot(HMGL gr, HCDT y, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Plot"); return; }\r
+ register long n=y->GetNx();\r
+ if(n<2) { gr->SetWarn(mglWarnLow,"Plot"); return; }\r
gr->SaveState(opt);\r
- mglData x(y->GetNx()), z(y->GetNx());\r
+ mglData x(n), z(n);\r
x.Fill(gr->Min.x,gr->Max.x);\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_plot_xyz(gr,&x,y,&z,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_plot_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
void mgl_tens_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT c, const char *pen, const char *opt)\r
{\r
long j,m,mx,my,mz,mc,n=y->GetNx(), pal;\r
- if(x->GetNx()!=n || z->GetNx()!=n || c->GetNx()!=n)\r
- { gr->SetWarn(mglWarnDim,"Tens"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Tens"); return; }\r
+ if(mgl_check_dim1(gr,x,y,z,0,"Tens")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Tens",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy(); m = z->GetNy() > m ? z->GetNy() : m;\r
char mk=gr->SetPenPal(pen, &pal); gr->Reserve(2*n*m);\r
long ss=gr->AddTexture(pen);\r
bool t1,t2,t3;\r
- mglPoint p1,p2,p3,nn;\r
+ mglPoint p1,p2,pt,nn;\r
long n1=-1,n2=-1,n3=-1;\r
\r
for(j=0;j<m;j++)\r
\r
if(i>0 && ((t1 && !t2) || (t2 && !t1))) // do smoothing\r
{\r
- float i1=0, i2=1, ii;\r
- p3=p1; t3=t1; n3=n1; // copy current\r
+ mreal i1=0, i2=1, ii;\r
+ t3=t1; n3=n1; // copy current\r
do {\r
ii = (i1+i2)/2;\r
- p1.x = x->v(i,mx)*ii+x->v(i-1,mx)*(1-ii);\r
- p1.y = y->v(i,my)*ii+y->v(i-1,my)*(1-ii);\r
- p1.z = z->v(i,mz)*ii+z->v(i-1,mz)*(1-ii);\r
- p1.c = c->v(i,mc)*ii+c->v(i-1,mc)*(1-ii);\r
- n1 = gr->AddPnt(p1,gr->GetC(ss,p1.c)); t1 = n1>=0;\r
+ pt.x = p1.x*ii+p2.x*(1-ii);\r
+ pt.y = p1.y*ii+p2.y*(1-ii);\r
+ pt.z = p1.z*ii+p2.z*(1-ii);\r
+ pt.c = p1.c*ii+p2.c*(1-ii);\r
+ n1 = gr->AddPnt(pt,gr->GetC(ss,pt.c)); t1 = n1>=0;\r
if((t1 && t3) || (t2 && !t1)) i2 = ii;\r
else i1 = ii;\r
} while(fabs(i2-i1)>1e-3);\r
{\r
gr->SaveState(opt);\r
mglData z(y->GetNx());\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tens_xyz(gr,x,y,&z,c,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_tens(HMGL gr, HCDT y, HCDT c, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Tens"); return; }\r
+ register long n=y->GetNx();\r
+ if(n<2) { gr->SetWarn(mglWarnLow,"Tens"); return; }\r
gr->SaveState(opt);\r
- mglData x(y->GetNx()), z(y->GetNx());\r
+ mglData x(n), z(n);\r
x.Fill(gr->Min.x,gr->Max.x);\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tens_xyz(gr,&x,y,&z,c,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_tens_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *c, const char *pen, const char *opt,int l,int lo)\r
void mgl_area_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *pen, const char *opt)\r
{\r
long i,j,n=y->GetNx(),m,mx,my,mz,pal;\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Area"); return; }\r
- if(x->GetNx()!=n || z->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Area"); return; }\r
+ if(mgl_check_dim1(gr,x,y,z,0,"Area")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Area3",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy(); m = z->GetNy() > m ? z->GetNy() : m;\r
bool sh = pen && strchr(pen,'!');\r
bool wire = pen && strchr(pen,'#');\r
\r
- float z0=gr->GetOrgZ('x');\r
- float c1,c2;\r
+ mreal z0=gr->GetOrgZ('x');\r
+ mreal c1,c2;\r
mglPoint p1,p2,p3,p4,nn;\r
long n1,n2,n3,n4;\r
gr->SetPenPal(pen,&pal); gr->Reserve(2*n*m);\r
mx = j<x->GetNy() ? j:0; my = j<y->GetNy() ? j:0; mz = j<z->GetNy() ? j:0;\r
\r
nn = mglPoint(-y->dvx(0,my),x->dvx(0,mx));\r
- n1 = gr->AddPnt(mglPoint(x->v(0,mx),y->v(0,my),z->v(0,mz)),c1,nn);\r
- n2 = gr->AddPnt(mglPoint(x->v(0,mx),y->v(0,my),z0),c2,nn);\r
+ mglPoint p = mglPoint(x->v(0,mx),y->v(0,my),z->v(0,mz));\r
+ n1 = gr->AddPnt(p,c1,nn); p.z = z0; n2 = gr->AddPnt(p,c2,nn);\r
for(i=1;i<n;i++)\r
{\r
if(gr->Stop) return;\r
n3=n1; n4=n2;\r
nn = mglPoint(-y->dvx(i,my),x->dvx(i,mx));\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx),y->v(i,my),z->v(i,mz)),c1,nn);\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx),y->v(i,my),z0),c2,nn);\r
+ p = mglPoint(x->v(i,mx),y->v(i,my),z->v(i,mz));\r
+ n1 = gr->AddPnt(p,c1,nn); p.z = z0; n2 = gr->AddPnt(p,c2,nn);\r
if(wire)\r
{\r
gr->line_plot(n1,n2); gr->line_plot(n3,n4);\r
void mgl_area_xy(HMGL gr, HCDT x, HCDT y, const char *pen, const char *opt)\r
{\r
long i,j,n=y->GetNx(),m=y->GetNy(),mx,my,pal;\r
- if(x->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Area"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Area"); return; }\r
+ if(mgl_check_dim1(gr,x,y,0,0,"Area")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Curve",cgid++);\r
- float y0=gr->GetOrgY('x'), z0;\r
- float c1,c2;\r
+ mreal zm = gr->AdjustZMin();\r
+ mreal y0=gr->GetOrgY('x'), z0;\r
+ mreal c1,c2;\r
mglPoint nn=mglPoint(0,0,1);\r
long n1,n2,n3,n4;\r
bool sh = pen && strchr(pen,'!');\r
c2=c1=gr->NextColor(pal);\r
if(gr->GetNumPal(pal)==2*m && !sh) c2=gr->NextColor(pal);\r
mx = j<x->GetNy() ? j:0; my = j<y->GetNy() ? j:0;\r
- z0 = gr->Min.z + (m-1-j)*(gr->Max.z-gr->Min.z)/m;\r
+ z0 = zm + (m-1-j)*(gr->Max.z-zm)/m;\r
\r
- n1 = gr->AddPnt(mglPoint(x->v(0,mx),y->v(0,my),z0),c1,nn);\r
- n2 = gr->AddPnt(mglPoint(x->v(0,mx),y0,z0),c2,nn);\r
+ mglPoint p = mglPoint(x->v(0,mx),y->v(0,my),z0);\r
+ n1 = gr->AddPnt(p,c1,nn); p.y = y0; n2 = gr->AddPnt(p,c2,nn);\r
for(i=1;i<n;i++)\r
{\r
if(gr->Stop) return;\r
n3=n1; n4=n2;\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx),y->v(i,my),z0),c1,nn);\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx),y0,z0),c2,nn);\r
+ p = mglPoint(x->v(i,mx),y->v(i,my),z0);\r
+ n1 = gr->AddPnt(p,c1,nn); p.y = y0; n2 = gr->AddPnt(p,c2,nn);\r
if(wire)\r
{\r
gr->line_plot(n1,n2); gr->line_plot(n3,n4);\r
//-----------------------------------------------------------------------------\r
void mgl_area(HMGL gr, HCDT y, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Area"); return; }\r
gr->SaveState(opt);\r
mglData x(y->GetNx());\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_area_xy(gr,&x,y,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_area_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
void mgl_region_xy(HMGL gr, HCDT x, HCDT y1, HCDT y2, const char *pen, const char *opt)\r
{\r
long i,j, n=y1->GetNx(), m=y1->GetNy(), mx, pal;\r
- if(x->GetNx()!=n || y2->GetNx()!=n || y2->GetNy()!=m)\r
- { gr->SetWarn(mglWarnDim,"Region"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Region"); return; }\r
+ if(mgl_check_dim1(gr,x,y1,y2,0,"Region")) return;\r
+ if(y2->GetNy()!=m) { gr->SetWarn(mglWarnDim,"Region"); return; }\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Region",cgid++);\r
- float c1,c2;\r
+ mreal c1,c2;\r
mglPoint nn=mglPoint(0,0,1);\r
long n1,n2,n3,n4;\r
- float xx,f1,f2,f3,f4;\r
+ mreal xx,f1,f2,f3,f4;\r
+ mreal zm = gr->AdjustZMin();\r
bool inside = (pen && strchr(pen,'i')); // NOTE: check if 'i' is free (used here for inside flag)\r
bool sh = pen && strchr(pen,'!');\r
\r
c2=c1=gr->NextColor(pal);\r
if(gr->GetNumPal(pal)==2*m && !sh) c2=gr->NextColor(pal);\r
mx = j<x->GetNy() ? j:0;\r
- float z0 = gr->Min.z + (m-1-j)*(gr->Max.z-gr->Min.z)/m;\r
+ mreal z0 = zm + (m-1-j)*(gr->Max.z-zm)/m;\r
\r
f1 = y1->v(0,j); f2 = y2->v(0,j); xx = x->v(0,mx);\r
n1 = gr->AddPnt(mglPoint(xx,f1,z0),c1,nn);\r
{\r
gr->SaveState(opt);\r
mglData x(y1->GetNx());\r
- x.Fill(gr->Min.z, gr->Max.z);\r
+ x.Fill(gr->Min.x, gr->Max.x);\r
mgl_region_xy(gr,&x,y1,y2,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_region_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y1, uintptr_t *y2, const char *pen, const char *opt, int l, int lo)\r
void mgl_step_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *pen, const char *opt)\r
{\r
long i,j,m,mx,my,mz,n=y->GetNx(), pal;\r
- if(x->GetNx()!=n || z->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Step"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Step"); return; }\r
+ if(mgl_check_dim1(gr,x,y,z,0,"Step")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Step3",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy(); m = z->GetNy() > m ? z->GetNy() : m;\r
\r
char mk=gr->SetPenPal(pen,&pal); gr->Reserve(2*n*m);\r
long n1,n2;\r
+ mglPoint p;\r
for(j=0;j<m;j++)\r
{\r
mx = j<x->GetNy() ? j:0; my = j<y->GetNy() ? j:0;\r
{\r
if(gr->Stop) return;\r
n2 = n1; // horizontal\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my), z->v(i-1,mz)));\r
- gr->line_plot(n1,n2);\r
+ p = mglPoint(x->v(i,mx), y->v(i,my), z->v(i-1,mz));\r
+ n1 = gr->AddPnt(p); gr->line_plot(n1,n2);\r
if(i==1) gr->arrow_plot(n1,n2,gr->Arrow1);\r
\r
n2 = n1; // vertical\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my), z->v(i,mz)));\r
+ p.z = z->v(i,mz); n1 = gr->AddPnt(p);\r
if(mk) gr->mark_plot(n1,mk);\r
gr->line_plot(n1,n2);\r
if(i==n-1) gr->arrow_plot(n1,n2,gr->Arrow2);\r
void mgl_step_xy(HMGL gr, HCDT x, HCDT y, const char *pen, const char *opt)\r
{\r
long i,j,m,mx,my,n=y->GetNx(), pal;\r
- if(x->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Step"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Step"); return; }\r
+ if(mgl_check_dim1(gr,x,y,0,0,"Step")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Step",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy();\r
bool sh = pen && strchr(pen,'!');\r
\r
- float zVal = gr->Min.z;\r
+ mreal zVal =gr->AdjustZMin();\r
char mk=gr->SetPenPal(pen,&pal); gr->Reserve(2*n*m);\r
long n1,n2;\r
+ mglPoint p;\r
for(j=0;j<m;j++)\r
{\r
mx = j<x->GetNy() ? j:0; my = j<y->GetNy() ? j:0;\r
{\r
if(gr->Stop) return;\r
n2 = n1; // horizontal\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i-1,my), zVal));\r
- gr->line_plot(n1,n2);\r
+ p = mglPoint(x->v(i,mx), y->v(i-1,my), zVal);\r
+ n1 = gr->AddPnt(p); gr->line_plot(n1,n2);\r
if(i==1) gr->arrow_plot(n1,n2,gr->Arrow1);\r
\r
n2 = n1; // vertical\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my), zVal));\r
+ p.y = y->v(i,my); n1 = gr->AddPnt(p);\r
if(mk) gr->mark_plot(n1,mk);\r
gr->line_plot(n1,n2);\r
if(i==n-1) gr->arrow_plot(n1,n2,gr->Arrow2);\r
//-----------------------------------------------------------------------------\r
void mgl_step(HMGL gr, HCDT y, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Step"); return; }\r
gr->SaveState(opt);\r
mglData x(y->GetNx());\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_step_xy(gr,&x,y,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_step_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
void mgl_stem_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *pen, const char *opt)\r
{\r
long i,j,m,mx,my,mz,n=y->GetNx(), pal;\r
- if(x->GetNx()!=n || z->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Stem"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Stem"); return; }\r
+ if(mgl_check_dim1(gr,x,y,z,0,"Stem")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Stem3",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy(); m = z->GetNy() > m ? z->GetNy() : m;\r
bool sh = pen && strchr(pen,'!');\r
\r
- float z0=gr->GetOrgZ('x');\r
+ mreal z0=gr->GetOrgZ('x');\r
char mk=gr->SetPenPal(pen,&pal); gr->Reserve(2*n*m);\r
long n1,n2;\r
for(j=0;j<m;j++)\r
void mgl_stem_xy(HMGL gr, HCDT x, HCDT y, const char *pen, const char *opt)\r
{\r
long i,j,m,mx,my,n=y->GetNx(), pal;\r
- if(x->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Stem"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Stem"); return; }\r
+ if(mgl_check_dim1(gr,x,y,0,0,"Stem")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Stem",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy();\r
bool sh = pen && strchr(pen,'!');\r
\r
- float zVal = gr->Min.z;\r
- float y0=gr->GetOrgY('x');\r
+ mreal zVal = gr->AdjustZMin(), y0=gr->GetOrgY('x'), vv;\r
char mk=gr->SetPenPal(pen,&pal); gr->Reserve(2*n*m);\r
long n1,n2;\r
for(j=0;j<m;j++)\r
for(i=0;i<n;i++)\r
{\r
if(gr->Stop) return;\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my), zVal));\r
+ vv = x->v(i,mx);\r
+ n1 = gr->AddPnt(mglPoint(vv, y->v(i,my), zVal));\r
if(mk) gr->mark_plot(n1,mk);\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx), y0, zVal));\r
+ n2 = gr->AddPnt(mglPoint(vv, y0, zVal));\r
gr->line_plot(n1,n2);\r
if(sh) gr->NextColor(pal);\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_stem(HMGL gr, HCDT y, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Stem"); return; }\r
gr->SaveState(opt);\r
mglData x(y->GetNx());\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_stem_xy(gr,&x,y,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_stem_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
void mgl_bars_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *pen, const char *opt)\r
{\r
long i,j,m,mx,my,mz,n=z->GetNx(), pal,nx=x->GetNx(),ny=y->GetNx();\r
- if(nx<n || ny<n) { gr->SetWarn(mglWarnDim,"Bars"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Bars"); return; }\r
+ if(mgl_check_dim1(gr,x,z,y,0,"Bars",true)) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Bars3",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy(); m = z->GetNy() > m ? z->GetNy() : m;\r
bool wire = pen && strchr(pen,'#');\r
bool above = pen && strchr(pen,'a'), fall = pen && strchr(pen,'f');\r
if(above) fall = false;\r
- float c1,c2,c;\r
+ mreal c1,c2,c;\r
mglPoint p1,p2,p3,p4,nn;\r
long n1,n2,n3,n4;\r
- float *dd=new float[n], x1,x2,y1,y2,z0,zz,zp,d;\r
- memset(dd,0,n*sizeof(float));\r
+ mreal *dd=new mreal[n], x1,x2,y1,y2,z0,zz,zp,d,vv;\r
+ memset(dd,0,n*sizeof(mreal));\r
\r
gr->SetPenPal(pen,&pal);\r
if(wire) gr->Reserve(4*n*m); else gr->Reserve(4*n*m);\r
for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete []dd; return; }\r
- d = i<nx-1 ? x->v(i+1,mx)-x->v(i,mx) : x->v(i,mx)-x->v(i-1,mx);\r
- x1 = x->v(i,mx) + d/2*(1-gr->BarWidth); x2 = x1 + gr->BarWidth*d;\r
- d = i<ny-1 ? y->v(i+1,my)-y->v(i,my) : y->v(i,my)-y->v(i-1,my);\r
- y1 = y->v(i,my) + d/2*(1-gr->BarWidth); y2 = y1 + gr->BarWidth*d;\r
- zz = z->v(i,mz);\r
+ vv = x->v(i,mx); d = i<nx-1 ? x->v(i+1,mx)-vv : vv-x->v(i-1,mx);\r
+ x1 = vv + d/2*(1-gr->BarWidth); x2 = x1 + gr->BarWidth*d;\r
+ vv = y->v(i,my); d = i<ny-1 ? y->v(i+1,my)-vv : vv-y->v(i-1,my);\r
+ y1 = vv + d/2*(1-gr->BarWidth); y2 = y1 + gr->BarWidth*d;\r
+ vv = zz = z->v(i,mz);\r
if(!above)\r
{\r
x2 = (x2-x1)/m; x1 += j*x2; x2 += x1;\r
{ z0 = gr->GetOrgZ('x') + dd[i]; dd[i] += zz; zz += z0; }\r
if(fall) { z0 = zp; zz += z0; zp = zz; }\r
\r
- c = z->v(i,mz)<0 ? c1 : c2;\r
+ c = vv<0 ? c1 : c2;\r
nn = mglPoint(-y->dvx(i,my),x->dvx(i,mx));\r
p1 = mglPoint(x1,y1,zz); p2 = mglPoint(x1,y1,z0);\r
p3 = mglPoint(x2,y2,z0); p4 = mglPoint(x2,y2,zz);\r
void mgl_bars_xy(HMGL gr, HCDT x, HCDT y, const char *pen, const char *opt)\r
{\r
long i,j,m,mx,my,n=y->GetNx(),pal;\r
- if(x->GetNx()<n) { gr->SetWarn(mglWarnDim,"Bars"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Bars"); return; }\r
+ if(mgl_check_dim1(gr,x,y,0,0,"Bars",true)) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Bars",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy();\r
bool sh = pen && strchr(pen,'!');\r
\r
bool wire = pen && strchr(pen,'#');\r
- bool above = pen && strchr(pen,'a')!=0, fall = pen && strchr(pen,'f')!=0;\r
+ bool above = pen && strchr(pen,'a'), fall = pen && strchr(pen,'f');\r
if(above) fall = false;\r
- float c1,c2,c;\r
+ mreal c1,c2,c;\r
long n1,n2,n3,n4;\r
- float *dd=new float[n], x1,x2,yy,y0,yp,d;\r
- memset(dd,0,n*sizeof(float));\r
+ mreal *dd=new mreal[n], x1,x2,yy,y0,yp,d,vv;\r
+ mreal zm = gr->AdjustZMin();\r
+ memset(dd,0,n*sizeof(mreal));\r
\r
gr->SetPenPal(pen,&pal);\r
if(wire) gr->Reserve(4*n*m); else gr->Reserve(4*n*m);\r
c2=c1=gr->NextColor(pal);\r
if(gr->GetNumPal(pal)==2*m && !sh) c2 = gr->NextColor(pal);\r
mx = j<x->GetNy() ? j:0; my = j<y->GetNy() ? j:0;\r
- yp = y0 = gr->GetOrgZ('x');\r
+ yp = y0 = gr->GetOrgY('x');\r
for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete []dd; return; }\r
- d = i<n-1 ? x->v(i+1,mx)-x->v(i,mx) : x->v(i,mx)-x->v(i-1,mx);\r
- x1 = x->v(i,mx) + d/2*(1-gr->BarWidth);\r
- x2 = x1 + gr->BarWidth*d; yy = y->v(i,my);\r
+ vv = x->v(i,mx); d = i<n-1 ? x->v(i+1,mx)-vv : vv-x->v(i-1,mx);\r
+ x1 = vv + d/2*(1-gr->BarWidth); x2 = x1 + gr->BarWidth*d;\r
+ vv = yy = y->v(i,my);\r
if(!above)\r
{ x2 = (x2-x1)/m; x1 += j*x2; x2 += x1; }\r
else\r
{ y0 = gr->GetOrgY('x') + dd[i]; dd[i] += yy; yy += y0; }\r
if(fall) { y0 = yp; yy += y0; yp = yy; }\r
\r
- c = (y->v(i,my)<0) ? c1 : c2;\r
- n1 = gr->AddPnt(mglPoint(x1,yy,gr->Min.z),c);\r
- n2 = gr->AddPnt(mglPoint(x1,y0,gr->Min.z),c);\r
- n3 = gr->AddPnt(mglPoint(x2,y0,gr->Min.z),c);\r
- n4 = gr->AddPnt(mglPoint(x2,yy,gr->Min.z),c);\r
+ c = vv<0 ? c1 : c2;\r
+ n1 = gr->AddPnt(mglPoint(x1,yy,zm),c);\r
+ n2 = gr->AddPnt(mglPoint(x1,y0,zm),c);\r
+ n3 = gr->AddPnt(mglPoint(x2,y0,zm),c);\r
+ n4 = gr->AddPnt(mglPoint(x2,yy,zm),c);\r
if(wire)\r
{\r
gr->line_plot(n1,n2); gr->line_plot(n1,n4);\r
//-----------------------------------------------------------------------------\r
void mgl_bars(HMGL gr, HCDT y, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Bars"); return; }\r
gr->SaveState(opt);\r
mglData x(y->GetNx()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_bars_xy(gr,&x,y,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_bars_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
void mgl_barh_yx(HMGL gr, HCDT y, HCDT v, const char *pen, const char *opt)\r
{\r
long i,j,m,mx,my,n=v->GetNx(),pal;\r
- if(y->GetNx()<n) { gr->SetWarn(mglWarnDim,"Barh"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Barh"); return; }\r
+ if(mgl_check_dim1(gr,y,v,0,0,"Barh",true)) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Barh",cgid++);\r
m = y->GetNy() > v->GetNy() ? y->GetNy() : v->GetNy();\r
bool wire = pen && strchr(pen,'#');\r
bool above = pen && strchr(pen,'a'), fall = pen && strchr(pen,'f');\r
if(above) fall = false;\r
- float c1,c2,c;\r
+ mreal c1,c2,c;\r
long n1,n2,n3,n4;\r
- float *dd=new float[n], y1,y2,xx,x0,xp,d;\r
- memset(dd,0,n*sizeof(float));\r
+ mreal *dd=new mreal[n], y1,y2,xx,x0,xp,d,vv;\r
+ mreal zm = gr->AdjustZMin();\r
+ memset(dd,0,n*sizeof(mreal));\r
\r
gr->SetPenPal(pen,&pal);\r
if(wire) gr->Reserve(4*n*m); else gr->Reserve(4*n*m);\r
for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete []dd; return; }\r
- d = i<n-1 ? y->v(i+1,my)-y->v(i,my) : y->v(i,my)-y->v(i-1,my);\r
- y1 = y->v(i,my) + d/2*(1-gr->BarWidth);\r
- y2 = y1 + gr->BarWidth*d; xx = v->v(i,mx);\r
+ vv = y->v(i,my); d = i<n-1 ? y->v(i+1,my)-vv : vv-y->v(i-1,my);\r
+ y1 = vv + d/2*(1-gr->BarWidth); y2 = y1 + gr->BarWidth*d;\r
+ vv = xx = v->v(i,mx);\r
if(!above)\r
{ y2 = (y2-y1)/m; y1 += j*y2; y2 += y1; }\r
else\r
{ x0 = gr->GetOrgX('y') + dd[i]; dd[i] += xx; xx += x0; }\r
if(fall) { x0 = xp; xx += x0; xp = xx; }\r
\r
- c = (v->v(i,mx)<0) ? c1 : c2;\r
- n1 = gr->AddPnt(mglPoint(xx,y1,gr->Min.z),c);\r
- n2 = gr->AddPnt(mglPoint(xx,y2,gr->Min.z),c);\r
- n3 = gr->AddPnt(mglPoint(x0,y2,gr->Min.z),c);\r
- n4 = gr->AddPnt(mglPoint(x0,y1,gr->Min.z),c);\r
+ c = vv<0 ? c1 : c2;\r
+ n1 = gr->AddPnt(mglPoint(xx,y1,zm),c);\r
+ n2 = gr->AddPnt(mglPoint(xx,y2,zm),c);\r
+ n3 = gr->AddPnt(mglPoint(x0,y2,zm),c);\r
+ n4 = gr->AddPnt(mglPoint(x0,y1,zm),c);\r
if(wire)\r
{\r
gr->line_plot(n1,n2); gr->line_plot(n1,n4);\r
//-----------------------------------------------------------------------------\r
void mgl_barh(HMGL gr, HCDT v, const char *pen, const char *opt)\r
{\r
- if(v->GetNx()<2) { gr->SetWarn(mglWarnLow,"Barh"); return; }\r
gr->SaveState(opt);\r
mglData y(v->GetNx()+1);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_barh_yx(gr,&y,v,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_barh_yx_(uintptr_t *gr, uintptr_t *y, uintptr_t *v, const char *pen, const char *opt,int l,int lo)\r
double sgn(double a);\r
int mgl_cmp_flt(const void *a, const void *b)\r
{\r
- const float *aa = (const float *)a;\r
- const float *bb = (const float *)b;\r
+ const mreal *aa = (const mreal *)a;\r
+ const mreal *bb = (const mreal *)b;\r
return int(sgn(*aa-*bb));\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_boxplot_xy(HMGL gr, HCDT x, HCDT y, const char *pen, const char *opt)\r
{\r
long n=y->GetNx(), m=y->GetNy(), nx=x->GetNx();\r
- if(nx<n) { gr->SetWarn(mglWarnDim,"BoxPlot"); return; }\r
+ if(nx<n || nx<2) { gr->SetWarn(mglWarnDim,"BoxPlot"); return; }\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("BoxPlot",cgid++);\r
- float *b = new float[5*n], *d = new float[m], x1, x2, dd;\r
- float zVal = gr->Min.z;\r
+ mreal *b = new mreal[5*n], *d = new mreal[m], x1, x2, dd;\r
+ mreal zVal = gr->AdjustZMin(), vv;\r
bool sh = pen && strchr(pen,'!');\r
register long i,j;\r
for(i=0;i<n;i++) // find quartiles by itself\r
{\r
if(gr->Stop) { delete []d; return; }\r
register long mm,k;\r
- for(mm=j=0;j<m;j++) if(!mgl_isnan(y->v(i,j)))\r
- { d[mm]=y->v(i,j); mm++; }\r
+ for(mm=j=0;j<m;j++)\r
+ {\r
+ vv = y->v(i,j);\r
+ if(!mgl_isnan(vv)) { d[mm]=vv; mm++; }\r
+ }\r
if(m==0) { b[i]=NAN; break; }\r
- qsort(d, mm, sizeof(float), mgl_cmp_flt);\r
+ qsort(d, mm, sizeof(mreal), mgl_cmp_flt);\r
b[i] = d[0]; b[i+4*n] = d[mm-1]; k = mm/4;\r
b[i+n] = (mm%4) ? d[k] : (d[k]+d[k-1])/2.;\r
b[i+2*n] = (mm%2) ? d[mm/2] : (d[mm/2]+d[mm/2-1])/2.;\r
for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete []b; return; }\r
- dd = i<nx-1 ? x->v(i+1)-x->v(i) : x->v(i)-x->v(i-1);\r
- x1 = x->v(i) + dd/2*(1-gr->BarWidth);\r
+ vv = x->v(i);\r
+ dd = i<nx-1 ? x->v(i+1)-vv : vv-x->v(i-1);\r
+ x1 = vv + dd/2*(1-gr->BarWidth);\r
x2 = x1 + gr->BarWidth*dd;\r
for(j=0;j<5;j++) // horizontal lines\r
{\r
//-----------------------------------------------------------------------------\r
void mgl_boxplot(HMGL gr, HCDT y, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"BoxPlot"); return; }\r
gr->SaveState(opt);\r
mglData x(y->GetNx()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_boxplot_xy(gr,&x,y,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_boxplot_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, const char *pen, const char *opt,int l,int lo)\r
void mgl_error_exy(HMGL gr, HCDT x, HCDT y, HCDT ex, HCDT ey, const char *pen, const char *opt)\r
{\r
long i,j,k,m,mx,my,m1,m2,n=ey->GetNx(),pal;\r
- if(x->GetNx()!=n || y->GetNx()!=n || ex->GetNx()!=n )\r
- { gr->SetWarn(mglWarnDim,"Error"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Error"); return; }\r
+ if(mgl_check_dim1(gr,x,y,ey,ex,"Error")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Error",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy();\r
\r
bool ma = pen && strchr(pen,'@');\r
char mk = gr->SetPenPal(pen,&pal);\r
- float zVal=gr->Min.z; gr->Reserve(5*n*m);\r
+ mreal zVal=gr->AdjustZMin(), vx, vy, ve, vf;\r
+ gr->Reserve(5*n*m);\r
if(ma && (mk==0 || !strchr("PXsSdD+xoOC",mk) )) mk = 'S';\r
long n1,n2,n3,n4;\r
mglPoint q(NAN,NAN);\r
{\r
if(strchr("PXsS",mk)) for(i=0;i<n;i++) // boundary of square\r
{\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx)-ex->v(i,m1), y->v(i,my)+ey->v(i,m2), zVal),-1,q,-1,11);\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx)-ex->v(i,m1), y->v(i,my)-ey->v(i,m2), zVal),-1,q,-1,11);\r
- n3 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1), y->v(i,my)+ey->v(i,m2), zVal),-1,q,-1,11);\r
- n4 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1), y->v(i,my)-ey->v(i,m2), zVal),-1,q,-1,11);\r
+ vx=x->v(i,mx); ve=ex->v(i,m1); vy=y->v(i,my); vf=ey->v(i,m2);\r
+ n1 = gr->AddPnt(mglPoint(vx-ve, vy+vf, zVal),-1,q,-1,11);\r
+ n2 = gr->AddPnt(mglPoint(vx-ve, vy-vf, zVal),-1,q,-1,11);\r
+ n3 = gr->AddPnt(mglPoint(vx+ve, vy+vf, zVal),-1,q,-1,11);\r
+ n4 = gr->AddPnt(mglPoint(vx+ve, vy-vf, zVal),-1,q,-1,11);\r
gr->line_plot(n1,n2); gr->line_plot(n1,n3);\r
gr->line_plot(n4,n2); gr->line_plot(n4,n3);\r
if(sh) gr->NextColor(pal);\r
}\r
if(strchr("dD",mk)) for(i=0;i<n;i++) // boundary of rhomb\r
{\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my)+ey->v(i,m2), zVal),-1,q,-1,11);\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx)-ex->v(i,m1), y->v(i,my), zVal),-1,q,-1,11);\r
- n3 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my)-ey->v(i,m2), zVal),-1,q,-1,11);\r
- n4 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1), y->v(i,my), zVal),-1,q,-1,11);\r
+ vx=x->v(i,mx); ve=ex->v(i,m1); vy=y->v(i,my); vf=ey->v(i,m2);\r
+ n1 = gr->AddPnt(mglPoint(vx, vy+vf, zVal),-1,q,-1,11);\r
+ n2 = gr->AddPnt(mglPoint(vx-ve, vy, zVal),-1,q,-1,11);\r
+ n3 = gr->AddPnt(mglPoint(vx, vy-vf, zVal),-1,q,-1,11);\r
+ n4 = gr->AddPnt(mglPoint(vx+ve, vy, zVal),-1,q,-1,11);\r
gr->line_plot(n1,n2); gr->line_plot(n2,n3);\r
gr->line_plot(n3,n4); gr->line_plot(n4,n1);\r
if(sh) gr->NextColor(pal);\r
}\r
if(strchr("oOC",mk)) for(i=0;i<n;i++) // circle\r
{\r
+ vx=x->v(i,mx); ve=ex->v(i,m1); vy=y->v(i,my); vf=ey->v(i,m2);\r
for(k=0,n2=-1;k<=40;k++)\r
{\r
n1 = n2;\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1)*cos(k*M_PI/20),\r
- y->v(i,my)+ey->v(i,m2)*sin(k*M_PI/20), zVal),-1,q,-1,11);\r
+ n2 = gr->AddPnt(mglPoint(vx+ve*cos(k*M_PI/20),\r
+ vy+vf*sin(k*M_PI/20), zVal),-1,q,-1,11);\r
if(k>0) gr->line_plot(n1,n2);\r
}\r
if(sh) gr->NextColor(pal);\r
switch(mk)\r
{\r
case 'P': case '+': for(i=0;i<n;i++)\r
- {\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my)+ey->v(i,m2), zVal),-1,q,-1,11);\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx)-ex->v(i,m1), y->v(i,my), zVal),-1,q,-1,11);\r
- n3 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my)-ey->v(i,m2), zVal),-1,q,-1,11);\r
- n4 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1), y->v(i,my), zVal),-1,q,-1,11);\r
- gr->line_plot(n1,n3); gr->line_plot(n2,n4);\r
- if(sh) gr->NextColor(pal);\r
- } break;\r
+ {\r
+ vx=x->v(i,mx); ve=ex->v(i,m1); vy=y->v(i,my); vf=ey->v(i,m2);\r
+ n1 = gr->AddPnt(mglPoint(vx, vy+vf, zVal),-1,q,-1,11);\r
+ n2 = gr->AddPnt(mglPoint(vx-ve, vy, zVal),-1,q,-1,11);\r
+ n3 = gr->AddPnt(mglPoint(vx, vy-vf, zVal),-1,q,-1,11);\r
+ n4 = gr->AddPnt(mglPoint(vx+ve, vy, zVal),-1,q,-1,11);\r
+ gr->line_plot(n1,n3); gr->line_plot(n2,n4);\r
+ if(sh) gr->NextColor(pal);\r
+ } break;\r
case 'X': case 'x': for(i=0;i<n;i++)\r
- {\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx)-ex->v(i,m1), y->v(i,my)+ey->v(i,m2), zVal),-1,q,-1,11);\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx)-ex->v(i,m1), y->v(i,my)-ey->v(i,m2), zVal),-1,q,-1,11);\r
- n3 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1), y->v(i,my)+ey->v(i,m2), zVal),-1,q,-1,11);\r
- n4 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1), y->v(i,my)-ey->v(i,m2), zVal),-1,q,-1,11);\r
- gr->line_plot(n1,n3); gr->line_plot(n2,n4);\r
- if(sh) gr->NextColor(pal);\r
- } break;\r
+ {\r
+ vx=x->v(i,mx); ve=ex->v(i,m1); vy=y->v(i,my); vf=ey->v(i,m2);\r
+ n1 = gr->AddPnt(mglPoint(vx-ve, vy+vf, zVal),-1,q,-1,11);\r
+ n2 = gr->AddPnt(mglPoint(vx-ve, vy-vf, zVal),-1,q,-1,11);\r
+ n3 = gr->AddPnt(mglPoint(vx+ve, vy+vf, zVal),-1,q,-1,11);\r
+ n4 = gr->AddPnt(mglPoint(vx+ve, vy-vf, zVal),-1,q,-1,11);\r
+ gr->line_plot(n1,n3); gr->line_plot(n2,n4);\r
+ if(sh) gr->NextColor(pal);\r
+ } break;\r
case 'S': for(i=0;i<n;i++)\r
- {\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx)-ex->v(i,m1), y->v(i,my)+ey->v(i,m2), zVal),-1,q,-1,11);\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx)-ex->v(i,m1), y->v(i,my)-ey->v(i,m2), zVal),-1,q,-1,11);\r
- n3 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1), y->v(i,my)+ey->v(i,m2), zVal),-1,q,-1,11);\r
- n4 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1), y->v(i,my)-ey->v(i,m2), zVal),-1,q,-1,11);\r
- gr->quad_plot(n1,n2,n3,n4);\r
- if(sh) gr->NextColor(pal);\r
- } break;\r
+ {\r
+ vx=x->v(i,mx); ve=ex->v(i,m1); vy=y->v(i,my); vf=ey->v(i,m2);\r
+ n1 = gr->AddPnt(mglPoint(vx-ve, vy+vf, zVal),-1,q,-1,11);\r
+ n2 = gr->AddPnt(mglPoint(vx-ve, vy-vf, zVal),-1,q,-1,11);\r
+ n3 = gr->AddPnt(mglPoint(vx+ve, vy+vf, zVal),-1,q,-1,11);\r
+ n4 = gr->AddPnt(mglPoint(vx+ve, vy-vf, zVal),-1,q,-1,11);\r
+ gr->quad_plot(n1,n2,n3,n4);\r
+ if(sh) gr->NextColor(pal);\r
+ } break;\r
case 'D': for(i=0;i<n;i++)\r
- {\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my)+ey->v(i,m2), zVal),-1,q,-1,11);\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx)-ex->v(i,m1), y->v(i,my), zVal),-1,q,-1,11);\r
- n3 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my)-ey->v(i,m2), zVal),-1,q,-1,11);\r
- n4 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1), y->v(i,my), zVal),-1,q,-1,11);\r
- gr->quad_plot(n1,n2,n3,n4);\r
- if(sh) gr->NextColor(pal);\r
- } break;\r
+ {\r
+ vx=x->v(i,mx); ve=ex->v(i,m1); vy=y->v(i,my); vf=ey->v(i,m2);\r
+ n1 = gr->AddPnt(mglPoint(vx, vy+vf, zVal),-1,q,-1,11);\r
+ n2 = gr->AddPnt(mglPoint(vx-ve, vy, zVal),-1,q,-1,11);\r
+ n3 = gr->AddPnt(mglPoint(vx, vy-vf, zVal),-1,q,-1,11);\r
+ n4 = gr->AddPnt(mglPoint(vx+ve, vy, zVal),-1,q,-1,11);\r
+ gr->quad_plot(n1,n2,n3,n4);\r
+ if(sh) gr->NextColor(pal);\r
+ } break;\r
case 'O': for(i=0;i<n;i++)\r
+ {\r
+ vx=x->v(i,mx); ve=ex->v(i,m1); vy=y->v(i,my); vf=ey->v(i,m2);\r
+ n3 = gr->AddPnt(mglPoint(vx,vy,zVal));\r
+ for(k=0,n2=-1;k<=40;k++)\r
{\r
- n3 = gr->AddPnt(mglPoint(x->v(i,mx),y->v(i,my),zVal));\r
- for(k=0,n2=-1;k<=40;k++)\r
- {\r
- n1 = n2;\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1)*cos(k*M_PI/20),\r
- y->v(i,my)+ey->v(i,m2)*sin(k*M_PI/20), zVal),-1,q,-1,11);\r
- if(k>0) gr->trig_plot(n1,n2,n3);\r
- }\r
- if(sh) gr->NextColor(pal);\r
- } break;\r
- case 'C': for(i=0;i<n;i++)\r
- {\r
- gr->mark_plot(gr->AddPnt(mglPoint(x->v(i,mx),y->v(i,my),zVal),-1,q,-1,3), '.');\r
- if(sh) gr->NextColor(pal);\r
+ n1 = n2;\r
+ n2 = gr->AddPnt(mglPoint(vx+ve*cos(k*M_PI/20),\r
+ vy+vf*sin(k*M_PI/20), zVal),-1,q,-1,11);\r
+ if(k>0) gr->trig_plot(n1,n2,n3);\r
}\r
+ if(sh) gr->NextColor(pal);\r
+ } break;\r
+ case 'C': for(i=0;i<n;i++)\r
+ {\r
+ vx=x->v(i,mx); ve=ex->v(i,m1); vy=y->v(i,my); vf=ey->v(i,m2);\r
+ gr->mark_plot(gr->AddPnt(mglPoint(vx,vy,zVal),-1,q,-1,3), '.');\r
+ if(sh) gr->NextColor(pal);\r
+ }\r
}\r
}\r
else for(i=0;i<n;i++)\r
{\r
- if(mk) gr->mark_plot(gr->AddPnt(mglPoint(x->v(i,mx),y->v(i,my),zVal)), mk);\r
+ vx=x->v(i,mx); ve=ex->v(i,m1); vy=y->v(i,my); vf=ey->v(i,m2);\r
+ if(mk) gr->mark_plot(gr->AddPnt(mglPoint(vx,vy,zVal)), mk);\r
\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my)+ey->v(i,m2), zVal),-1,q,-1,11);\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx), y->v(i,my)-ey->v(i,m2), zVal),-1,q,-1,11);\r
+ n1 = gr->AddPnt(mglPoint(vx, vy+vf, zVal),-1,q,-1,11);\r
+ n2 = gr->AddPnt(mglPoint(vx, vy-vf, zVal),-1,q,-1,11);\r
gr->line_plot(n1,n2); gr->arrow_plot(n1,n2,'I'); gr->arrow_plot(n2,n1,'I');\r
\r
- n1 = gr->AddPnt(mglPoint(x->v(i,mx)+ex->v(i,m1), y->v(i,my), zVal),-1,q,-1,11);\r
- n2 = gr->AddPnt(mglPoint(x->v(i,mx)-ex->v(i,m1), y->v(i,my), zVal),-1,q,-1,11);\r
+ n1 = gr->AddPnt(mglPoint(vx+ve, vy, zVal),-1,q,-1,11);\r
+ n2 = gr->AddPnt(mglPoint(vx-ve, vy, zVal),-1,q,-1,11);\r
gr->line_plot(n1,n2); gr->arrow_plot(n1,n2,'I'); gr->arrow_plot(n2,n1,'I');\r
if(sh) gr->NextColor(pal);\r
}\r
mglData ex(y->GetNx());\r
ex.Fill(NAN,NAN);\r
mgl_error_exy(gr,x,y,&ex,ey,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_error(HMGL gr, HCDT y, HCDT ey, const char *pen, const char *opt)\r
mglData x(y->GetNx());\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_error_xy(gr,&x,y,ey,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_error_(uintptr_t *gr, uintptr_t *y, uintptr_t *ey, const char *pen, const char *opt,int l,int lo)\r
// Chart series\r
//\r
//-----------------------------------------------------------------------------\r
-void face_plot(mglBase *gr, mglPoint o, mglPoint d1, mglPoint d2, float c, bool wire)\r
+void face_plot(mglBase *gr, mglPoint o, mglPoint d1, mglPoint d2, mreal c, bool wire)\r
{\r
const int num=10;\r
mglPoint p,nn=d1^d2;\r
if(cols) for(i=0;i<long(strlen(cols));i++)\r
if(strchr("wkrgbcymhRGBCYMHWlenuqpLENUQP ",cols[i])) j++;\r
if(j==0) cols = MGL_DEF_PAL;\r
- float *c = new float[strlen(cols)+1],cc;\r
+ mreal *c = new mreal[strlen(cols)+1],cc;\r
long nc=0; // number of colors\r
for(i=0;i<long(strlen(cols));i++)\r
if(strchr("wkrgbcymhRGBCYMHWlenuqpLENUQP ",cols[i]))\r
{ c[nc]=gr->AddTexture(cols[i]); nc++; }\r
\r
- float dy = (gr->Max.y-gr->Min.y)/a->GetNy(), dx, ss, cs, x1, y1, dz=gr->Max.z-gr->Min.z;\r
+ mreal dy = (gr->Max.y-gr->Min.y)/a->GetNy(), dx, ss, cs, x1, y1, dz=gr->Max.z-gr->Min.z, vv;\r
mglPoint d1,d2,o;\r
\r
for(j=0;j<a->GetNy();j++)\r
for(cs=0,i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete []c; return; }\r
- dx = a->v(i,j)/ss; cc = c[i%nc];\r
+ vv = a->v(i,j); dx = vv/ss; cc = c[i%nc];\r
if(dx==0) continue;\r
x1 = gr->Min.x + (gr->Max.x-gr->Min.x)*cs/ss; dx *= (gr->Max.x-gr->Min.x);\r
if(cc>=0)\r
face_plot(gr,mglPoint(x1+dx,y1+dy,gr->Max.z),mglPoint(-dx,0,0),mglPoint(0,-dy,0),cc,wire);\r
face_plot(gr,mglPoint(x1+dx,y1+dy,gr->Max.z),mglPoint(0,-dy,0),mglPoint(0,0,-dz),cc,wire);\r
}\r
- cs += a->v(i,j);\r
+ cs += vv;\r
}\r
}\r
gr->EndGroup(); delete []c;\r
void mgl_mark_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT r, const char *pen, const char *opt)\r
{\r
long j,m,mx,my,mz,mr,n=y->GetNx(),pal;\r
- if(x->GetNx()!=n || z->GetNx()!=n || r->GetNx()!=n)\r
- { gr->SetWarn(mglWarnDim,"Mark"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Mark"); return; }\r
+ if(mgl_check_dim1(gr,x,y,z,r,"Mark")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Mark",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy();\r
{\r
gr->SaveState(opt);\r
mglData z(y->GetNx());\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_mark_xyz(gr,x,y,&z,r,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_mark_y(HMGL gr, HCDT y, HCDT r, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Mark"); return; }\r
+ register long n=y->GetNx();\r
+ if(n<2) { gr->SetWarn(mglWarnLow,"Mark"); return; }\r
gr->SaveState(opt);\r
- mglData x(y->GetNx()), z(y->GetNx());\r
+ mglData x(n), z(n);\r
x.Fill(gr->Min.x,gr->Max.x);\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_mark_xyz(gr,&x,y,&z,r,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_mark_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *r, const char *pen, const char *opt,int l,int lo)\r
void mgl_tube_xyzr(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT r, const char *pen, const char *opt)\r
{\r
long j,m,mx,my,mz,mr,n=y->GetNx(),pal;\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Tube"); return; }\r
- if(x->GetNx()!=n || z->GetNx()!=n || r->GetNx()!=n)\r
- { gr->SetWarn(mglWarnDim,"Tube"); return; }\r
+ if(mgl_check_dim1(gr,x,y,z,r,"Tube")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Tube",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy();\r
l = mglPoint(x->dvx(i,mx),y->dvx(i,my),z->dvx(i,mz));\r
t = !l; t.Normalize(); u = t^l; u.Normalize();\r
q = mglPoint(x->v(i,mx),y->v(i,my),z->v(i,mz));\r
- float si,co,ff, rr=r->v(i,mr), dr=r->dvx(i,mr);\r
+ mreal si,co,ff, rr=r->v(i,mr), dr=r->dvx(i,mr);\r
for(k=0;k<num;k++)\r
{\r
if(gr->Stop) { delete []nn; return; }\r
{\r
gr->SaveState(opt);\r
mglData z(y->GetNx());\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tube_xyzr(gr,x,y,&z,r,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_tube_r(HMGL gr, HCDT y, HCDT r, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Tube"); return; }\r
+ register long n=y->GetNx();\r
+ if(n<2) { gr->SetWarn(mglWarnLow,"Tube"); return; }\r
gr->SaveState(opt);\r
- mglData x(y->GetNx()), z(y->GetNx());\r
+ mglData x(n), z(n);\r
x.Fill(gr->Min.x,gr->Max.x);\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tube_xyzr(gr,&x,y,&z,r,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_tube(HMGL gr, HCDT y, float rr, const char *pen, const char *opt)\r
+void mgl_tube(HMGL gr, HCDT y, mreal rr, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Tube"); return; }\r
+ register long n=y->GetNx();\r
+ if(n<2) { gr->SetWarn(mglWarnLow,"Tube"); return; }\r
gr->SaveState(opt);\r
- mglData x(y->GetNx()), r(y->GetNx()), z(y->GetNx());\r
+ mglData x(n), r(n), z(n);\r
x.Fill(gr->Min.x,gr->Max.x);\r
r.Fill(rr,rr);\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tube_xyzr(gr,&x,y,&z,&r,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_tube_xy(HMGL gr, HCDT x, HCDT y, float rr, const char *pen, const char *opt)\r
+void mgl_tube_xy(HMGL gr, HCDT x, HCDT y, mreal rr, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Tube"); return; }\r
+ register long n=y->GetNx();\r
+ if(n<2) { gr->SetWarn(mglWarnLow,"Tube"); return; }\r
gr->SaveState(opt);\r
- mglData r(y->GetNx()), z(y->GetNx());\r
+ mglData r(n), z(n);\r
r.Fill(rr,rr);\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tube_xyzr(gr,x,y,&z,&r,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_tube_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, float rr, const char *pen, const char *opt)\r
+void mgl_tube_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, mreal rr, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Tube"); return; }\r
gr->SaveState(opt);\r
mglData r(y->GetNx());\r
r.Fill(rr,rr);\r
mgl_tube_xyzr(gr,x,y,z,&r,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_tube_xyzr_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *r, const char *pen, const char *opt,int l,int lo)\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_tube_r(_GR_,_DA_(y),_DA_(r),s,o); delete []s; delete []o; }\r
//-----------------------------------------------------------------------------\r
-void mgl_tube_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, float *r, const char *pen, const char *opt,int l,int lo)\r
+void mgl_tube_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, mreal *r, const char *pen, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,pen,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_tube_xyz(_GR_,_DA_(x),_DA_(y),_DA_(z),*r,s,o); delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_tube_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, float *r, const char *pen, const char *opt,int l,int lo)\r
+void mgl_tube_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, mreal *r, const char *pen, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,pen,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_tube_xy(_GR_,_DA_(x),_DA_(y),*r,s,o); delete []s; delete []o; }\r
//-----------------------------------------------------------------------------\r
-void mgl_tube_(uintptr_t *gr, uintptr_t *y, float *r, const char *pen, const char *opt,int l,int lo)\r
+void mgl_tube_(uintptr_t *gr, uintptr_t *y, mreal *r, const char *pen, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,pen,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_tube(_GR_,_DA_(y),*r,s,o);\r
void mgl_tape_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *pen, const char *opt)\r
{\r
long j,m,mx,my,mz,n=y->GetNx(),pal;\r
- if(x->GetNx()!=n || z->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Tape"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Tape"); return; }\r
+ if(mgl_check_dim1(gr,x,y,z,0,"Tape")) return;\r
+\r
static int cgid=1; gr->StartGroup("Tape",cgid++);\r
- float ll, rr = gr->SaveState(opt);\r
+ mreal ll, rr = gr->SaveState(opt);\r
if(rr==0 || mgl_isnan(rr)) rr = mgl_norm(gr->Max-gr->Min)*gr->BarWidth/25;\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy(); m = z->GetNy() > m ? z->GetNy() : m;\r
gr->SetPenPal(pen,&pal); gr->Reserve(4*n*m);\r
long n1=-1,n2=-1,n3=-1,n4=-1, m1=-1,m2=-1,m3=-1,m4=-1;\r
bool sh = pen && strchr(pen,'!'), xo = pen && strchr(pen,'x'), zo = pen && strchr(pen,'z'), wire = pen && strchr(pen,'#');\r
if(!xo && !zo) xo = zo = true;\r
- float c1,c2;\r
+ mreal c1,c2;\r
\r
for(j=0;j<m;j++)\r
{\r
q1 = mglPoint(-l.y,l.x,0); ll = mgl_norm(q1);\r
if(ll) q1 /= ll; else q1 = mglPoint(0,1,0);\r
q2 = (q1^l);\r
- if(xo) { n1 = gr->AddPnt(p2,c1,q2,-1,3); n2 = gr->AddPnt(p2+rr*q1,c1,q2,-1,3); }\r
- if(zo) { n3 = gr->AddPnt(p2,c2,q1,-1,3); n4 = gr->AddPnt(p2+rr*q2,c2,q1,-1,3); }\r
+ if(p2>gr->Min && p2<gr->Max)\r
+ {\r
+ if(xo) { n1 = gr->AddPnt(p2,c1,q2,-1,3); n2 = gr->AddPnt(p2+rr*q1,c1,q2,-1,3); }\r
+ if(zo) { n3 = gr->AddPnt(p2,c2,q1,-1,3); n4 = gr->AddPnt(p2+rr*q2,c2,q1,-1,3); }\r
+ }\r
+ else { n1=n2=n3=n4=-1; }\r
register long i;\r
for(i=1;i<n;i++)\r
{\r
l = p2-p1; l /= mgl_norm(l);\r
q1 -= l*(l*q1); q1/= mgl_norm(q1); q2 = (q1^l);\r
m1 = n1; m2 = n2; m3 = n3; m4 = n4;\r
- if(xo)\r
+ if(p2>gr->Min && p2<gr->Max)\r
{\r
- n1 = gr->AddPnt(p2,c1,wire?qn:q2,-1,3);\r
- n2 = gr->AddPnt(p2+rr*q1,c1,wire?qn:q2,-1,3);\r
- if(wire) gr->line_plot(m2,n2);\r
- else gr->quad_plot(n1,n2,m1,m2);\r
- }\r
- if(zo)\r
- {\r
- n3 = gr->AddPnt(p2,c2,wire?qn:q1,-1,3);\r
- n4 = gr->AddPnt(p2+rr*q2,c2,wire?qn:q1,-1,3);\r
- if(wire) gr->line_plot(m4,n4);\r
- else gr->quad_plot(n3,n4,m3,m4);\r
+ if(xo)\r
+ {\r
+ n1 = gr->AddPnt(p2,c1,wire?qn:q2,-1,3);\r
+ n2 = gr->AddPnt(p2+rr*q1,c1,wire?qn:q2,-1,3);\r
+ if(wire) gr->line_plot(m2,n2);\r
+ else gr->quad_plot(n1,n2,m1,m2);\r
+ }\r
+ if(zo)\r
+ {\r
+ n3 = gr->AddPnt(p2,c2,wire?qn:q1,-1,3);\r
+ n4 = gr->AddPnt(p2+rr*q2,c2,wire?qn:q1,-1,3);\r
+ if(wire) gr->line_plot(m4,n4);\r
+ else gr->quad_plot(n3,n4,m3,m4);\r
+ }\r
}\r
if(sh) c2=c1=gr->NextColor(pal);\r
}\r
{\r
gr->SaveState(opt);\r
mglData z(y->GetNx());\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tape_xyz(gr,x,y,&z,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_tape(HMGL gr, HCDT y, const char *pen, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"Plot"); return; }\r
+ register long n=y->GetNx();\r
+ if(n<2) { gr->SetWarn(mglWarnLow,"Plot"); return; }\r
gr->SaveState(opt);\r
- mglData x(y->GetNx()), z(y->GetNx());\r
+ mglData x(n), z(n);\r
x.Fill(gr->Min.x,gr->Max.x);\r
- z.Fill(gr->Min.z,gr->Min.z);\r
+ mreal zm = gr->AdjustZMin(); z.Fill(zm,zm);\r
mgl_tape_xyz(gr,&x,y,&z,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_tape_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
+#include <png.h>\r
#include <stdio.h>\r
#include <time.h>\r
-#include <zlib.h>\r
#include "mgl2/canvas.h"\r
#include "mgl2/canvas_cf.h"\r
\r
-#include "oPRCFile.h"\r
+#include "prc/oPRCFile.h"\r
#include <map>\r
#include <utility>\r
#include <string.h>\r
#include <iostream>\r
#include <iomanip>\r
#include <fstream>\r
-#include <png.h>\r
\r
#if MGL_HAVE_PDF\r
-#include <stdlib.h>\r
#include <setjmp.h>\r
-#include <math.h>\r
#include <hpdf.h>\r
#include <hpdf_u3d.h>\r
#include <hpdf_annotation.h>\r
};\r
//-----------------------------------------------------------------------------\r
struct prctriangles {\r
- prctriangles(const HMGL g) : samecolour(true), colourset(false),\r
- gr(g), ntxt(g->GetTxtNum()) {}\r
+ prctriangles(const HMGL g) : samecolour(true), samealpha(true),\r
+ gr(g), ntxt(g->GetTxtNum()), vertexcolor(g->get(MGL_PREFERVC)) {}\r
std::map<PRCVector3d,uint32_t> points;\r
std::map<PRCVector2d,uint32_t> texturecoords;\r
+ std::map<RGBAColour,uint32_t> colours;\r
std::vector<prctriangle> triangles;\r
- RGBAColour colour;\r
+ RGBAColour commoncolour;\r
bool samecolour;\r
- bool colourset;\r
+ float commonalpha;\r
+ bool samealpha;\r
const HMGL gr;\r
const size_t ntxt;\r
- \r
- \r
+ bool vertexcolor;\r
+\r
+\r
uint32_t addPoint(const mglPnt& p)\r
{\r
const PRCVector3d point(p.x,p.y,p.z);\r
- \r
+\r
std::map<PRCVector3d,uint32_t>::iterator pPoint = points.find(point);\r
if(pPoint!=points.end())\r
return pPoint->second;\r
return point_index;\r
}\r
}\r
- \r
+\r
uint32_t addPoint(float x, float y, float z)\r
{\r
const PRCVector3d point(x,y,z);\r
- \r
+\r
std::map<PRCVector3d,uint32_t>::iterator pPoint = points.find(point);\r
if(pPoint!=points.end())\r
return pPoint->second;\r
return point_index;\r
}\r
}\r
- \r
+\r
void writePoints(double (*P)[3])\r
{\r
for(std::map<PRCVector3d,uint32_t>::const_iterator pPoint = points.begin(); pPoint != points.end(); pPoint++)\r
P[pPoint->second][2] = pPoint->first.z;\r
}\r
}\r
- \r
- uint32_t addTextureCoords(const mglPnt& p)\r
+\r
+ uint32_t addColourInfo(const mglPnt& p)\r
{\r
- const float u = ((1-p.ta)*(512-2)+1)/512;\r
- const float v = ((1-p.c/ntxt)*(512*ntxt-2) + 1)/(512*ntxt);\r
- \r
- const PRCVector2d point(u, v);\r
- \r
- if (colourset) {\r
- if (samecolour) {\r
- if (colour.R != p.r || colour.G != p.g || colour.B != p.b || colour.A != p.a)\r
- samecolour = false;\r
+ const RGBAColour colour(p.r,p.g,p.b,p.a);\r
+\r
+ if (colours.empty() && texturecoords.empty()) {\r
+ commoncolour = colour;\r
+ commonalpha = p.a;\r
+ }\r
+ if (samecolour) {\r
+ if (commoncolour != colour)\r
+ samecolour = false;\r
+ }\r
+ if (samealpha) {\r
+ if (commonalpha != p.a)\r
+ samealpha = false;\r
+ }\r
+\r
+ if (vertexcolor) {\r
+ std::map<RGBAColour,uint32_t>::iterator pColour = colours.find(colour);\r
+ if(pColour!=colours.end())\r
+ return pColour->second;\r
+ else\r
+ {\r
+ const uint32_t colour_index = colours.size();\r
+ colours.insert(std::make_pair(colour,colour_index));\r
+ return colour_index;\r
+ }\r
+ } else {\r
+ const float u = p.ta;\r
+ const float v = 1 - p.c/ntxt;\r
+\r
+ const PRCVector2d point(u, v);\r
+ std::map<PRCVector2d,uint32_t>::iterator pPoint = texturecoords.find(point);\r
+ if(pPoint!=texturecoords.end())\r
+ return pPoint->second;\r
+ else\r
+ {\r
+ const uint32_t point_index = texturecoords.size();\r
+ texturecoords.insert(std::make_pair(point,point_index));\r
+ return point_index;\r
}\r
}\r
- else {\r
- colour.Set(p.r, p.g, p.b, p.a);\r
- colourset = true;\r
- }\r
- \r
- \r
- std::map<PRCVector2d,uint32_t>::iterator pPoint = texturecoords.find(point);\r
- if(pPoint!=texturecoords.end())\r
- return pPoint->second;\r
- else\r
+ }\r
+\r
+ void writeTextureCoords(double (*T)[2])\r
+ {\r
+ for(std::map<PRCVector2d,uint32_t>::const_iterator pPoint = texturecoords.begin(); pPoint != texturecoords.end(); pPoint++)\r
{\r
- const uint32_t point_index = texturecoords.size();\r
- texturecoords.insert(std::make_pair(point,point_index));\r
- return point_index;\r
+ T[pPoint->second][0] = pPoint->first.x;\r
+ T[pPoint->second][1] = pPoint->first.y;\r
}\r
}\r
- \r
- void writeTextureCoords(double (*P)[2])\r
+\r
+ void writeColours(RGBAColour *C)\r
{\r
- for(std::map<PRCVector2d,uint32_t>::const_iterator pPoint = texturecoords.begin(); pPoint != texturecoords.end(); pPoint++)\r
+ for(std::map<RGBAColour,uint32_t>::const_iterator pColour = colours.begin(); pColour != colours.end(); pColour++)\r
{\r
- P[pPoint->second][0] = pPoint->first.x;\r
- P[pPoint->second][1] = pPoint->first.y;\r
+ C[pColour->second] = pColour->first;\r
}\r
}\r
};\r
+\r
//-----------------------------------------------------------------------------\r
/* structure to store PNG image bytes */\r
struct png_buf\r
{\r
struct png_buf* p=(struct png_buf*)png_get_io_ptr(png_ptr);\r
size_t nsize = p->size + length;\r
- \r
+\r
/* allocate or grow buffer */\r
if(p->data)\r
p->data = (uint8_t*)realloc(p->data, nsize);\r
else\r
p->data = (uint8_t*)malloc(nsize);\r
- \r
+\r
if(!p->data)\r
png_error(png_ptr, "Write Error - no mem");\r
- \r
+\r
/* copy new bytes to end of buffer */\r
memcpy(p->data + p->size, data, length);\r
p->size += length;\r
}\r
//-----------------------------------------------------------------------------\r
-void my_png_flush(png_structp png_ptr)\r
+void my_png_flush(png_structp /*png_ptr*/)\r
{\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_write_prc(HMGL gr, const char *fname,const char *descr, int make_pdf)\r
+void mgl_write_prc(HMGL gr, const char *fname,const char */*descr*/, int make_pdf)\r
{\r
if(gr->GetPrmNum()<=0) return; // nothing to do\r
-// register size_t i,j;\r
{\r
long m1=0,m2=0,m;\r
for(size_t i=0;i<gr->Grp.size();i++) // prepare array of indirect indexing\r
oPRCFile file(tname);\r
PRCoptions grpopt;\r
grpopt.tess = true;\r
- grpopt.closed = false; // set to true to make only front side visible\r
- // grpopt.no_break = true;\r
- // grpopt.do_break = false;\r
+ grpopt.closed = gr->get(MGL_ONESIDED); // set to true to make only front side visible\r
+ // grpopt.no_break = true;\r
+ // grpopt.do_break = false;\r
+ grpopt.crease_angle = 80;\r
\r
uint32_t materialMathGLid = m1;\r
+ if (gr->get(MGL_PREFERVC)) {\r
+ const PRCmaterial materialMathGL(\r
+ RGBAColour(0.1,0.1,0.1,1), // ambient\r
+ RGBAColour(1.0,1.0,1.0,1), // diffuse\r
+ RGBAColour(0.1,0.1,0.1,1), // emissive\r
+ RGBAColour(0.0,0.0,0.0,1), // spectral\r
+ 1.0,0.1 // alpha, shininess\r
+ );\r
+ materialMathGLid = file.addMaterial(materialMathGL);\r
+ }\r
+ else\r
{\r
png_buf buffer;\r
buffer.data = (uint8_t*)malloc(1024);;\r
const png_uint_32 width=256, height=256*ntxt;\r
png_bytep buf = new png_byte[4*width*height];\r
png_bytepp pbuf= new png_bytep[height];\r
- for(size_t i=0;i<height;i++) pbuf[i] = buf+4*width*i;\r
- for(size_t i=0;i<ntxt;i++) gr->GetTxt(i).GetRGBA(buf+i*256*256*4);\r
+ for(size_t i=0;i<height;i++)\r
+ pbuf[i] = buf+4*width*i;\r
+ for(size_t i=0;i<ntxt;i++)\r
+ gr->GetTxt(i).GetRGBA(buf+i*256*256*4);\r
\r
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,0,0,0);\r
png_infop info_ptr = png_create_info_struct(png_ptr);\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, width, height, 8,\r
- PNG_COLOR_TYPE_RGB_ALPHA,\r
+ PNG_COLOR_TYPE_RGB_ALPHA,\r
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,\r
PNG_FILTER_TYPE_DEFAULT);\r
png_set_rows(png_ptr, info_ptr, pbuf);\r
- png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);\r
+ png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, 0);\r
png_write_end(png_ptr, info_ptr);\r
\r
png_destroy_write_struct(&png_ptr, &info_ptr);\r
const PRCmaterial materialMathGL(\r
RGBAColour(0.1,0.1,0.1,1), // ambient\r
RGBAColour(1.0,1.0,1.0,1), // diffuse\r
- RGBAColour(0.1,0.1,0.1,1), //emissive\r
- RGBAColour(0.0,0.0,0.0,1), //spectral\r
+ RGBAColour(0.1,0.1,0.1,1), // emissive\r
+ RGBAColour(0.0,0.0,0.0,1), // spectral\r
1.0,0.1, // alpha, shininess\r
buffer.data, KEPRCPicture_PNG, 0, 0, buffer.size, true);\r
materialMathGLid = file.addMaterial(materialMathGL);\r
// primitive definition in groups\r
\r
mglPnt p0;\r
- p0.x = dynamic_cast<mglCanvas *>(gr)->GetWidth()/2.;\r
- p0.y = dynamic_cast<mglCanvas *>(gr)->GetHeight()/2.;\r
- p0.z = sqrt(p0.x*p0.y);\r
+ const double width = dynamic_cast<mglCanvas *>(gr)->GetWidth();\r
+ const double height = dynamic_cast<mglCanvas *>(gr)->GetHeight();\r
+ const double depth = sqrt(width*height);\r
+\r
+ p0.x = width/2.;\r
+ p0.y = height/2.;\r
+ p0.z = (1.f-sqrt(width*height)/(2*depth))*depth;\r
\r
for(size_t i=0;i<gr->Grp.size();i++)\r
{\r
break;\r
case 'S':\r
{\r
- const uint32_t ti = group.addTextureCoords(p);\r
+ const uint32_t ti = group.addColourInfo(p);\r
\r
const uint32_t pi1 = group.addPoint(p.x-ss,p.y-ss,p.z);\r
const uint32_t pi2 = group.addPoint(p.x+ss,p.y-ss,p.z);\r
break;\r
case 'D':\r
{\r
- const uint32_t ti = group.addTextureCoords(p);\r
+ const uint32_t ti = group.addColourInfo(p);\r
\r
const uint32_t pi1 = group.addPoint(p.x,p.y-ss,p.z);\r
const uint32_t pi2 = group.addPoint(p.x+ss,p.y,p.z);\r
break;\r
case 'T':\r
{\r
- const uint32_t ti = group.addTextureCoords(p);\r
+ const uint32_t ti = group.addColourInfo(p);\r
\r
const uint32_t pi1 = group.addPoint(p.x-ss,p.y-ss/2,p.z);\r
const uint32_t pi2 = group.addPoint(p.x+ss,p.y-ss/2,p.z);\r
break;\r
case 'V':\r
{\r
- const uint32_t ti = group.addTextureCoords(p);\r
+ const uint32_t ti = group.addColourInfo(p);\r
\r
const uint32_t pi1 = group.addPoint(p.x-ss,p.y+ss/2,p.z);\r
const uint32_t pi2 = group.addPoint(p.x,p.y-ss,p.z);\r
break;\r
case 'L':\r
{\r
- const uint32_t ti = group.addTextureCoords(p);\r
+ const uint32_t ti = group.addColourInfo(p);\r
\r
const uint32_t pi1 = group.addPoint(p.x+ss/2,p.y+ss,p.z);\r
const uint32_t pi2 = group.addPoint(p.x-ss, p.y, p.z);\r
break;\r
case 'R':\r
{\r
- const uint32_t ti = group.addTextureCoords(p);\r
+ const uint32_t ti = group.addColourInfo(p);\r
\r
const uint32_t pi1 = group.addPoint(p.x-ss/2,p.y+ss,p.z);\r
const uint32_t pi2 = group.addPoint(p.x-ss/2,p.y-ss,p.z);\r
break;\r
case 'O':\r
{\r
- const uint32_t ti = group.addTextureCoords(p);\r
+ const uint32_t ti = group.addColourInfo(p);\r
\r
const uint32_t cpi=group.addPoint(p);\r
uint32_t pi[21];\r
triangle.pi[0] = group.addPoint(p1);\r
triangle.pi[1] = group.addPoint(p2);\r
triangle.pi[2] = group.addPoint(p3);\r
- triangle.ti[0] = group.addTextureCoords(p1);\r
- triangle.ti[1] = group.addTextureCoords(p2);\r
- triangle.ti[2] = group.addTextureCoords(p3);\r
+ triangle.ti[0] = group.addColourInfo(p1);\r
+ triangle.ti[1] = group.addColourInfo(p2);\r
+ triangle.ti[2] = group.addColourInfo(p3);\r
group.triangles.push_back(triangle);\r
}\r
break;\r
{\r
const mglPnt p1 = gr->GetPnt(q.n1) - p0;\r
const uint32_t pi1 = group.addPoint(p1);\r
- const uint32_t ti1 = group.addTextureCoords(p1);\r
+ const uint32_t ti1 = group.addColourInfo(p1);\r
\r
const mglPnt p2 = gr->GetPnt(q.n2) - p0;\r
const uint32_t pi2 = group.addPoint(p2);\r
- const uint32_t ti2 = group.addTextureCoords(p2);\r
+ const uint32_t ti2 = group.addColourInfo(p2);\r
\r
const mglPnt p3 = gr->GetPnt(q.n3) - p0;\r
const uint32_t pi3 = group.addPoint(p3);\r
- const uint32_t ti3 = group.addTextureCoords(p3);\r
+ const uint32_t ti3 = group.addColourInfo(p3);\r
\r
const mglPnt p4 = gr->GetPnt(q.n4) - p0;\r
const uint32_t pi4 = group.addPoint(p4);\r
- const uint32_t ti4 = group.addTextureCoords(p4);\r
+ const uint32_t ti4 = group.addColourInfo(p4);\r
\r
prctriangle triangle1, triangle2;\r
triangle1.pi[0] = pi1;\r
PI[i][2] = group.triangles[i].pi[2];\r
}\r
if (!group.samecolour) {\r
- const uint32_t nT = group.texturecoords.size();\r
- double (*T)[2] = new double[nT][2];\r
- group.writeTextureCoords(T);\r
- uint32_t (*TI)[3] = new uint32_t[nI][3];\r
- for(uint32_t i = 0; i<nI; i++)\r
- {\r
- TI[i][0] = group.triangles[i].ti[0];\r
- TI[i][1] = group.triangles[i].ti[1];\r
- TI[i][2] = group.triangles[i].ti[2];\r
+ if (gr->get(MGL_PREFERVC)) {\r
+ const uint32_t nC = group.colours.size();\r
+ RGBAColour *C = new RGBAColour[nC];\r
+ group.writeColours(C);\r
+ uint32_t (*CI)[3] = new uint32_t[nI][3];\r
+ for(uint32_t i = 0; i<nI; i++)\r
+ {\r
+ CI[i][0] = group.triangles[i].ti[0];\r
+ CI[i][1] = group.triangles[i].ti[1];\r
+ CI[i][2] = group.triangles[i].ti[2];\r
+ }\r
+ const uint32_t tess_index = file.createTriangleMesh(nP, P, nI, PI, m1, 0, NULL, NULL, 0, NULL, NULL, nC, C, CI, 0, NULL, NULL, grpopt.crease_angle);\r
+ uint32_t materialid = materialMathGLid;\r
+ if (group.samealpha) { // workaround for transparency ignored in vertex colors, may not work in OpenGL\r
+ const double a = group.commonalpha;\r
+ const PRCmaterial materialTransparent(\r
+ RGBAColour(0.1,0.1,0.1,a), // ambient\r
+ RGBAColour(1.0,1.0,1.0,a), // diffuse\r
+ RGBAColour(0.1,0.1,0.1,a), // emissive\r
+ RGBAColour(0.0,0.0,0.0,a), // spectral\r
+ a,0.1 // alpha, shininess\r
+ );\r
+ materialid = file.addMaterial(materialTransparent);\r
+ }\r
+ file.useMesh(tess_index, materialid);\r
+ delete [] CI;\r
+ delete [] C;\r
+ } else {\r
+ const uint32_t nT = group.texturecoords.size();\r
+ double (*T)[2] = new double[nT][2];\r
+ group.writeTextureCoords(T);\r
+ uint32_t (*TI)[3] = new uint32_t[nI][3];\r
+ for(uint32_t i = 0; i<nI; i++)\r
+ {\r
+ TI[i][0] = group.triangles[i].ti[0];\r
+ TI[i][1] = group.triangles[i].ti[1];\r
+ TI[i][2] = group.triangles[i].ti[2];\r
+ }\r
+ const uint32_t tess_index = file.createTriangleMesh(nP, P, nI, PI, m1, 0, NULL, NULL, nT, T, TI, 0, NULL, NULL, 0, NULL, NULL, grpopt.crease_angle);\r
+ file.useMesh(tess_index, materialMathGLid);\r
+ delete [] TI;\r
+ delete [] T;\r
}\r
- const uint32_t tess_index = file.createTriangleMesh(nP, P, nI, PI, m1, 0, NULL, NULL, nT, T, TI, 0, NULL, NULL, 0, NULL, NULL);\r
- file.useMesh(tess_index, materialMathGLid);\r
- delete [] TI;\r
- delete [] T;\r
} else {\r
- const uint32_t tess_index = file.createTriangleMesh(nP, P, nI, PI, m1, 0, NULL, NULL, 0, NULL, NULL, 0, NULL, NULL, 0, NULL, NULL);\r
+ const uint32_t tess_index = file.createTriangleMesh(nP, P, nI, PI, m1, 0, NULL, NULL, 0, NULL, NULL, 0, NULL, NULL, 0, NULL, NULL, grpopt.crease_angle);\r
\r
const PRCmaterial material(\r
RGBAColour(0.1,0.1,0.1,1), // ambient\r
- group.colour, // diffuse\r
- RGBAColour(0.1,0.1,0.1,1), //emissive\r
- RGBAColour(0.0,0.0,0.0,1), //spectral\r
- group.colour.A,0.1); // alpha, shininess\r
+ group.commoncolour, // diffuse\r
+ RGBAColour(0.1,0.1,0.1,1), // emissive\r
+ RGBAColour(0.0,0.0,0.0,1), // spectral\r
+ group.commoncolour.A,0.1); // alpha, shininess\r
file.useMesh(tess_index, file.addMaterial(material));\r
}\r
delete [] PI;\r
\r
if (make_pdf) {\r
#if MGL_HAVE_PDF\r
- const HPDF_REAL width = dynamic_cast<mglCanvas *>(gr)->GetWidth();\r
+ const HPDF_REAL width = dynamic_cast<mglCanvas *>(gr)->GetWidth();\r
const HPDF_REAL height = dynamic_cast<mglCanvas *>(gr)->GetHeight();\r
- const HPDF_REAL depth = sqrt(width*height);\r
+ const HPDF_REAL depth = sqrt(width*height);\r
\r
const HPDF_Rect rect = {0, 0, width, height};\r
\r
// Create annotation\r
annot = HPDF_Page_Create3DAnnot (page, rect, u3d );\r
\r
+ // Enable toolbar\r
+ HPDF_Dict action = (HPDF_Dict)HPDF_Dict_GetItem (annot, "3DA", HPDF_OCLASS_DICT);\r
+ HPDF_Dict_AddBoolean (action, "TB", HPDF_TRUE);\r
+\r
/* save the document to a file */\r
const size_t len = strlen(tname);\r
tname[len-2]='p'; tname[len-2]='d'; tname[len-1]='f';\r
}
map<PRCVector3d,uint32_t> points;
PRC3DTess *tess = new PRC3DTess();
+ tess->crease_angle = group.options.crease_angle;
PRCTessFace *tessFace = new PRCTessFace();
tessFace->used_entities_flag=PRC_FACETESSDATA_Triangle;
uint32_t triangles = 0;
{
map<PRCVector3d,uint32_t> points;
PRC3DTess *tess = new PRC3DTess();
+ tess->crease_angle = group.options.crease_angle;
PRCTessFace *tessFace = new PRCTessFace();
tessFace->used_entities_flag=PRC_FACETESSDATA_Triangle;
uint32_t triangles = 0;
{
for(std::vector<PRCPolyBrepModel*>::iterator pit=group.polymodels.begin(); pit!=group.polymodels.end(); pit++)
{
+ (*pit)->is_closed = group.options.closed;
part_definition->addPolyBrepModel(*pit);
}
}
uint32_t nN, const double N[][3], const uint32_t NI[][3],
uint32_t nT, const double T[][2], const uint32_t TI[][3],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][3],
- uint32_t nM, const PRCmaterial M[], const uint32_t MI[])
+ uint32_t nM, const PRCmaterial M[], const uint32_t MI[], double ca)
{
if(nP==0 || P==NULL || nI==0 || PI==NULL)
return;
- const uint32_t tess_index = createTriangleMesh(nP, P, nI, PI, m, nN, N, NI, nT, T, TI, nC, C, CI, nM, M, MI);
+ const uint32_t tess_index = createTriangleMesh(nP, P, nI, PI, m, nN, N, NI, nT, T, TI, nC, C, CI, nM, M, MI, ca);
useMesh(tess_index,m1);
}
uint32_t nN, const double N[][3], const uint32_t NI[][3],
uint32_t nT, const double T[][2], const uint32_t TI[][3],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][3],
- uint32_t nS, const uint32_t S[], const uint32_t SI[])
+ uint32_t nS, const uint32_t S[], const uint32_t SI[], double ca)
{
if(nP==0 || P==NULL || nI==0 || PI==NULL)
return m1;
tess->normal_coordinate.push_back(N[i][2]);
}
}
+ else
+ tess->crease_angle = ca;
if(textured)
{
tess->texture_coordinate.reserve(2*nT);
uint32_t nN, const double N[][3], const uint32_t NI[][4],
uint32_t nT, const double T[][2], const uint32_t TI[][4],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][4],
- uint32_t nM, const PRCmaterial M[], const uint32_t MI[])
+ uint32_t nM, const PRCmaterial M[], const uint32_t MI[], double ca)
{
if(nP==0 || P==NULL || nI==0 || PI==NULL)
return;
- const uint32_t tess_index = createQuadMesh(nP, P, nI, PI, m, nN, N, NI, nT, T, TI, nC, C, CI, nM, M, MI);
+ const uint32_t tess_index = createQuadMesh(nP, P, nI, PI, m, nN, N, NI, nT, T, TI, nC, C, CI, nM, M, MI, ca);
useMesh(tess_index,m1);
}
uint32_t nN, const double N[][3], const uint32_t NI[][4],
uint32_t nT, const double T[][2], const uint32_t TI[][4],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][4],
- uint32_t nS, const uint32_t S[], const uint32_t SI[])
+ uint32_t nS, const uint32_t S[], const uint32_t SI[], double ca)
{
if(nP==0 || P==NULL || nI==0 || PI==NULL)
return m1;
tess->normal_coordinate.push_back(N[i][2]);
}
}
+ else
+ tess->crease_angle = ca;
if(textured)
{
tess->texture_coordinate.reserve(2*nT);
bool tess; // use tessellated mesh to store straight patches
bool do_break; //
bool no_break; // do not render transparent patches as one-faced nodes
+ double crease_angle; // crease angle for meshes
PRCoptions(double compression=0.0, double granularity=0.0, bool closed=false,
- bool tess=false, bool do_break=true, bool no_break=false)
+ bool tess=false, bool do_break=true, bool no_break=false, double crease_angle=25.8419)
: compression(compression), granularity(granularity), closed(closed),
- tess(tess), do_break(do_break), no_break(no_break) {}
+ tess(tess), do_break(do_break), no_break(no_break), crease_angle(crease_angle) {}
};
class PRCgroup
uint32_t nN, const double N[][3], const uint32_t NI[][3],
uint32_t nT, const double T[][2], const uint32_t TI[][3],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][3],
- uint32_t nM, const PRCmaterial M[], const uint32_t MI[]);
+ uint32_t nM, const PRCmaterial M[], const uint32_t MI[], double ca);
uint32_t createTriangleMesh(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[][3], uint32_t style_index,
uint32_t nN, const double N[][3], const uint32_t NI[][3],
uint32_t nT, const double T[][2], const uint32_t TI[][3],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][3],
- uint32_t nS, const uint32_t S[], const uint32_t SI[]);
+ uint32_t nS, const uint32_t S[], const uint32_t SI[], double ca);
uint32_t createTriangleMesh(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[][3], const PRCmaterial& m,
uint32_t nN, const double N[][3], const uint32_t NI[][3],
uint32_t nT, const double T[][2], const uint32_t TI[][3],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][3],
- uint32_t nM, const PRCmaterial M[], const uint32_t MI[])
+ uint32_t nM, const PRCmaterial M[], const uint32_t MI[], double ca)
{
const uint32_t style = addMaterial(m);
if(M!=NULL && nM>0)
uint32_t* const styles = new uint32_t[nM];
for(uint32_t i=0; i<nM; i++)
styles[i]=addMaterial(M[i]);
- const uint32_t meshid = createTriangleMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, nM, styles, MI);
+ const uint32_t meshid = createTriangleMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, nM, styles, MI, ca);
delete[] styles;
return meshid;
}
else
- return createTriangleMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, 0, NULL, NULL);
+ return createTriangleMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, 0, NULL, NULL, ca);
}
void addQuads(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[][4], const PRCmaterial& m,
uint32_t nN, const double N[][3], const uint32_t NI[][4],
uint32_t nT, const double T[][2], const uint32_t TI[][4],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][4],
- uint32_t nM, const PRCmaterial M[], const uint32_t MI[]);
+ uint32_t nM, const PRCmaterial M[], const uint32_t MI[], double ca);
uint32_t createQuadMesh(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[][4], uint32_t style_index,
uint32_t nN, const double N[][3], const uint32_t NI[][4],
uint32_t nT, const double T[][2], const uint32_t TI[][4],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][4],
- uint32_t nS, const uint32_t S[], const uint32_t SI[]);
+ uint32_t nS, const uint32_t S[], const uint32_t SI[], double ca);
uint32_t createQuadMesh(uint32_t nP, const double P[][3], uint32_t nI, const uint32_t PI[][4], const PRCmaterial& m,
uint32_t nN, const double N[][3], const uint32_t NI[][4],
uint32_t nT, const double T[][2], const uint32_t TI[][4],
uint32_t nC, const RGBAColour C[], const uint32_t CI[][4],
- uint32_t nM, const PRCmaterial M[], const uint32_t MI[])
+ uint32_t nM, const PRCmaterial M[], const uint32_t MI[], double ca)
{
const uint32_t style = addMaterial(m);
if(M!=NULL && nM>0)
uint32_t* const styles = new uint32_t[nM];
for(uint32_t i=0; i<nM; i++)
styles[i]=addMaterial(M[i]);
- const uint32_t meshid = createQuadMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, nM, styles, MI);
+ const uint32_t meshid = createQuadMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, nM, styles, MI, ca);
delete[] styles;
return meshid;
}
else
- return createQuadMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, 0, NULL, NULL);
+ return createQuadMesh(nP, P, nI, PI, style, nN, N, NI, nT, T, TI, nC, C, CI, 0, NULL, NULL, ca);
}
#define PRCTRANSFORM const double origin[3]=NULL, const double x_axis[3]=NULL, const double y_axis[3]=NULL, double scale=1, const double* t=NULL
#define PRCCARTRANSFORM const double origin[3], const double x_axis[3], const double y_axis[3], double scale
public:
PRC3DTess() :
has_faces(false), has_loops(false),
- crease_angle(80)
+ crease_angle(25.8419) // arccos(0.9), default found in Acrobat output
{}
~PRC3DTess() { for(PRCTessFaceList::iterator it=face_tessellation.begin(); it!=face_tessellation.end(); ++it) delete *it; }
void serialize3DTess(PRCbitStream&);
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <wchar.h>\r
-#include <stdlib.h>\r
#include "mgl2/canvas.h"\r
#include "mgl2/prim.h"\r
#include "mgl2/data.h"\r
// Mark & Curve series\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_mark(HMGL gr, float x,float y,float z,const char *mark)\r
+void mgl_mark(HMGL gr, mreal x,mreal y,mreal z,const char *mark)\r
{\r
char mk = gr->SetPenPal(mark);\r
if(!mk) mk = '.';\r
- mglPoint p(x,y,z);\r
- gr->mark_plot(gr->AddPnt(p,gr->CDef,mglPoint(NAN),-1,3),mk);\r
+ gr->mark_plot(gr->AddPnt(mglPoint(x,y,z),gr->CDef,mglPoint(NAN),-1,3),mk);\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_mark_(uintptr_t *gr, mreal *x, mreal *y, mreal *z, const char *pen,int l)\r
{ char *s=new char[l+1]; memcpy(s,pen,l); s[l]=0;\r
mgl_mark(_GR_, *x,*y,*z,s); delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_ball(HMGL gr, float x,float y,float z)\r
+void mgl_ball(HMGL gr, mreal x,mreal y,mreal z)\r
{\r
- mglPoint p(x,y,z);\r
- gr->mark_plot(gr->AddPnt(p,gr->AddTexture('r'),mglPoint(NAN),-1,3),'.');\r
+ gr->mark_plot(gr->AddPnt(mglPoint(x,y,z),gr->AddTexture('r'),mglPoint(NAN),-1,3),'.');\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_ball_(uintptr_t *gr, mreal *x,mreal *y,mreal *z)\r
{ mgl_ball(_GR_, *x,*y,*z); }\r
//-----------------------------------------------------------------------------\r
-void mgl_line(HMGL gr, float x1, float y1, float z1, float x2, float y2, float z2, const char *pen,int n)\r
+void mgl_line(HMGL gr, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, const char *pen,int n)\r
{\r
static int cgid=1; gr->StartGroup("Line",cgid++);\r
if(mgl_isnan(z1) || mgl_isnan(z2)) z1=z2=gr->Min.z;\r
n = (n<2) ? 2 : n;\r
\r
register long i,k1,k2;\r
- register float s;\r
+ register mreal s;\r
gr->Reserve(n);\r
k1 = gr->AddPnt(p,gr->CDef,nn,-1,3);\r
for(i=1;i<n;i++)\r
{\r
if(gr->Stop) return;\r
- s = i/float(n-1); p = p1*(1-s)+p2*s; k2 = k1;\r
+ s = i/mreal(n-1); p = p1*(1-s)+p2*s; k2 = k1;\r
k1 = gr->AddPnt(p,gr->CDef,nn,-1,3);\r
gr->line_plot(k2,k1);\r
if(i==1) gr->arrow_plot(k2,k1,gr->Arrow1);\r
{ char *s=new char[l+1]; memcpy(s,pen,l); s[l]=0;\r
mgl_line(_GR_, *x1,*y1,*z1, *x2,*y2,*z2,s,*n); delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_curve(HMGL gr, float x1, float y1, float z1, float dx1, float dy1, float dz1, float x2, float y2, float z2, float dx2, float dy2, float dz2, const char *pen,int n)\r
+void mgl_curve(HMGL gr, mreal x1, mreal y1, mreal z1, mreal dx1, mreal dy1, mreal dz1, mreal x2, mreal y2, mreal z2, mreal dx2, mreal dy2, mreal dz2, const char *pen,int n)\r
{\r
static int cgid=1; gr->StartGroup("Curve",cgid++);\r
mglPoint p1(x1,y1,z1), p2(x2,y2,z2), d1(dx1,dy1,dz1), d2(dx2,dy2,dz2), a,b,p=p1,nn=mglPoint(NAN);\r
gr->SetPenPal(pen);\r
\r
register long i,k1,k2;\r
- register float s;\r
+ register mreal s;\r
gr->Reserve(n);\r
k1=gr->AddPnt(p,gr->CDef,nn,-1,3);\r
for(i=0;i<n;i++)\r
{ char *s=new char[l+1]; memcpy(s,pen,l); s[l]=0;\r
mgl_curve(_GR_, *x1,*y1,*z1, *dx1,*dy1,*dz1, *x2,*y2,*z2, *dx2,*dy2,*dz2, s, *n); delete []s;}\r
//-----------------------------------------------------------------------------\r
-void mgl_error_box(HMGL gr, float x, float y, float z, float ex, float ey, float ez, const char *pen)\r
+void mgl_error_box(HMGL gr, mreal x, mreal y, mreal z, mreal ex, mreal ey, mreal ez, const char *pen)\r
{\r
static int cgid=1; gr->StartGroup("ErBox",cgid++);\r
char mk=gr->SetPenPal(pen);\r
// Face series\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_face(HMGL gr, float x0, float y0, float z0, float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, const char *stl)\r
+void mgl_face(HMGL gr, mreal x0, mreal y0, mreal z0, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, mreal x3, mreal y3, mreal z3, const char *stl)\r
{\r
static int cgid=1; gr->StartGroup("Face",cgid++);\r
long pal;\r
gr->SetPenPal(stl,&pal);\r
- float c1,c2,c3,c4,zz=(gr->Min.z+gr->Max.z)/2;\r
+ mreal c1,c2,c3,c4,zz=(gr->Min.z+gr->Max.z)/2;\r
c1=c2=c3=c4=gr->CDef;\r
if(mgl_isnan(z0)) z0 = zz; if(mgl_isnan(z1)) z1 = zz;\r
if(mgl_isnan(z2)) z2 = zz; if(mgl_isnan(z3)) z3 = zz;\r
gr->EndGroup();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_facex(HMGL gr, float x0, float y0, float z0, float wy, float wz, const char *stl, float d1, float d2)\r
+void mgl_facex(HMGL gr, mreal x0, mreal y0, mreal z0, mreal wy, mreal wz, const char *stl, mreal d1, mreal d2)\r
{ mgl_face(gr, x0,y0,z0, x0,y0+wy,z0, x0,y0,z0+wz, x0,y0+wy+d1,z0+wz+d2, stl); }\r
//-----------------------------------------------------------------------------\r
-void mgl_facey(HMGL gr, float x0, float y0, float z0, float wx, float wz, const char *stl, float d1, float d2)\r
+void mgl_facey(HMGL gr, mreal x0, mreal y0, mreal z0, mreal wx, mreal wz, const char *stl, mreal d1, mreal d2)\r
{ mgl_face(gr, x0,y0,z0, x0+wx,y0,z0, x0,y0,z0+wz, x0+wx+d1,y0,z0+wz+d2, stl); }\r
//-----------------------------------------------------------------------------\r
-void mgl_facez(HMGL gr, float x0, float y0, float z0, float wx, float wy, const char *stl, float d1, float d2)\r
+void mgl_facez(HMGL gr, mreal x0, mreal y0, mreal z0, mreal wx, mreal wy, const char *stl, mreal d1, mreal d2)\r
{ mgl_face(gr, x0,y0,z0, x0,y0+wy,z0, x0+wx,y0,z0, x0+wx+d1,y0+wy+d2,z0, stl); }\r
//-----------------------------------------------------------------------------\r
void mgl_facex_(uintptr_t* gr, mreal *x0, mreal *y0, mreal *z0, mreal *wy, mreal *wz, const char *stl, mreal *dx, mreal *dy, int l)\r
{ char *s=new char[l+1]; memcpy(s,stl,l); s[l]=0;\r
mgl_facez(_GR_, *x0,*y0,*z0,*wx,*wy,s,*dx,*dy); delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_face_(uintptr_t* gr, float *x0, float *y0, float *z0, float *x1, float *y1, float *z1, float *x2, float *y2, float *z2, float *x3, float *y3, float *z3, const char *stl, int l)\r
+void mgl_face_(uintptr_t* gr, mreal *x0, mreal *y0, mreal *z0, mreal *x1, mreal *y1, mreal *z1, mreal *x2, mreal *y2, mreal *z2, mreal *x3, mreal *y3, mreal *z3, const char *stl, int l)\r
{ char *s=new char[l+1]; memcpy(s,stl,l); s[l]=0;\r
mgl_face(_GR_, *x0,*y0,*z0, *x1,*y1,*z1, *x2,*y2,*z2, *x3,*y3,*z3, stl); delete []s; }\r
//-----------------------------------------------------------------------------\r
// Cone\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_cone(HMGL gr, float x1, float y1, float z1, float x2, float y2, float z2, float r1, float r2, const char *stl)\r
+void mgl_cone(HMGL gr, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, mreal r1, mreal r2, const char *stl)\r
{\r
if(r2<0) r2=r1;\r
if(r1==0 && r2==0) return;\r
mglPoint p1(x1,y1,z1), p2(x2,y2,z2), p,q, d=p2-p1,a,b;\r
a=!d; a.Normalize(); b=d^a; b.Normalize();\r
long ss=gr->AddTexture(stl);\r
- float c1=gr->GetC(ss,p1.z), c2=gr->GetC(ss,p2.z);\r
+ mreal c1=gr->GetC(ss,p1.z), c2=gr->GetC(ss,p2.z);\r
long *kk=new long[164],k1=-1,k2=-1;\r
bool edge = stl && strchr(stl,'@');\r
bool wire = stl && strchr(stl,'#');\r
k1=gr->AddPnt(p1,c1,d,-1,3);\r
k2=gr->AddPnt(p2,c2,d,-1,3);\r
}\r
- float f,si,co, dr=r2-r1;\r
+ mreal f,si,co, dr=r2-r1;\r
register long i;\r
for(i=0;i<(wire?13:41);i++)\r
{\r
//-----------------------------------------------------------------------------\r
void mgl_cones_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *pen, const char *opt)\r
{\r
- long i,j,m,mx,my,mz,n=z->GetNx(),nx=x->GetNx(), pal;\r
- if(x->GetNx()<n || y->GetNx()<n) { gr->SetWarn(mglWarnDim,"Cones"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Cones"); return; }\r
+ long i,j,m,mx,my,mz,n=z->GetNx(),nx=x->GetNx(), nz=z->GetNy(), pal;\r
+ if(mgl_check_dim1(gr,x,z,y,0,"Cones",true)) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Cones",cgid++);\r
- m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy(); m = z->GetNy() > m ? z->GetNy() : m;\r
+ m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy(); m = nz > m ? nz : m;\r
\r
bool above= pen && strchr(pen,'a');\r
bool wire = pen && strchr(pen,'#');\r
- float *dd=new float[2*n], x1,z0,zz,d;\r
- memset(dd,0,n*sizeof(float));\r
+ mreal *dd=new mreal[2*n], x1,z0,zz,d, vx,vy,vz,v0,v1;\r
\r
gr->SetPenPal(pen,&pal);\r
char c1[7]; memset(c1,0,7); c1[0] ='@';\r
char c2[7]; memset(c2,0,7); c2[0] ='@';\r
if(wire) c1[5]=c2[5]='#';\r
- memset(dd,0,2*n*sizeof(float));\r
+ memset(dd,0,2*n*sizeof(mreal));\r
z0 = gr->GetOrgZ('x');\r
- for(i=0;i<n;i++) for(j=0;j<m;j++) dd[i] += z->v(i, j<z->GetNy() ? j:0);\r
+ for(i=0;i<n;i++) for(j=0;j<m;j++) dd[i] += z->v(i, j<nz ? j:0);\r
for(j=0;j<m;j++)\r
{\r
gr->NextColor(pal); memcpy(c1+1,gr->last_line(),4);\r
if(gr->GetNumPal(pal)==2*m)\r
{ gr->NextColor(pal); memcpy(c2+1,gr->last_line(),4); }\r
else memcpy(c2,c1,7);\r
- mx = j<x->GetNy() ? j:0; my = j<y->GetNy() ? j:0; mz = j<z->GetNy() ? j:0;\r
+ mx = j<x->GetNy() ? j:0; my = j<y->GetNy() ? j:0; mz = j<nz ? j:0;\r
for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete []dd; return; }\r
- d = i<nx-1 ? x->v(i+1,mx)-x->v(i,mx) : x->v(i,mx)-x->v(i-1,mx);\r
- x1 = (n<nx?(x->v(i,mx)+x->v(i+1,mx))/2:x->v(i,mx)) + d/2*(1-0.7*gr->BarWidth);\r
+ vx=x->v(i,mx); vy=y->v(i,my); vz=z->v(i,mz);\r
+ v0=y->v(i,0); v1=i<nx-1 ? x->v(i+1,mx):x->v(i-1,mx);\r
+ d = i<nx-1 ? v1-vx : vx-v1;\r
+ x1 = (n<nx ? (vx+v1)/2 : vx) + d/2*(1-0.7*gr->BarWidth);\r
if(above)\r
{\r
- zz = j>0?dd[i+n]:z0; dd[i+n] += z->v(i,mz);\r
- mgl_cone(gr, x1,y->v(i,0),zz, x1,y->v(i,0),dd[i+n],\r
+ zz = j>0?dd[i+n]:z0; dd[i+n] += vz;\r
+ mgl_cone(gr, x1,v0,zz, x1,v0,dd[i+n],\r
0.7*gr->BarWidth*d*(dd[i]-zz)/(dd[i]-z0),\r
0.7*gr->BarWidth*d*(dd[i]-dd[i+n])/(dd[i]-z0), c1);\r
}\r
- else mgl_cone(gr, x1,y->v(i,my),z0, x1,y->v(i,my),z->v(i,mz), 0.7*gr->BarWidth*d,0, z->v(i,mz)<0?c1:c2);\r
+ else mgl_cone(gr, x1,vy,z0, x1,vy,vz, 0.7*gr->BarWidth*d,0, vz<0?c1:c2);\r
}\r
}\r
gr->EndGroup(); delete []dd;\r
mglData y(z);\r
y.Fill(gr->Min.y,gr->Max.y,'y');\r
mgl_cones_xyz(gr,x,&y,z,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_cones(HMGL gr, HCDT z, const char *pen, const char *opt)\r
{\r
- if(z->GetNx()<2) { gr->SetWarn(mglWarnLow,"Bars"); return; }\r
gr->SaveState(opt);\r
mglData x(z->GetNx()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
mgl_cones_xz(gr,&x,z,pen,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_cones_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, const char *pen, const char *opt,int l,int lo)\r
// Ellipse & Rhomb\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_ellipse(HMGL gr, float x1, float y1, float z1, float x2, float y2, float z2, float r, const char *stl)\r
+void mgl_ellipse(HMGL gr, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, mreal r, const char *stl)\r
{\r
const int n = 41;\r
long pal=0,n0,n1=-1,n2,m1=-1,m2;\r
+ static int cgid=1; gr->StartGroup("Ellipse",cgid++);\r
gr->SetPenPal(stl,&pal);\r
- float c=gr->NextColor(pal), d;\r
- float k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');\r
+ mreal c=gr->NextColor(pal), d;\r
+ mreal k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');\r
bool fill = !(stl && strchr(stl,'#')), box = (stl && strchr(stl,'@')) || !fill;\r
if(!fill) k=c;\r
\r
for(long i=0;i<n;i++)\r
{\r
if(gr->Stop) return;\r
- float t = i*2*M_PI/(n-1.);\r
+ mreal t = i*2*M_PI/(n-1.);\r
p = s+v*cos(t)+u*sin(t);\r
n2 = n1; n1 = gr->AddPnt(p,c,q,-1,11);\r
m2 = m1; m1 = gr->CopyNtoC(n1,k);\r
if(box) gr->line_plot(m1,m2);\r
}\r
}\r
+ gr->EndGroup();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_rhomb(HMGL gr, float x1, float y1, float z1, float x2, float y2, float z2, float r, const char *stl)\r
+void mgl_rhomb(HMGL gr, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, mreal r, const char *stl)\r
{\r
long pal=0, n1,n2,n3,n4;\r
+ static int cgid=1; gr->StartGroup("Rhomb",cgid++);\r
gr->SetPenPal(stl,&pal);\r
- float c=gr->NextColor(pal);\r
- float k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');\r
- float b=(gr->GetNumPal(pal)>2)?gr->NextColor(pal):c;\r
+ mreal c=gr->NextColor(pal);\r
+ mreal k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');\r
+ mreal b=(gr->GetNumPal(pal)>2)?gr->NextColor(pal):c;\r
bool fill = !(stl && strchr(stl,'#')), box = (stl && strchr(stl,'@')) || !fill;\r
if(!fill) k=c;\r
gr->Reserve(8);\r
if(box)\r
{ gr->line_plot(n1,n2); gr->line_plot(n2,n3);\r
gr->line_plot(n3,n4); gr->line_plot(n4,n1); }\r
+ gr->EndGroup();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_ellipse_(uintptr_t* gr, float *x1, float *y1, float *z1, float *x2, float *y2, float *z2, float *r, const char *stl,int l)\r
+void mgl_ellipse_(uintptr_t* gr, mreal *x1, mreal *y1, mreal *z1, mreal *x2, mreal *y2, mreal *z2, mreal *r, const char *stl,int l)\r
{ char *s=new char[l+1]; memcpy(s,stl,l); s[l]=0;\r
mgl_ellipse(_GR_,*x1,*y1,*z1,*x2,*y2,*z2,*r,s); delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_rhomb_(uintptr_t* gr, float *x1, float *y1, float *z1, float *x2, float *y2, float *z2, float *r, const char *stl,int l)\r
+void mgl_rhomb_(uintptr_t* gr, mreal *x1, mreal *y1, mreal *z1, mreal *x2, mreal *y2, mreal *z2, mreal *r, const char *stl,int l)\r
{ char *s=new char[l+1]; memcpy(s,stl,l); s[l]=0;\r
mgl_rhomb(_GR_,*x1,*y1,*z1,*x2,*y2,*z2,*r,s); delete []s; }\r
//-----------------------------------------------------------------------------\r
// Sphere & Drop\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_sphere(HMGL gr, float x, float y, float z, float r, const char *stl)\r
+void mgl_sphere(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl)\r
{ mgl_drop(gr,x,y,z,1,0,0,2*r,stl,0,1); }\r
//-----------------------------------------------------------------------------\r
void mgl_sphere_(uintptr_t* gr, mreal *x, mreal *y, mreal *z, mreal *r, const char *stl,int l)\r
{ char *s=new char[l+1]; memcpy(s,stl,l); s[l]=0;\r
mgl_sphere(_GR_, *x,*y,*z,*r,s); delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_drop(HMGL gr, mglPoint p, mglPoint q, float r, float c, float sh, float a)\r
+void mgl_drop(HMGL gr, mglPoint p, mglPoint q, mreal r, mreal c, mreal sh, mreal a)\r
{\r
mglPoint p1,p2,pp,qq;\r
if(q.norm()==0) { q = mglPoint(1,0,0); sh=0; }\r
gr->Reserve(n*n);\r
long *nn=new long[2*n];\r
\r
- float u,v,x,y,z,rr,dr, co,si;\r
+ mreal u,v,x,y,z,rr,dr, co,si;\r
for(i=0;i<n;i++) for(j=0;j<n;j++)\r
{\r
if(gr->Stop) { delete []nn; return; }\r
delete []nn; gr->EndGroup();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_drop(HMGL gr, float x1, float y1, float z1, float x2, float y2, float z2, float r, const char *stl, float sh, float a)\r
+void mgl_drop(HMGL gr, mreal x1, mreal y1, mreal z1, mreal x2, mreal y2, mreal z2, mreal r, const char *stl, mreal sh, mreal a)\r
{\r
- float c=gr->AddTexture((stl && stl[0]) ? stl[0]:'r');\r
+ mreal c=gr->AddTexture((stl && stl[0]) ? stl[0]:'r');\r
mgl_drop(gr,mglPoint(x1,y1,z1), mglPoint(x2,y2,z2), r, c, sh, a);\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_dew_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt)\r
{\r
long i,j,n=ax->GetNx(),m=ax->GetNy(),k;\r
- if(n*m*ax->GetNz()!=ay->GetNx()*ay->GetNy()*ay->GetNz()) { gr->SetWarn(mglWarnDim,"Dew"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Dew"); return; }\r
- bool both = x->GetNx()==n && y->GetNx()==n && x->GetNy()==m && y->GetNy()==m;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m))) { gr->SetWarn(mglWarnDim,"Dew"); return; }\r
+ if(mgl_check_dim2(gr,x,y,ax,ay,"Dew")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("DewXY",cgid++);\r
\r
- float xm,ym,dx,dy,dd;\r
+ mreal xm,ym,dx,dy,dd;\r
long ss = gr->AddTexture(sch);\r
bool inv = sch && strchr(sch,'A');\r
- float zVal = gr->Min.z;\r
+ mreal zVal = gr->Min.z;\r
long tx=1,ty=1;\r
if(gr->MeshNum>1) { tx=(n-1)/(gr->MeshNum-1); ty=(m-1)/(gr->MeshNum-1); }\r
if(tx<1) tx=1; if(ty<1) ty=1;\r
ym = sqrt(ax->v(i,j,k)*ax->v(i,j,k)+ay->v(i,j,k)*ay->v(i,j,k));\r
xm = xm>ym ? xm : ym;\r
}\r
-/* for(i=0,xm=0;i<m*n*ax->GetNz();i++)\r
- {\r
- ym = hypot(ax->vthr(i),ay->vthr(i));\r
- xm = xm>ym ? xm : ym;\r
- }*/\r
- xm = 1./MGL_FLT_EPS/(xm==0 ? 1:xm);\r
- mglPoint p,q;\r
+ xm = 1./MGL_EPSILON/(xm==0 ? 1:xm);\r
+ mglPoint q;\r
\r
for(k=0;k<ax->GetNz();k++)\r
{\r
- if(ax->GetNz()>1) zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*float(k)/(ax->GetNz()-1);\r
+ if(ax->GetNz()>1) zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*mreal(k)/(ax->GetNz()-1);\r
for(i=0;i<n;i+=tx) for(j=0;j<m;j+=ty)\r
{\r
if(gr->Stop) return;\r
- float xx=GetX(x,i,j,k).x, yy=GetY(y,i,j,k).x;\r
+ mreal xx=GetX(x,i,j,k).x, yy=GetY(y,i,j,k).x;\r
dx = i<n-1 ? (GetX(x,i+1,j,k).x-xx) : (xx-GetX(x,i-1,j,k).x);\r
dy = j<m-1 ? (GetY(y,i,j+1,k).x-yy) : (yy-GetY(y,i,j-1,k).x);\r
dx *= tx; dy *= ty;\r
\r
- p = mglPoint(xx, yy, zVal);\r
- q = inv ? mglPoint(-ax->v(i,j,k),-ay->v(i,j,k),0) : mglPoint(ax->v(i,j,k),ay->v(i,j,k),0);\r
- p = mglPoint(xx, yy, zVal); dd = q.norm();\r
- float ccc = gr->GetC(ss,dd*xm,false);\r
- mgl_drop(gr,p,q,(dx<dy?dx:dy)/2,ccc,dd*xm,1);\r
+ q = mglPoint(ax->v(i,j,k),ay->v(i,j,k)); dd = q.norm();\r
+ if(inv) q = -q;\r
+ mreal ccc = gr->GetC(ss,dd*xm,false);\r
+ mgl_drop(gr,mglPoint(xx, yy, zVal),q,(dx<dy?dx:dy)/2,ccc,dd*xm,1);\r
}\r
}\r
gr->EndGroup();\r
//-----------------------------------------------------------------------------\r
void mgl_dew_2d(HMGL gr, HCDT ax, HCDT ay, const char *sch, const char *opt)\r
{\r
- if(ax->GetNx()<2 || ax->GetNy()<2) { gr->SetWarn(mglWarnLow,"Vect"); return; }\r
gr->SaveState(opt);\r
mglData x(ax->GetNx()), y(ax->GetNy());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_dew_xy(gr,&x,&y,ax,ay,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_dew_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int l,int lo)\r
// Puts series\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_puts(HMGL gr, float x, float y, float z,const char *text, const char *font, float size)\r
+void mgl_puts(HMGL gr, mreal x, mreal y, mreal z,const char *text, const char *font, mreal size)\r
{ mgl_puts_dir(gr, x, y, z, NAN, NAN, 0, text, font, size); }\r
-void mgl_putsw(HMGL gr, float x, float y, float z,const wchar_t *text, const char *font, float size)\r
+void mgl_putsw(HMGL gr, mreal x, mreal y, mreal z,const wchar_t *text, const char *font, mreal size)\r
{ mgl_putsw_dir(gr, x, y, z, NAN, NAN, 0, text, font, size); }\r
//-----------------------------------------------------------------------------\r
-void mgl_puts_dir(HMGL gr, float x, float y, float z, float dx, float dy, float dz, const char *text, const char *font, float size)\r
+void mgl_puts_dir(HMGL gr, mreal x, mreal y, mreal z, mreal dx, mreal dy, mreal dz, const char *text, const char *font, mreal size)\r
{\r
long len = strlen(text);\r
wchar_t *buf = new wchar_t[len+1];\r
delete []buf;\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_putsw_dir(HMGL gr, float x, float y, float z, float dx, float dy, float dz, const wchar_t *text, const char *font, float size)\r
+void mgl_putsw_dir(HMGL gr, mreal x, mreal y, mreal z, mreal dx, mreal dy, mreal dz, const wchar_t *text, const char *font, mreal size)\r
{\r
bool a=font && strchr(font,'a'), A=font && strchr(font,'A');\r
mglCanvas *g = dynamic_cast<mglCanvas *>(gr);\r
{\r
g->Push(); g->Identity(a);\r
gr->set(MGL_DISABLE_SCALE);\r
- register float s=a?1:g->GetPlotFactor();\r
+ register mreal s=a?1:g->GetPlotFactor();\r
x = (2*x-1)*s; y = (2*y-1)*s;\r
dx= (2*dx-1)*s; dy= (2*dy-1)*s;\r
}\r
gr->text_plot(k,text,font,size);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_puts_(uintptr_t *gr, float *x, float *y, float *z,const char *text, const char *font, float *size, int l, int n)\r
+void mgl_puts_(uintptr_t *gr, mreal *x, mreal *y, mreal *z,const char *text, const char *font, mreal *size, int l, int n)\r
{ wchar_t *s=new wchar_t[l+1]; mbstowcs(s,text,l); s[l]=0;\r
char *f=new char[n+1]; memcpy(f,font,n); f[n]=0;\r
mgl_putsw_dir(_GR_, *x, *y, *z, NAN, NAN, 0, s, f, *size);\r
delete []s; delete []f; }\r
//-----------------------------------------------------------------------------\r
-void mgl_puts_dir_(uintptr_t *gr, float *x, float *y, float *z, float *dx, float *dy, float *dz, const char *text, const char *font, float *size, int l, int n)\r
+void mgl_puts_dir_(uintptr_t *gr, mreal *x, mreal *y, mreal *z, mreal *dx, mreal *dy, mreal *dz, const char *text, const char *font, mreal *size, int l, int n)\r
{ wchar_t *s=new wchar_t[l+1]; mbstowcs(s,text,l); s[l]=0;\r
char *f=new char[n+1]; memcpy(f,font,n); f[n]=0;\r
mgl_putsw_dir(_GR_, *x, *y, *z, *dx, *dy, *dz, s, f, *size);\r
void mgl_textmarkw_xyzr(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT r, const wchar_t *text, const char *fnt, const char *opt)\r
{\r
long j,m,mx,my,mz,mr,n=y->GetNx();\r
- if(x->GetNx()!=n || z->GetNx()!=n || r->GetNx()!=n)\r
- { gr->SetWarn(mglWarnDim,"TextMark"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"TextMark"); return; }\r
+ if(mgl_check_dim1(gr,x,y,z,r,"TextMark")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("TextMark",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy();\r
gr->SaveState(opt);\r
mglData z(y->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_textmarkw_xyzr(gr,x,y,&z,r,text,fnt,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_textmarkw_yr(HMGL gr, HCDT y, HCDT r, const wchar_t *text, const char *fnt, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"TextMark"); return; }\r
+ register long n=y->GetNx();\r
+ if(n<2) { gr->SetWarn(mglWarnLow,"TextMark"); return; }\r
gr->SaveState(opt);\r
- mglData x(y->GetNx()); x.Fill(gr->Min.x,gr->Max.x);\r
- mglData z(y->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
+ mglData x(n); x.Fill(gr->Min.x,gr->Max.x);\r
+ mglData z(n); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_textmarkw_xyzr(gr,&x,y,&z,r,text,fnt,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_textmarkw(HMGL gr, HCDT y, const wchar_t *text, const char *fnt, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"TextMark"); return; }\r
+ register long n=y->GetNx();\r
+ if(n<2) { gr->SetWarn(mglWarnLow,"TextMark"); return; }\r
gr->SaveState(opt);\r
- mglData r(y->GetNx()); r.Fill(1,1);\r
- mglData x(y->GetNx()); x.Fill(gr->Min.x,gr->Max.x);\r
- mglData z(y->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
+ mglData r(n); r.Fill(1,1);\r
+ mglData x(n); x.Fill(gr->Min.x,gr->Max.x);\r
+ mglData z(n); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_textmarkw_xyzr(gr,&x,y,&z,&r,text,fnt,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_textmark_xyzr(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT r, const char *str, const char *fnt, const char *opt)\r
mgl_textmarkw(_GR_, _DA_(y),s,f, o); delete []o; delete []s; delete []f; }\r
//-----------------------------------------------------------------------------\r
//\r
-// PutsFit series\r
-//\r
-//-----------------------------------------------------------------------------\r
-extern char mglFitRes[1024]; ///< Last fitted formula\r
-void mgl_puts_fit(HMGL gr, float x, float y, float z, const char *pre, const char *font, float size)\r
-{\r
- long n = strlen(mglFitRes)+(pre?strlen(pre):0)+1;\r
- char *buf = new char[n];\r
- if(pre) sprintf(buf,"%s%s",pre,mglFitRes);\r
- else strcpy(buf,mglFitRes);\r
- mgl_puts(gr,x,y,z,buf,font,size);\r
- delete []buf;\r
-}\r
-void mgl_puts_fit_(uintptr_t* gr, mreal *x, mreal *y, mreal *z, const char *prefix, const char *font, mreal *size, int l, int n)\r
-{\r
- char *s=new char[l+1]; memcpy(s,prefix,l); s[l]=0;\r
- char *d=new char[n+1]; memcpy(d,font,n); d[n]=0;\r
- mgl_puts_fit(_GR_, *x,*y,*z, s, d, *size);\r
- delete []s; delete []d;\r
-}\r
-//-----------------------------------------------------------------------------\r
-//\r
-// TextMark series\r
+// Label series\r
//\r
//-----------------------------------------------------------------------------\r
void mgl_labelw_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const wchar_t *text, const char *fnt, const char *opt)\r
{\r
long j,m,mx,my,mz,n=y->GetNx();\r
- if(x->GetNx()!=n || z->GetNx()!=n)\r
- { gr->SetWarn(mglWarnDim,"Label"); return; }\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Label"); return; }\r
- float size=gr->SaveState(opt); if(mgl_isnan(size)) size=-0.7;\r
+ if(mgl_check_dim1(gr,x,y,z,0,"Label")) return;\r
+\r
+ mreal size=gr->SaveState(opt); if(mgl_isnan(size)) size=-0.7;\r
static int cgid=1; gr->StartGroup("Label",cgid++);\r
m = x->GetNy() > y->GetNy() ? x->GetNy() : y->GetNy(); m = z->GetNy() > m ? z->GetNy() : m;\r
\r
for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete []buf; return; }\r
- float xx=x->v(i,mx), yy=y->v(i,my), zz=z->v(i,mz);\r
+ mreal xx=x->v(i,mx), yy=y->v(i,my), zz=z->v(i,mz);\r
p = mglPoint(xx,yy,zz);\r
kk = gr->AddPnt(p,-1,q);\r
memset(buf,0,nn*sizeof(wchar_t));\r
else if(text[k+1]=='z') mglprintf(buf+l,nn-l,L"%.2g",zz);\r
l=wcslen(buf); k++;\r
}\r
- gr->text_plot(kk, buf, fnt, size, 0.03);\r
+ gr->text_plot(kk, buf, fnt, size, 0.05);\r
}\r
}\r
delete []buf; gr->EndGroup();\r
gr->SaveState(opt);\r
mglData z(y->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_labelw_xyz(gr,x,y,&z,text,fnt,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_labelw_y(HMGL gr, HCDT y, const wchar_t *text, const char *fnt, const char *opt)\r
{\r
- if(y->GetNx()<2) { gr->SetWarn(mglWarnLow,"TextMark"); return; }\r
+ register long n=y->GetNx();\r
+ if(n<2) { gr->SetWarn(mglWarnLow,"TextMark"); return; }\r
gr->SaveState(opt);\r
- mglData x(y->GetNx()); x.Fill(gr->Min.x,gr->Max.x);\r
- mglData z(y->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
+ mglData x(n); x.Fill(gr->Min.x,gr->Max.x);\r
+ mglData z(n); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_labelw_xyz(gr,&x,y,&z,text,fnt,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_label_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, const char *str, const char *fnt, const char *opt)\r
or you could email david@s-hull.org and arrange to make a donation of 10 of your local currancy units
to support s-hull.org.
+-------------------
+
+This is permission to use s-hull-pro mathgl as long as the routines retain
+my copyright notice. I an happy for it to be included in an LGPL product and
+I am happy for the source to be bundled with mathgl under whatever license you
+use for that.
+++ /dev/null
-#include <iostream>
-#include <hash_set.h>
-#include <set>
-#include <vector>
-#include <fstream>
-#include <stdlib.h>
-#include <math.h>
-
-
-#include "s_hull.h"
-
-/*
- fast and simple convex hull finder.
- kind of a circular vesion of Steven Fortune's sweepline algorithm
-but without the complicated bits.
-
- and combined with link insertion and flipping will give you Delaunay triangles..
-
-S-hull, Copyright (c) 2010
-Dr David SInclair
-Cambridge, UK
-
-email david@s-hull.org
-S-hull is free software and may be obtained from www.s-hull.org.
-It may be freely copied, modified,
-and redistributed under the following conditions which might loosely be termed a contribtors beerware license:
-1. All copyright notices must remain intact in all files.
-2. A copy of this text file must be distributed along with any copies
- of S-hull that you redistribute; this includes copies that you have
- modified, or copies of programs or other software products that
- include S-hull where distributed as source.
-
-3. If you modify S-hull, you must include a notice giving the
- name of the person performing the modification, the date of
- modification, and the reason for such modification.
-
-4. If you are distributing a binary or compiled version of s-hull it
- is not necessary to include any acknowledgement or reference
- to s-hull.
-5. There is no warranty or other guarantee of fitness for S-hull, it is
- provided solely "as is". Bug reports or fixes may be sent to
- bugs@s-hull.org; the authors may or may not act on them as
- they desire.
-6. By copying or compliing the code for S-hull you explicitly indemnify
-the copyright holder against any liability he may incur as a result of you
-copying the code.
-
-7. If you meet any of the contributors to the code you used from s-hull.org
- in a pub or a bar, and you think the source code they contributed to is worth it,
- you can buy them a beer.
-
- If your principles run against beer a bacon-double-cheeseburger would do just as nicely
- or you could email david@s-hull.org and arrange to make a donation of 10 of your local currancy units
- to support s-hull.org.
-
-
- */
-
-
-
-
-
-void circle_cent2(float r1,float c1, float r2,float c2, float r3,float c3,
-float &r,float &c, float &ro2){
- /*
- * function to return the center of a circle and its radius
- * degenerate case should never be passed to this routine!!!!!!!!!!!!!
- * but will return r0 = -1 if it is.
- */
-
- float v1 = 2*(r2-r1), v2 = 2*(c2-c1), v3 = r2*r2 - r1*r1 + c2*c2 - c1*c1;
- float v4 = 2*(r3-r1),
- v5 = 2*(c3-c1),
- v6 = r3*r3 - r1*r1 + c3*c3 - c1*c1,
-
- v7 = v2*v4 - v1*v5;
- if( v7 == 0 ){
- r=0;
- c=0;
- ro2 = -1;
- return;
- }
-
- c = (v4*v3 - v1*v6)/v7;
- if( v1 != 0 )
- r = (v3 - c*v2)/v1;
- else
- r = (v6 - c*v5)/v4;
-
- ro2 = ( (r-r1)*(r-r1) + (c-c1)*(c-c1) );
-
- return;
-}
-
-
-void write_Shx(std::vector<Shx> &pts, char * fname){
- std::ofstream out(fname, ios::out);
-
- int nr = pts.size();
- out << nr << " 2" << endl;
-
- for (int r = 0; r < nr; r++){
- out << pts[r].r << ' ' << pts[r].c << endl;
- }
- out.close();
-
- return;
-};
-
-
-
-/*
- write out triangle ids to be compatible with matlab/octave array numbering.
-
- */
-void write_Triads(std::vector<Triad> &ts, char * fname){
- std::ofstream out(fname, ios::out);
-
- int nr = ts.size();
- out << nr << " 7" << endl;
-
- for (int r = 0; r < nr; r++){
- out << ts[r].a+1 << ' ' << ts[r].b+1 <<' ' << ts[r].c+1 <<' '
- << ts[r].ab+1 <<' ' << ts[r].ac+1 <<' ' << ts[r].bc+1 << " " << ts[r].ro << endl;
- }
- out.close();
-
- return;
-};
-
-
-
-
-void T_flip2( std::vector<Shx> &pts, std::vector<Triad> &triads, int *slump, int numt, int start){
-
- float R,C,r0,c0, r1,c1, r2,c2, r3,c3, rot, rot2, dR, dC;
- int pa,pb,pc, pd, ab, bc, ac, D, L1, L2, L3, L4, T2;
- std::vector<int> aliens;
- Triad tx, tx2;
- std::set<int> ids;
-
- for( int t=start; t<numt; t++){
-
- //write_Triads(triads, "tflip0.mat");
-
- Triad &tri = triads[t];
- // test all 3 neighbours of tri
- pa = slump[tri.a];
- pb = slump[tri.b];
- pc = slump[tri.c];
-
- int flipped = 0;
-
-
- if( tri.bc >= 0 ){
- T2 = tri.bc;
- Triad &t2 = triads[T2];
- // find relative orientation (shared limb).
- if( t2.ab == t ){
- D = t2.c;
- pd = slump[t2.c];
-
- if( tri.a == t2.a){
- L3 = t2.ac;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ac;
- }
- }
- else if( t2.ac == t ){
- D = t2.b;
- pd = slump[t2.b];
-
- if( tri.a == t2.a){
- L3 = t2.ab;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ab;
- }
- }
- else if( t2.bc == t ){
- D = t2.a;
- pd = slump[t2.a];
-
- if( tri.b == t2.b){
- L3 = t2.ab;
- L4 = t2.ac;
- }
- else{
- L3 = t2.ac;
- L4 = t2.ab;
- }
- }
- else{
- cerr << "fuck up at line 12 dude!" << endl;
- }
-
- r3 = pts[pd].r;
- c3 = pts[pd].c;
- dR = tri.R-r3;
- dC = tri.C-c3;
-
-
- if( dR*dR+dC*dC < tri.ro ){ // not valid in the Delaunay sense.
- L1 = tri.ab;
- L2 = tri.ac;
-
- circle_cent2(pts[pa].r, pts[pa].c, pts[pb].r, pts[pb].c, r3, c3, R, C , rot);
-
- tx.a = tri.a;
- tx.b = tri.b;
- tx.c = D;
- tx.ro = rot;
- tx.R = R;
- tx.C = C;
-
- tx.ab = L1;
- tx.ac = T2;
- tx.bc = L3;
-
-
- // triangle 2;
- tx2.a = tri.a;
- tx2.b = tri.c;
- tx2.c = D;
- circle_cent2(pts[pa].r, pts[pa].c, pts[pc].r, pts[pc].c, r3, c3, R, C , rot);
- tx2.ro = rot;
- tx2.R = R;
- tx2.C = C;
-
- tx2.ab = L2;
- tx2.ac = t;
- tx2.bc = L4;
-
-
- ids.insert(t);
- ids.insert(T2);
-
- t2 = tx2;
- tri = tx;
- flipped = 1;
-
- // change knock on triangle labels.
- if( L3 >= 0 ){
- Triad &t3 = triads[L3];
- if( t3.ab == T2 ) t3.ab = t;
- else if( t3.bc == T2 ) t3.bc = t;
- else if( t3.ac == T2 ) t3.ac = t;
- }
-
- if(L2 >= 0 ){
- Triad &t4 = triads[L2];
- if( t4.ab == t ) t4.ab = T2;
- else if( t4.bc == t ) t4.bc = T2;
- else if( t4.ac == t ) t4.ac = T2;
- }
-
- }
- }
-
- //write_Triads(triads, "tflip1.mat");
- int df = 9;
- df = 8;
- }
-
-
-
-
-
-
- return;
-}
-
-
-
-/* version in which the ids of the triangles associated with the sides of the hull are tracked.
-
-
- */
-
-void s_hull_del_ray2( std::vector<Shx> &pts, std::vector<Triad> &triads)
-{
-
- int nump = pts.size();
-
-
- float r = pts[0].r;
- float c = pts[0].c;
- for( int k=0; k<nump; k++){
- float dr = pts[k].r-r;
- float dc = pts[k].c-c;
-
- pts[k].ro = dr*dr + dc*dc;
-
- }
-
- sort( pts.begin(), pts.end() );
-
-
- float r1 = pts[0].r;
- float c1 = pts[0].c;
-
- float r2 = pts[1].r;
- float c2 = pts[1].c;
- int mid = -1;
- float romin2 = 100000000.0, ro2, R,C;
-
- int k=2;
- while (k<nump){
-
- circle_cent2(r1,c1,r2,c2, pts[k].r, pts[k].c, r,c,ro2);
- if( ro2 < romin2 && ro2 > 0 ){
- mid = k;
- romin2 = ro2;
- R = r;
- C = c;
-
- }
- else if( romin2 *4 < pts[k].ro )
- k=nump;
-
- k++;
- }
-
- //std::cerr << "earwig noodles " << pts[1].id << " " << pts[mid].id << " " << romin2 << endl;
-
- Shx pt0 = pts[0];
- Shx pt1 = pts[1];
- Shx pt2 = pts[mid];
-
- pts.erase(pts.begin() + mid); // necessary for round off reasons:((((((
- pts.erase(pts.begin() );
- pts.erase(pts.begin() );
-
- for( int k=0; k<nump-3; k++){
- float dr = pts[k].r-R;
- float dc = pts[k].c-C;
-
- pts[k].ro = dr*dr + dc*dc;
-
- }
-
- sort( pts.begin(), pts.end() );
-
- pts.insert(pts.begin(), pt2);
- pts.insert(pts.begin(), pt1);
- pts.insert(pts.begin(), pt0);
-
- int slump [nump];
-
- for( int k=0; k<nump; k++){
- slump[ pts[k].id] = k;
- }
-
- std::vector<Shx> hull;
-
-
- r = (pts[0].r + pts[1].r + pts[2].r )/3.0;
- c = (pts[0].c + pts[1].c + pts[2].c )/3.0;
-
- float dr0 = pts[0].r - r, dc0 = pts[0].c - c;
- float tr01 = pts[1].r - pts[0].r, tc01 = pts[1].c - pts[0].c;
-
- float df = -tr01* dc0 + tc01*dr0;
- if( df < 0 ){ // [ 0 1 2 ]
- pt0.tr = pt1.r-pt0.r;
- pt0.tc = pt1.c-pt0.c;
- pt0.trid = 0;
- hull.push_back( pt0 );
-
- pt1.tr = pt2.r-pt1.r;
- pt1.tc = pt2.c-pt1.c;
- pt1.trid = 0;
- hull.push_back( pt1 );
-
- pt2.tr = pt0.r-pt2.r;
- pt2.tc = pt0.c-pt2.c;
- pt2.trid = 0;
- hull.push_back( pt2 );
-
-
- Triad tri(pt0.id,pt1.id,pt2.id);
- tri.ro = romin2;
- tri.R = R;
- tri.C = C;
-
- triads.push_back(tri);
-
- }
- else{ // [ 0 2 1 ] as anti-clockwise turning is the work of the devil....
- pt0.tr = pt2.r-pt0.r;
- pt0.tc = pt2.c-pt0.c;
- pt0.trid = 0;
- hull.push_back( pt0 );
-
- pt2.tr = pt1.r-pt2.r;
- pt2.tc = pt1.c-pt2.c;
- pt2.trid = 0;
- hull.push_back( pt2 );
-
- pt1.tr = pt0.r-pt1.r;
- pt1.tc = pt0.c-pt1.c;
- pt1.trid = 0;
- hull.push_back( pt1 );
-
- Triad tri(pt0.id,pt2.id,pt1.id);
- tri.ro = romin2;
- tri.R = R;
- tri.C = C;
- triads.push_back(tri);
- }
-
- // add new points into hull (removing obscured ones from the chain)
- // and creating triangles....
- // that will need to be flipped.
-
- float dr, dc, rx,cx;
- Shx ptx;
- int numt;
-
- for( int k=3; k<nump; k++){
- rx = pts[k].r; cx = pts[k].c;
- ptx.r = rx;
- ptx.c = cx;
- ptx.id = pts[k].id;
-
- int numh = hull.size(), numh_old = numh;
- dr = rx- hull[0].r; dc = cx- hull[0].c; // outwards pointing from hull[0] to pt.
-
- if(0){
- cerr << "numt = " << triads.size() << endl;
- cerr << "ids = [ " ;
- for(int g=0; g<numh; g++){
- cerr << hull[g].id+1 << ' ' ;
- }
- cerr << hull[0].id+1 << "];" << endl;
-
-
- cerr << "trids = [ " ;
- for(int g=0; g<numh; g++){
- cerr << hull[g].trid+1 << ' ' ;
- }
- cerr << hull[0].trid+1 << "];" << endl;
-
-
- cerr << "h_test = [ " ;
- for(int g=0; g<numh-1; g++){
- float gaf = -(hull[g+1].c-hull[g].c) * hull[g].tr + (hull[g+1].r-hull[g].r)*hull[g].tc;
- cerr << gaf << ' ' ;
- }
-
- cerr << -(hull[0].c-hull[numh-1].c) * hull[numh-1].tr +
- (hull[0].r-hull[numh-1].r)*hull[numh-1].tc << "];" << endl;
-
- }
-
-
- std::vector<int> pidx, tridx;
- int hidx; // new hull point location within hull.....
-
-
- float df = -dc* hull[0].tr + dr*hull[0].tc; // visibility test vector.
- if( df < 0 ){ // starting with a visible hull facet !!!
- int e1 = 1, e2 = numh;
- hidx = 0;
-
- // check to see if segment numh is also visible
- df = -dc* hull[numh-1].tr + dr*hull[numh-1].tc;
- //cerr << df << ' ' ;
- if( df < 0 ){ // visible.
- pidx.push_back(hull[numh-1].id);
- tridx.push_back(hull[numh-1].trid);
-
-
- for( int h=0; h<numh-1; h++){
- // if segment h is visible delete h
- dr = rx- hull[h].r; dc = cx- hull[h].c;
- df = -dc* hull[h].tr + dr*hull[h].tc;
- pidx.push_back(hull[h].id);
- tridx.push_back(hull[h].trid);
- if( df < 0 ){
- hull.erase(hull.begin() + h);
- h--;
- numh--;
- }
- else{ // quit on invisibility
- ptx.tr = hull[h].r - ptx.r;
- ptx.tc = hull[h].c - ptx.c;
-
- hull.insert( hull.begin() , ptx);
- numh++;
- break;
- }
- }
- // look backwards through the hull structure.
-
- for( int h=numh-2; h>0; h--){
- // if segment h is visible delete h + 1
- dr = rx- hull[h].r; dc = cx- hull[h].c;
- df = -dc* hull[h].tr + dr*hull[h].tc;
-
- if( df < 0 ){ // h is visible
- pidx.insert(pidx.begin(), hull[h].id);
- tridx.insert(tridx.begin(), hull[h].trid);
- hull.erase(hull.begin() + h+1); // erase end of chain
-
- }
- else{
-
- h = hull.size()-1;
- hull[h].tr = -hull[h].r + ptx.r; // points at start of chain.
- hull[h].tc = -hull[h].c + ptx.c;
- break;
- }
- }
-
- df = 9;
-
- }
- else{
- // cerr << df << ' ' << endl;
- hidx = 1; // keep pt hull[0]
- tridx.push_back(hull[0].trid);
- pidx.push_back(hull[0].id);
-
- for( int h=1; h<numh; h++){
- // if segment h is visible delete h
- dr = rx- hull[h].r; dc = cx- hull[h].c;
- df = -dc* hull[h].tr + dr*hull[h].tc;
- pidx.push_back(hull[h].id);
- tridx.push_back(hull[h].trid);
- if( df < 0 ){ // visible
- hull.erase(hull.begin() + h);
- h--;
- numh--;
- }
- else{ // quit on invisibility
- ptx.tr = hull[h].r - ptx.r;
- ptx.tc = hull[h].c - ptx.c;
-
- hull[h-1].tr = ptx.r - hull[h-1].r;
- hull[h-1].tc = ptx.c - hull[h-1].c;
-
- hull.insert( hull.begin()+h, ptx);
- break;
- }
- }
- }
-
- df = 8;
-
- }
- else{
- int e1 = -1, e2 = numh;
- for( int h=1; h<numh; h++){
- dr = rx- hull[h].r; dc = cx- hull[h].c;
- df = -dc* hull[h].tr + dr*hull[h].tc;
- if( df < 0 ){
- if( e1 < 0 ) e1 = h; // fist visible
- }
- else{
- if( e1 > 0 ){ // first invisible segment.
- e2 = h;
- break;
- }
- }
-
- }
-
-
- // triangle pidx starts at e1 and ends at e2 (inclusive).
- if( e2 < numh ){
- for( int e=e1; e<=e2; e++){
- pidx.push_back(hull[e].id);
- tridx.push_back(hull[e].trid);
- }
- }
- else{
- for( int e=e1; e<e2; e++){
- pidx.push_back(hull[e].id);
- tridx.push_back(hull[e].trid); // there are only n-1 triangles from n hull pts.
- }
- pidx.push_back(hull[0].id);
- }
-
-
- // erase elements e1+1 : e2-1 inclusive.
-
- if( e1 < e2-1){
- hull.erase(hull.begin() + e1+1, hull.begin()+ e2);
- }
-
- // insert ptx at location e1+1.
- if( e2 == numh){
- ptx.tr = hull[0].r - ptx.r;
- ptx.tc = hull[0].c - ptx.c;
- }
- else{
- ptx.tr = hull[e1+1].r - ptx.r;
- ptx.tc = hull[e1+1].c - ptx.c;
- }
-
- hull[e1].tr = ptx.r - hull[e1].r;
- hull[e1].tc = ptx.c - hull[e1].c;
-
- hull.insert( hull.begin()+e1+1, ptx);
- hidx = e1+1;
-
- }
-
-
- int a = ptx.id, T0;
- Triad trx( a, 0,0);
- r1 = pts[slump[a]].r;
- c1 = pts[slump[a]].c;
-
- int npx = pidx.size()-1;
- numt = triads.size();
- T0 = numt;
-
- if( npx == 1){
- trx.b = pidx[0];
- trx.c = pidx[1];
-
- // compute circum circle radius squared (only relative size is required for flipping)
-
- r2 = pts[slump[trx.b]].r;
- c2 = pts[slump[trx.b]].c;
-
- circle_cent2(r1,c1,r2,c2, pts[slump[trx.c]].r,pts[slump[trx.c]].c , r,c,ro2);
- trx.ro = ro2;
- trx.R = r;
- trx.C = c;
-
- trx.bc = tridx[0];
- trx.ab = -1;
- trx.ac = -1;
-
- // index back into the triads.
- Triad &txx = triads[tridx[0]];
- if( ( trx.b == txx.a && trx.c == txx.b) |( trx.b == txx.b && trx.c == txx.a)) {
- txx.ab = numt;
- }
- else if( ( trx.b == txx.a && trx.c == txx.c) |( trx.b == txx.c && trx.c == txx.a)) {
- txx.ac = numt;
- }
- else if( ( trx.b == txx.b && trx.c == txx.c) |( trx.b == txx.c && trx.c == txx.b)) {
- txx.bc = numt;
- }
-
-
- hull[hidx].trid = numt;
- if( hidx > 0 )
- hull[hidx-1].trid = numt;
- else{
- numh = hull.size();
- hull[numh-1].trid = numt;
- }
- triads.push_back( trx );
- numt++;
- }
-
- else{
- trx.ab = -1;
- for(int p=0; p<npx; p++){
- trx.b = pidx[p];
- trx.c = pidx[p+1];
-
- // compute circum circle radius squared (only relative size is required for flipping)
-
- r2 = pts[slump[trx.b]].r;
- c2 = pts[slump[trx.b]].c;
-
- circle_cent2(r1,c1,r2,c2, pts[slump[trx.c]].r,pts[slump[trx.c]].c , r,c,ro2);
- trx.ro = ro2;
- trx.R = r;
- trx.C = c;
-
-
- trx.bc = tridx[p];
- if( p > 0 )
- trx.ab = numt-1;
- trx.ac = numt+1;
-
- // index back into the triads.
- Triad &txx = triads[tridx[p]];
- if( ( trx.b == txx.a && trx.c == txx.b) |( trx.b == txx.b && trx.c == txx.a)) {
- txx.ab = numt;
- }
- else if( ( trx.b == txx.a && trx.c == txx.c) |( trx.b == txx.c && trx.c == txx.a)) {
- txx.ac = numt;
- }
- else if( ( trx.b == txx.b && trx.c == txx.c) |( trx.b == txx.c && trx.c == txx.b)) {
- txx.bc = numt;
- }
-
- if( trx.ab == 26777 || trx.ac == 26777 || trx.bc == 26777){
- int foon = 7;
- }
-
- triads.push_back( trx );
- numt++;
- }
- triads[numt-1].ac=-1;
-
- hull[hidx].trid = numt-1;
- if( hidx > 0 )
- hull[hidx-1].trid = T0;
- else{
- numh = hull.size();
- hull[numh-1].trid = T0;
- }
-
-
- }
-
-
- // write_Triads(triads, "tris.mat");
- //int dfx = 9;
- //T_flip2( pts, triads, slump, numt, T0);
-
- //write_Triads(triads, "tris2.mat");
-
- }
-
- cerr << "of triangles " << triads.size() << " to be flipped. "<< endl;
-
- //write_Triads(triads, "tris0.mat");
-
- std::set<int> ids, ids2;
- T_flip3( pts, triads, slump, numt, 0, ids);
-
-
- int nits = ids.size(), nit=1;
- while( nits > 0 && nit < 20){
- // char nam[128];
- //sprintf(nam, "tris_%d.mat", nit);
- //write_Triads(triads, nam);
-
- T_flip4( pts, triads, slump, ids);
- nits = ids.size();
- nit ++;
-
- }
- //write_Triads(triads, "triangles3.mat");
-
- return;
-}
-
-/*
- flip pairs of triangles that are not valid delaunay triangles
- (the test used is the circum circle not containing any point of the other triangle (in bad English))
-
- */
-
-
-void T_flip3( std::vector<Shx> &pts, std::vector<Triad> &triads, int *slump, int numt, int start, std::set<int> &ids){
-
- float R,C,r0,c0, r1,c1, r2,c2, r3,c3, rot, rot2, dR, dC;
- int pa,pb,pc, pd, ab, bc, ac, D, L1, L2, L3, L4, T2;
- std::vector<int> aliens;
- Triad tx, tx2;
- //std::set<int> ids;
-
- for( int t=start; t<numt; t++){
-
- //write_Triads(triads, "tflip0.mat");
-
- Triad &tri = triads[t];
- // test all 3 neighbours of tri
-
- int flipped = 0;
-
- if( tri.bc >= 0 ){
-
- pa = slump[tri.a];
- pb = slump[tri.b];
- pc = slump[tri.c];
-
- T2 = tri.bc;
- Triad &t2 = triads[T2];
- // find relative orientation (shared limb).
- if( t2.ab == t ){
- D = t2.c;
- pd = slump[t2.c];
-
- if( tri.b == t2.a){
- L3 = t2.ac;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ac;
- }
- }
- else if( t2.ac == t ){
- D = t2.b;
- pd = slump[t2.b];
-
- if( tri.b == t2.a){
- L3 = t2.ab;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ab;
- }
- }
- else if( t2.bc == t ){
- D = t2.a;
- pd = slump[t2.a];
-
- if( tri.b == t2.b){
- L3 = t2.ab;
- L4 = t2.ac;
- }
- else{
- L3 = t2.ac;
- L4 = t2.ab;
- }
- }
- else{
- cerr << "fuck up at line 12 dude! " << t << endl;
- }
-
- r3 = pts[pd].r;
- c3 = pts[pd].c;
- dR = tri.R-r3;
- dC = tri.C-c3;
-
-
- if( dR*dR+dC*dC < tri.ro ){ // not valid in the Delaunay sense.
- L1 = tri.ab;
- L2 = tri.ac;
- if( L1 != L3 && L2 != L4 ){ // need this check for stability.
-
- circle_cent2(pts[pa].r, pts[pa].c, pts[pb].r, pts[pb].c, r3, c3, R, C , rot);
-
- tx.a = tri.a;
- tx.b = tri.b;
- tx.c = D;
- tx.ro = rot;
- tx.R = R;
- tx.C = C;
-
- tx.ab = L1;
- tx.ac = T2;
- tx.bc = L3;
-
-
- // triangle 2;
- tx2.a = tri.a;
- tx2.b = tri.c;
- tx2.c = D;
- circle_cent2(pts[pa].r, pts[pa].c, pts[pc].r, pts[pc].c, r3, c3, R, C , rot);
- tx2.ro = rot;
- tx2.R = R;
- tx2.C = C;
-
- tx2.ab = L2;
- tx2.ac = t;
- tx2.bc = L4;
-
-
- ids.insert(t);
- ids.insert(T2);
-
- t2 = tx2;
- tri = tx;
- flipped = 1;
-
- // change knock on triangle labels.
- if( L3 >= 0 ){
- Triad &t3 = triads[L3];
- if( t3.ab == T2 ) t3.ab = t;
- else if( t3.bc == T2 ) t3.bc = t;
- else if( t3.ac == T2 ) t3.ac = t;
- }
-
- if(L2 >= 0 ){
- Triad &t4 = triads[L2];
- if( t4.ab == t ) t4.ab = T2;
- else if( t4.bc == t ) t4.bc = T2;
- else if( t4.ac == t ) t4.ac = T2;
- }
- }
- }
- }
-
-
- if( flipped == 0 && tri.ab >= 0 ){
-
- pc = slump[tri.c];
- pb = slump[tri.b];
- pa = slump[tri.a];
-
- T2 = tri.ab;
- Triad &t2 = triads[T2];
- // find relative orientation (shared limb).
- if( t2.ab == t ){
- D = t2.c;
- pd = slump[t2.c];
-
- if( tri.a == t2.a){
- L3 = t2.ac;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ac;
- }
- }
- else if( t2.ac == t ){
- D = t2.b;
- pd = slump[t2.b];
-
- if( tri.a == t2.a){
- L3 = t2.ab;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ab;
- }
- }
- else if( t2.bc == t ){
- D = t2.a;
- pd = slump[t2.a];
-
- if( tri.a == t2.b){
- L3 = t2.ab;
- L4 = t2.ac;
- }
- else{
- L3 = t2.ac;
- L4 = t2.ab;
- }
- }
- else{
- cerr << "fuck up at line 13 dude! " << t << endl;
- }
-
- r3 = pts[pd].r;
- c3 = pts[pd].c;
- dR = tri.R-r3;
- dC = tri.C-c3;
-
-
- if( dR*dR+dC*dC < tri.ro ){ // not valid in the Delaunay sense.
- L1 = tri.ac;
- L2 = tri.bc;
- if( L1 != L3 && L2 != L4 ){ // need this check for stability.
-
- circle_cent2(pts[pa].r, pts[pa].c, pts[pc].r, pts[pc].c, r3, c3, R, C , rot);
-
- tx.a = tri.c;
- tx.b = tri.a;
- tx.c = D;
- tx.ro = rot;
- tx.R = R;
- tx.C = C;
-
- tx.ab = L1;
- tx.ac = T2;
- tx.bc = L3;
-
-
- // triangle 2;
- tx2.a = tri.c;
- tx2.b = tri.b;
- tx2.c = D;
- circle_cent2(pts[pb].r, pts[pb].c, pts[pc].r, pts[pc].c, r3, c3, R, C , rot);
- tx2.ro = rot;
- tx2.R = R;
- tx2.C = C;
-
- tx2.ab = L2;
- tx2.ac = t;
- tx2.bc = L4;
-
-
- ids.insert(t);
- ids.insert(T2);
-
- t2 = tx2;
- tri = tx;
- flipped = 1;
-
- // change knock on triangle labels.
- if( L3 >= 0 ){
- Triad &t3 = triads[L3];
- if( t3.ab == T2 ) t3.ab = t;
- else if( t3.bc == T2 ) t3.bc = t;
- else if( t3.ac == T2 ) t3.ac = t;
- }
-
- if(L2 >= 0 ){
- Triad &t4 = triads[L2];
- if( t4.ab == t ) t4.ab = T2;
- else if( t4.bc == t ) t4.bc = T2;
- else if( t4.ac == t ) t4.ac = T2;
- }
-
- }
-
- }
- }
-
-
- if( flipped == 0 && tri.ac >= 0 ){
-
- pc = slump[tri.c];
- pb = slump[tri.b];
- pa = slump[tri.a];
-
- T2 = tri.ac;
- Triad &t2 = triads[T2];
- // find relative orientation (shared limb).
- if( t2.ab == t ){
- D = t2.c;
- pd = slump[t2.c];
-
- if( tri.a == t2.a){
- L3 = t2.ac;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ac;
- }
- }
- else if( t2.ac == t ){
- D = t2.b;
- pd = slump[t2.b];
-
- if( tri.a == t2.a){
- L3 = t2.ab;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ab;
- }
- }
- else if( t2.bc == t ){
- D = t2.a;
- pd = slump[t2.a];
-
- if( tri.a == t2.b){
- L3 = t2.ab;
- L4 = t2.ac;
- }
- else{
- L3 = t2.ac;
- L4 = t2.ab;
- }
- }
- else{
- cerr << "fuck up at line 14 dude! " << t << endl;
- }
-
- r3 = pts[pd].r;
- c3 = pts[pd].c;
- dR = tri.R-r3;
- dC = tri.C-c3;
-
-
- if( dR*dR+dC*dC < tri.ro ){ // not valid in the Delaunay sense.
- L1 = tri.ab; // .ac shared limb
- L2 = tri.bc;
- if( L1 != L3 && L2 != L4 ){ // need this check for stability.
-
- circle_cent2(pts[pa].r, pts[pa].c, pts[pb].r, pts[pb].c, r3, c3, R, C , rot);
-
- tx.a = tri.b;
- tx.b = tri.a;
- tx.c = D;
- tx.ro = rot;
- tx.R = R;
- tx.C = C;
-
- tx.ab = L1;
- tx.ac = T2;
- tx.bc = L3;
-
-
- // triangle 2;
- tx2.a = tri.b;
- tx2.b = tri.c;
- tx2.c = D;
- circle_cent2(pts[pb].r, pts[pb].c, pts[pc].r, pts[pc].c, r3, c3, R, C , rot);
- tx2.ro = rot;
- tx2.R = R;
- tx2.C = C;
-
- tx2.ab = L2;
- tx2.ac = t;
- tx2.bc = L4;
-
- ids.insert(t);
- ids.insert(T2);
-
- t2 = tx2;
- tri = tx;
-
- // change knock on triangle labels.
- if( L3 >= 0 ){
- Triad &t3 = triads[L3];
- if( t3.ab == T2 ) t3.ab = t;
- else if( t3.bc == T2 ) t3.bc = t;
- else if( t3.ac == T2 ) t3.ac = t;
- }
-
- if(L2 >= 0 ){
- Triad &t4 = triads[L2];
- if( t4.ab == t ) t4.ab = T2;
- else if( t4.bc == t ) t4.bc = T2;
- else if( t4.ac == t ) t4.ac = T2;
- }
-
- }
- }
- }
-
- //write_Triads(triads, "tflip1.mat");
- int df = 9;
- df = 8;
- }
-
-
- // cerr << " triangles to resolve " << ids.size() << endl;
-
-
-
-
-
- return;
-}
-
-
-
-
-
-
-
-// same again but with set of triangle ids to be iterated over.
-
-
-void T_flip4( std::vector<Shx> &pts, std::vector<Triad> &triads, int *slump, std::set<int> &ids){
-
- float R,C,r0,c0, r1,c1, r2,c2, r3,c3, rot, rot2, dR, dC;
- int pa,pb,pc, pd, ab, bc, ac, D, L1, L2, L3, L4, T2;
-
- Triad tx, tx2;
- std::set<int> ids2;
- ids2.clear();
-
- std::set<int> :: const_iterator x=ids.begin();
- while(x != ids.end() ){
- int t = *x;
- x++;
-
-
- Triad &tri = triads[t];
- // test all 3 neighbours of tri
- int flipped = 0;
-
-
-
- if( tri.bc >= 0 ){
-
- pa = slump[tri.a];
- pb = slump[tri.b];
- pc = slump[tri.c];
-
- T2 = tri.bc;
- Triad &t2 = triads[T2];
- // find relative orientation (shared limb).
- if( t2.ab == t ){
- D = t2.c;
- pd = slump[t2.c];
-
- if( tri.b == t2.a){
- L3 = t2.ac;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ac;
- }
- }
- else if( t2.ac == t ){
- D = t2.b;
- pd = slump[t2.b];
-
- if( tri.b == t2.a){
- L3 = t2.ab;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ab;
- }
- }
- else if( t2.bc == t ){
- D = t2.a;
- pd = slump[t2.a];
-
- if( tri.b == t2.b){
- L3 = t2.ab;
- L4 = t2.ac;
- }
- else{
- L3 = t2.ac;
- L4 = t2.ab;
- }
- }
- else{
- cerr << "fuck up at line 15 dude! t: " << t << " T2: " << T2<< endl;
- // tri.prnt();
- //t2.prnt();
-
- }
-
- r3 = pts[pd].r;
- c3 = pts[pd].c;
- dR = tri.R-r3;
- dC = tri.C-c3;
-
-
- if( dR*dR+dC*dC < tri.ro ){ // not valid in the Delaunay sense.
- L1 = tri.ab;
- L2 = tri.ac;
-
- if( L1 != L3 && L2 != L4 ){ // need this check for stability.
-
- circle_cent2(pts[pa].r, pts[pa].c, pts[pb].r, pts[pb].c, r3, c3, R, C , rot);
-
- tx.a = tri.a;
- tx.b = tri.b;
- tx.c = D;
- tx.ro = rot;
- tx.R = R;
- tx.C = C;
-
- tx.ab = L1;
- tx.ac = T2;
- tx.bc = L3;
-
-
- // triangle 2;
- tx2.a = tri.a;
- tx2.b = tri.c;
- tx2.c = D;
- circle_cent2(pts[pa].r, pts[pa].c, pts[pc].r, pts[pc].c, r3, c3, R, C , rot);
- tx2.ro = rot;
- tx2.R = R;
- tx2.C = C;
-
- tx2.ab = L2;
- tx2.ac = t;
- tx2.bc = L4;
-
- ids2.insert(t);
- ids2.insert(T2);
-
- t2 = tx2;
- tri = tx;
- flipped = 1;
-
- // change knock on triangle labels.
- if( L3 >= 0 ){
- Triad &t3 = triads[L3];
- if( t3.ab == T2 ) t3.ab = t;
- else if( t3.bc == T2 ) t3.bc = t;
- else if( t3.ac == T2 ) t3.ac = t;
- }
-
- if(L2 >= 0 ){
- Triad &t4 = triads[L2];
- if( t4.ab == t ) t4.ab = T2;
- else if( t4.bc == t ) t4.bc = T2;
- else if( t4.ac == t ) t4.ac = T2;
- }
- //if( triads[26777].ab == 27004 && triads[26777].bc == 27004)
- // cerr << " feck 1 " << endl;
- }
- }
- }
-
-
- if( flipped == 0 && tri.ab >= 0 ){
-
- pc = slump[tri.c];
- pb = slump[tri.b];
- pa = slump[tri.a];
-
- T2 = tri.ab;
- Triad &t2 = triads[T2];
- // find relative orientation (shared limb).
- if( t2.ab == t ){
- D = t2.c;
- pd = slump[t2.c];
-
- if( tri.a == t2.a){
- L3 = t2.ac;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ac;
- }
- }
- else if( t2.ac == t ){
- D = t2.b;
- pd = slump[t2.b];
-
- if( tri.a == t2.a){
- L3 = t2.ab;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ab;
- }
- }
- else if( t2.bc == t ){
- D = t2.a;
- pd = slump[t2.a];
-
- if( tri.a == t2.b){
- L3 = t2.ab;
- L4 = t2.ac;
- }
- else{
- L3 = t2.ac;
- L4 = t2.ab;
- }
- }
- else{
- cerr << "fuck up at line 16 dude! " << t << endl;
- }
-
- r3 = pts[pd].r;
- c3 = pts[pd].c;
- dR = tri.R-r3;
- dC = tri.C-c3;
-
-
- if( dR*dR+dC*dC < tri.ro ){ // not valid in the Delaunay sense.
- L1 = tri.ac;
- L2 = tri.bc;
- if( L1 != L3 && L2 != L4 ){ // need this check for stability.
- circle_cent2(pts[pa].r, pts[pa].c, pts[pc].r, pts[pc].c, r3, c3, R, C , rot);
-
- tx.a = tri.c;
- tx.b = tri.a;
- tx.c = D;
- tx.ro = rot;
- tx.R = R;
- tx.C = C;
-
- tx.ab = L1;
- tx.ac = T2;
- tx.bc = L3;
-
-
- // triangle 2;
- tx2.a = tri.c;
- tx2.b = tri.b;
- tx2.c = D;
- circle_cent2(pts[pb].r, pts[pb].c, pts[pc].r, pts[pc].c, r3, c3, R, C , rot);
- tx2.ro = rot;
- tx2.R = R;
- tx2.C = C;
-
- tx2.ab = L2;
- tx2.ac = t;
- tx2.bc = L4;
-
- if( (tx.ab == 26777 && tx.ac == 26777 && tx.bc == 26777) ||
- (tx2.ab == 26777 && tx2.ac == 26777 && tx2.bc == 26777) ){
- int foon = 8;
- }
-
-
- ids2.insert(t);
- ids2.insert(T2);
-
- t2 = tx2;
- tri = tx;
- flipped = 1;
-
- // change knock on triangle labels.
- if( L3 >= 0 ){
- Triad &t3 = triads[L3];
- if( t3.ab == T2 ) t3.ab = t;
- else if( t3.bc == T2 ) t3.bc = t;
- else if( t3.ac == T2 ) t3.ac = t;
- }
-
- if(L2 >= 0 ){
- Triad &t4 = triads[L2];
- if( t4.ab == t ) t4.ab = T2;
- else if( t4.bc == t ) t4.bc = T2;
- else if( t4.ac == t ) t4.ac = T2;
- }
- ///if( triads[26777].ab == 27004 && triads[26777].bc == 27004)
- // cerr << " feck 2 " << endl;
- }
- }
- }
-
-
- if( flipped == 0 && tri.ac >= 0 ){
-
- pc = slump[tri.c];
- pb = slump[tri.b];
- pa = slump[tri.a];
-
- T2 = tri.ac;
- Triad &t2 = triads[T2];
- // find relative orientation (shared limb).
- if( t2.ab == t ){
- D = t2.c;
- pd = slump[t2.c];
-
- if( tri.a == t2.a){
- L3 = t2.ac;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ac;
- }
- }
- else if( t2.ac == t ){
- D = t2.b;
- pd = slump[t2.b];
-
- if( tri.a == t2.a){
- L3 = t2.ab;
- L4 = t2.bc;
- }
- else{
- L3 = t2.bc;
- L4 = t2.ab;
- }
- }
- else if( t2.bc == t ){
- D = t2.a;
- pd = slump[t2.a];
-
- if( tri.a == t2.b){
- L3 = t2.ab;
- L4 = t2.ac;
- }
- else{
- L3 = t2.ac;
- L4 = t2.ab;
- }
- }
- else{
- cerr << "fuck up at line 17 dude! " << t << endl;
- }
-
- r3 = pts[pd].r;
- c3 = pts[pd].c;
- dR = tri.R-r3;
- dC = tri.C-c3;
-
- float scubit = dR*dR+dC*dC - tri.ro;
-
- if( scubit < 0.0 ){ // not valid in the Delaunay sense.
- L1 = tri.ab; // .ac shared limb
- L2 = tri.bc;
- if( L1 != L3 && L2 != L4 ){ // need this check for stability.
-
- if( -scubit*1000 > tri.ro )
- circle_cent2(pts[pa].r, pts[pa].c, pts[pb].r, pts[pb].c, r3, c3, R, C , rot);
- else{
- circle_cent4(pts[pa].r, pts[pa].c, pts[pb].r, pts[pb].c, r3, c3, R, C , rot);
- //cerr << "duff " << t << " scubit " << scubit << endl;
- }
-
- tx.a = tri.b;
- tx.b = tri.a;
- tx.c = D;
- tx.ro = rot;
- tx.R = R;
- tx.C = C;
-
- tx.ab = L1;
- tx.ac = T2;
- tx.bc = L3;
-
-
- // triangle 2;
- tx2.a = tri.b;
- tx2.b = tri.c;
- tx2.c = D;
-
-
- if( -scubit*1000 > tri.ro )
- circle_cent2(pts[pb].r, pts[pb].c, pts[pc].r, pts[pc].c, r3, c3, R, C , rot);
- else{
- circle_cent2(pts[pb].r, pts[pb].c, pts[pc].r, pts[pc].c, r3, c3, R, C , rot);
- //cerr << "duff " << t << " scubit " << scubit << endl;
- }
-
- tx2.ro = rot;
- tx2.R = R;
- tx2.C = C;
-
- tx2.ab = L2;
- tx2.ac = t;
- tx2.bc = L4;
-
-
- ids2.insert(t);
- ids2.insert(T2);
-
- t2 = tx2;
- tri = tx;
-
- // change knock on triangle labels.
- if( L3 >= 0 ){
- Triad &t3 = triads[L3];
- if( t3.ab == T2 ) t3.ab = t;
- else if( t3.bc == T2 ) t3.bc = t;
- else if( t3.ac == T2 ) t3.ac = t;
- }
-
- if(L2 >= 0 ){
- Triad &t4 = triads[L2];
- if( t4.ab == t ) t4.ab = T2;
- else if( t4.bc == t ) t4.bc = T2;
- else if( t4.ac == t ) t4.ac = T2;
- }
-
- //if( triads[26777].ab == 27004 && triads[26777].bc == 27004)
- // cerr << " feck 3" << endl;
- }
- }
- }
-
- //write_Triads(triads, "tflip1.mat");
- int df = 9;
- df = 8;
- }
-
-
- // cerr << " triangles to resolve " << ids2.size() << endl;
- ids.clear();
- ids.insert(ids2.begin(), ids2.end());
-
- return;
-}
-
-
-void circle_cent4(float r1,float c1, float r2,float c2, float r3,float c3,
- float &r,float &c, float &ro2){
- /*
- * function to return the center of a circle and its radius
- * degenerate case should never be passed to this routine!!!!!!!!!!!!!
- * but will return r0 = -1 if it is.
- */
-
- double rd, cd;
- double v1 = 2*(r2-r1), v2 = 2*(c2-c1), v3 = r2*r2 - r1*r1 + c2*c2 - c1*c1;
- double v4 = 2*(r3-r1),
- v5 = 2*(c3-c1),
- v6 = r3*r3 - r1*r1 + c3*c3 - c1*c1,
-
- v7 = v2*v4 - v1*v5;
- if( v7 == 0 ){
- r=0;
- c=0;
- ro2 = -1;
- return;
- }
-
- cd = (v4*v3 - v1*v6)/v7;
- if( v1 != 0 )
- rd = (v3 - c*v2)/v1;
- else
- rd = (v6 - c*v5)/v4;
-
- ro2 = (float) ( (rd-r1)*(rd-r1) + (cd-c1)*(cd-c1) );
- r = (float) rd;
- c = (float) cd;
-
- return;
-}
+++ /dev/null
-#ifndef _structures_h
-#define _structures_h
-
-
-
-
-// for FILE
-
-#include <stdlib.h>
-#include <vector>
-#include <set>
-
-
-
-/*
- for use in s_hull.C
-
-S-hull, Copyright (c) 2010
-Dr David SInclair
-Cambridge, UK
-
-email david@s-hull.org
-
-The software includes the S-hull programs.
-S-hull is copyrighted as above.
-S-hull is free software and may be obtained from www.s-hull.org.
-It may be freely copied, modified,
-and redistributed under the following conditions:
-
-S-hull is free software and may be obtained from www.s-hull.org.
-It may be freely copied, modified,
-and redistributed under the following conditions which might loosely be termed a contribtors beerware license:
-1. All copyright notices must remain intact in all files.
-2. A copy of this text file must be distributed along with any copies
- of S-hull that you redistribute; this includes copies that you have
- modified, or copies of programs or other software products that
- include S-hull where distributed as source.
-
-3. If you modify S-hull, you must include a notice giving the
- name of the person performing the modification, the date of
- modification, and the reason for such modification.
-
-4. If you are distributing a binary or compiled version of s-hull it
- is not necessary to include any acknowledgement or reference
- to s-hull.
-5. There is no warranty or other guarantee of fitness for S-hull, it is
- provided solely "as is". Bug reports or fixes may be sent to
- bugs@s-hull.org; the authors may or may not act on them as
- they desire.
-6. By copying or compliing the code for S-hull you explicitly indemnify
-the copyright holder against any liability he may incur as a result of you
-copying the code.
-
-7. If you meet any of the contributors to the code you used from s-hull.org
- in a pub or a bar, and you think the source code they contributed to is worth it,
- you can buy them a beer.
-
- If your principles run against beer a bacon-double-cheeseburger would do just as nicely
- or you could email david@s-hull.org and arrange to make a donation of 10 of your local currancy units
- to support s-hull.org.
-
-
-*/
-
-struct Triad
-{
- int a,b, c;
- int ab, bc, ac; // adjacent edges index to neighbouring triangle.
- float ro, R,C;
- //std::set<int> idx;
- Triad() {};
-Triad(int x, int y) : a(x), b(y),c(0), ab(-1), bc(-1), ac(-1), ro(-1), R(0), C(0) {};
-Triad(int x, int y, int z) : a(x), b(y), c(z), ab(-1), bc(-1), ac(-1), ro(-1), R(0), C(0) {};
-Triad(const Triad &p) : a(p.a), b(p.b), c(p.c), ab(p.ab), bc(p.bc), ac(p.ac), ro(p.ro), R(p.R), C(p.C) {};
-
- Triad &operator=(const Triad &p)
- {
- a = p.a;
- b = p.b;
- c = p.c;
-
- ab = p.ab;
- bc = p.bc;
- ac = p.ac;
-
- ro = p.ro;
- R = p.R;
- C = p.C;
-
- return *this;
- };
- void prnt(){
- cerr << a << " " << b << " " << c << " " << ab << " " << ac << " " << bc << endl;
- };
-};
-
-
-
-/* point structure for s_hull only.
- has to keep track of triangle ids as hull evolves.
-
-
-*/
-
-
-struct Shx
-{
- int id, trid;
- float r,c , tr, tc;
- float ro;
- Shx() {};
- Shx(int a, int b) : r(a), c(b), ro(0), id(-1) {};
- Shx(int a, int b, float x) : r(a), c(b), ro(x), id(-1) {};
- Shx(const Shx &p) : id(p.id), trid(p.trid), r(p.r), c(p.c), tr(p.tr), tc(p.tc), ro(p.ro) {};
-
- Shx &operator=(const Shx &p)
- {
- id = p.id;
- trid = p.trid;
- r = p.r;
- c = p.c;
- tr = p.tr;
- tc = p.tc;
- ro = p.ro;
- return *this;
- };
-
-};
-
-//inline bool operator==(const Shx &a, const Shx &b)
-//{
-// return a.r == b.r && a.c == b.c;
-//};
-
-// sort into descending order (for use in corner responce ranking).
-inline bool operator<(const Shx &a, const Shx &b)
-{
- if( a.ro == b.ro)
- return a.r < b.r;
- return a.ro < b.ro;
-};
-
-
-
-// from s_hull.C
-
-
-void s_hull_del_ray2( std::vector<Shx> &pts, std::vector<Triad> &triads);
-void circle_cent2(float r1,float c1, float r2,float c2, float r3,float c3,float &r,float &c, float &ro2);
-void circle_cent4(float r1,float c1, float r2,float c2, float r3,float c3,float &r,float &c, float &ro2);
-void write_Shx(std::vector<Shx> &pts, char * fname);
-void write_Triads(std::vector<Triad> &ts, char * fname);
-void T_flip2( std::vector<Shx> &pts, std::vector<Triad> &triads, int *slump, int numt, int start);
-void T_flip3( std::vector<Shx> &pts, std::vector<Triad> &triads, int *slump, int numt, int start,std::set<int> &ids );
-void T_flip4( std::vector<Shx> &pts, std::vector<Triad> &triads, int *slump, std::set<int> &ids);
-
-
-
-#endif
--- /dev/null
+#include <iostream>
+//#include <hash_set.h>
+//#include <hash_set>
+#include <set>
+#include <vector>
+#include <fstream>
+#include <stdlib.h>
+#include <math.h>
+#include <string>
+#include <algorithm>
+
+
+#include "s_hull_pro.h"
+
+using namespace std;
+
+
+/* copyright 2012 Dr David Sinclair
+ david@s-hull.org
+
+ program to compute Delaunay triangulation of a set of points.
+
+ this code may not be published or distributed without the concent of the copyright holder.
+
+ */
+
+
+
+
+void circle_cent2(float r1,float c1, float r2,float c2, float r3,float c3,
+ float &r,float &c, float &ro2)
+{
+ /*
+ * function to return the center of a circle and its radius
+ * degenerate case should never be passed to this routine!!!!!!!!!!!!!
+ * but will return r0 = -1 if it is.
+ */
+
+ float v1 = 2*(r2-r1), v2 = 2*(c2-c1), v3 = r2*r2 - r1*r1 + c2*c2 - c1*c1;
+ float v4 = 2*(r3-r1),
+ v5 = 2*(c3-c1),
+ v6 = r3*r3 - r1*r1 + c3*c3 - c1*c1,
+
+ v7 = v2*v4 - v1*v5;
+ if( v7 == 0 )
+ {
+ r=0;
+ c=0;
+ ro2 = -1;
+ return;
+ }
+
+ c = (v4*v3 - v1*v6)/v7;
+ if( v1 != 0 )
+ r = (v3 - c*v2)/v1;
+ else
+ r = (v6 - c*v5)/v4;
+
+ ro2 = ( (r-r1)*(r-r1) + (c-c1)*(c-c1) );
+
+ return;
+}
+
+
+/*
+ read an ascii file of (r,c) point pairs.
+
+ the first line of the points file should contain
+ "NUMP 2 points"
+
+ if it does not have the word points in it the first line is
+ interpretted as a point pair.
+
+ */
+
+int read_Shx(std::vector<Shx> &pts, char * fname)
+{
+ char s0[513];
+ int nump =0;
+ float p1,p2;
+
+ Shx pt;
+
+ std::string line;
+ std::string points_str("points");
+
+ std::ifstream myfile;
+ myfile.open(fname);
+
+ if (myfile.is_open())
+ {
+
+ getline (myfile,line);
+ //int numc = line.length();
+
+ // check string for the string "points"
+ int n = (int) line.find( points_str);
+ if( n > 0)
+ {
+ while ( myfile.good() )
+ {
+ getline (myfile,line);
+ if( line.length() <= 512)
+ {
+ copy( line.begin(), line.end(), s0);
+ s0[line.length()] = 0;
+ int v = sscanf( s0, "%g %g", &p1,&p2);
+ if( v>0 )
+ {
+ pt.id = nump;
+ nump++;
+ pt.r = p1;
+ pt.c = p2;
+ pts.push_back(pt);
+ }
+ }
+ }
+ }
+ else // assume all number pairs on a line are points
+ {
+ if( line.length() <= 512)
+ {
+ copy( line.begin(), line.end(), s0);
+ s0[line.length()] = 0;
+ int v = sscanf( s0, "%g %g", &p1,&p2);
+ if( v>0 )
+ {
+ pt.id = nump;
+ nump++;
+ pt.r = p1;
+ pt.c = p2;
+ pts.push_back(pt);
+ }
+ }
+
+ while ( myfile.good() )
+ {
+ getline (myfile,line);
+ if( line.length() <= 512)
+ {
+ copy( line.begin(), line.end(), s0);
+ s0[line.length()] = 0;
+ int v = sscanf( s0, "%g %g", &p1,&p2);
+ if( v>0 )
+ {
+ pt.id = nump;
+ nump++;
+ pt.r = p1;
+ pt.c = p2;
+ pts.push_back(pt);
+ }
+ }
+ }
+ }
+ myfile.close();
+ }
+
+ nump = (int) pts.size();
+
+ return(nump);
+};
+
+/*
+ write out a set of points to disk
+
+
+*/
+
+void write_Shx(std::vector<Shx> &pts, char * fname)
+{
+ std::ofstream out(fname, ios::out);
+
+ int nr = (int) pts.size();
+ out << nr << " 2 points" << endl;
+
+ for (int r = 0; r < nr; r++)
+ {
+ out << pts[r].r << ' ' << pts[r].c << endl;
+ }
+ out.close();
+
+ return;
+};
+
+
+
+/*
+ write out triangle ids to be compatible with matlab/octave array numbering.
+
+ */
+void write_Triads(std::vector<Triad> &ts, char * fname)
+{
+ std::ofstream out(fname, ios::out);
+
+ int nr = (int) ts.size();
+ out << nr << " 6 point-ids (1,2,3) adjacent triangle-ids ( limbs ab ac bc )" << endl;
+
+ for (int r = 0; r < nr; r++)
+ {
+ out << ts[r].a+1 << ' ' << ts[r].b+1 <<' ' << ts[r].c+1 <<' '
+ << ts[r].ab+1 <<' ' << ts[r].ac+1 <<' ' << ts[r].bc+1 << endl; //" " << ts[r].ro << endl;
+ }
+ out.close();
+
+ return;
+};
+
+
+
+
+
+/* version in which the ids of the triangles associated with the sides of the hull are tracked.
+
+
+ */
+
+int s_hull_pro( std::vector<Shx> &pts, std::vector<Triad> &triads)
+{
+
+ int nump = (int) pts.size();
+
+ if( nump < 3 )
+ {
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "less than 3 points, aborting " << endl;
+ return(-1);
+ }
+
+
+ float r = pts[0].r;
+ float c = pts[0].c;
+ for( int k=0; k<nump; k++)
+ {
+ float dr = pts[k].r-r;
+ float dc = pts[k].c-c;
+
+ pts[k].ro = dr*dr + dc*dc;
+
+ }
+
+ sort( pts.begin(), pts.end() );
+
+
+ float r1 = pts[0].r;
+ float c1 = pts[0].c;
+
+ float r2 = pts[1].r;
+ float c2 = pts[1].c;
+ int mid = -1;
+ float romin2 = 100000000.0, ro2, R=0,C=0; // added by A.Balakin 6 July 2012 -- uninitialised variable
+
+ int k=2;
+ while (k<nump)
+ {
+
+ circle_cent2(r1,c1,r2,c2, pts[k].r, pts[k].c, r,c,ro2);
+ if( ro2 < romin2 && ro2 > 0 )
+ {
+ mid = k;
+ romin2 = ro2;
+ R = r;
+ C = c;
+
+ }
+ else if( romin2 *4 < pts[k].ro )
+ k=nump;
+
+ k++;
+ }
+
+ if( mid < 0 )
+ {
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "linear structure, aborting " << endl;
+ return(-2);
+ }
+
+
+ Shx pt0 = pts[0];
+ Shx pt1 = pts[1];
+ Shx pt2 = pts[mid];
+
+ pts.erase(pts.begin() + mid); // necessary for round off reasons:((((((
+ pts.erase(pts.begin() );
+ pts.erase(pts.begin() );
+
+ for( int k=0; k<nump-3; k++)
+ {
+ float dr = pts[k].r-R;
+ float dc = pts[k].c-C;
+
+ pts[k].ro = dr*dr + dc*dc;
+
+ }
+
+ sort( pts.begin(), pts.end() );
+
+ pts.insert(pts.begin(), pt2);
+ pts.insert(pts.begin(), pt1);
+ pts.insert(pts.begin(), pt0);
+
+ // int slump [nump];
+// int * slump = new int [nump];
+ std::vector<int> slump;
+ slump.resize(nump);
+
+ for( int k=0; k<nump; k++)
+ {
+ if( pts[k].id < nump)
+ {
+ slump[ pts[k].id] = k;
+ }
+ else
+ {
+ int mx = pts[k].id+1;
+ while( (int) slump.size() <= mx)
+ {
+ slump.push_back(0);
+ }
+ slump[pts[k].id] = k;
+ }
+ }
+
+ std::vector<Shx> hull;
+
+
+ r = (pts[0].r + pts[1].r + pts[2].r )/(float) 3.0;
+ c = (pts[0].c + pts[1].c + pts[2].c )/(float) 3.0;
+
+ float dr0 = pts[0].r - r, dc0 = pts[0].c - c;
+ float tr01 = pts[1].r - pts[0].r, tc01 = pts[1].c - pts[0].c;
+
+ float df = -tr01* dc0 + tc01*dr0;
+ if( df < 0 ) // [ 0 1 2 ]
+ {
+ pt0.tr = pt1.r-pt0.r;
+ pt0.tc = pt1.c-pt0.c;
+ pt0.trid = 0;
+ hull.push_back( pt0 );
+
+ pt1.tr = pt2.r-pt1.r;
+ pt1.tc = pt2.c-pt1.c;
+ pt1.trid = 0;
+ hull.push_back( pt1 );
+
+ pt2.tr = pt0.r-pt2.r;
+ pt2.tc = pt0.c-pt2.c;
+ pt2.trid = 0;
+ hull.push_back( pt2 );
+
+
+ Triad tri(pt0.id,pt1.id,pt2.id);
+ tri.ro = romin2;
+ tri.R = R;
+ tri.C = C;
+
+ triads.push_back(tri);
+
+ }
+ else // [ 0 2 1 ] as anti-clockwise turning is the work of the devil....
+ {
+ pt0.tr = pt2.r-pt0.r;
+ pt0.tc = pt2.c-pt0.c;
+ pt0.trid = 0;
+ hull.push_back( pt0 );
+
+ pt2.tr = pt1.r-pt2.r;
+ pt2.tc = pt1.c-pt2.c;
+ pt2.trid = 0;
+ hull.push_back( pt2 );
+
+ pt1.tr = pt0.r-pt1.r;
+ pt1.tc = pt0.c-pt1.c;
+ pt1.trid = 0;
+ hull.push_back( pt1 );
+
+ Triad tri(pt0.id,pt2.id,pt1.id);
+ tri.ro = romin2;
+ tri.R = R;
+ tri.C = C;
+ triads.push_back(tri);
+ }
+
+ // add new points into hull (removing obscured ones from the chain)
+ // and creating triangles....
+ // that will need to be flipped.
+
+ float dr, dc, rx,cx;
+ Shx ptx;
+ int numt=0; // added by A.Balakin 6 July 2012 -- uninitialised variable
+
+ for( int k=3; k<nump; k++)
+ {
+ rx = pts[k].r;
+ cx = pts[k].c;
+ ptx.r = rx;
+ ptx.c = cx;
+ ptx.id = pts[k].id;
+
+ int numh = (int) hull.size()/*, numh_old = numh*/; // commented by A.Balakin 6 July 2012 -- unused variable
+ dr = rx- hull[0].r;
+ dc = cx- hull[0].c; // outwards pointing from hull[0] to pt.
+
+ std::vector<int> pidx, tridx;
+ int hidx; // new hull point location within hull.....
+
+
+ float df = -dc* hull[0].tr + dr*hull[0].tc; // visibility test vector.
+ if( df < 0 ) // starting with a visible hull facet !!!
+ {
+// int e1 = 1, e2 = numh; // commented by A.Balakin 6 July 2012 -- unused variable
+ hidx = 0;
+
+ // check to see if segment numh is also visible
+ df = -dc* hull[numh-1].tr + dr*hull[numh-1].tc;
+ //cerr << df << ' ' ;
+ if( df < 0 ) // visible.
+ {
+ pidx.push_back(hull[numh-1].id);
+ tridx.push_back(hull[numh-1].trid);
+
+
+ for( int h=0; h<numh-1; h++)
+ {
+ // if segment h is visible delete h
+ dr = rx- hull[h].r;
+ dc = cx- hull[h].c;
+ df = -dc* hull[h].tr + dr*hull[h].tc;
+ pidx.push_back(hull[h].id);
+ tridx.push_back(hull[h].trid);
+ if( df < 0 )
+ {
+ hull.erase(hull.begin() + h);
+ h--;
+ numh--;
+ }
+ else // quit on invisibility
+ {
+ ptx.tr = hull[h].r - ptx.r;
+ ptx.tc = hull[h].c - ptx.c;
+
+ hull.insert( hull.begin() , ptx);
+ numh++;
+ break;
+ }
+ }
+ // look backwards through the hull structure.
+
+ for( int h=numh-2; h>0; h--)
+ {
+ // if segment h is visible delete h + 1
+ dr = rx- hull[h].r;
+ dc = cx- hull[h].c;
+ df = -dc* hull[h].tr + dr*hull[h].tc;
+
+ if( df < 0 ) // h is visible
+ {
+ pidx.insert(pidx.begin(), hull[h].id);
+ tridx.insert(tridx.begin(), hull[h].trid);
+ hull.erase(hull.begin() + h+1); // erase end of chain
+
+ }
+ else
+ {
+
+ h = (int) hull.size()-1;
+ hull[h].tr = -hull[h].r + ptx.r; // points at start of chain.
+ hull[h].tc = -hull[h].c + ptx.c;
+ break;
+ }
+ }
+
+ df = 9;
+
+ }
+ else
+ {
+ // cerr << df << ' ' << endl;
+ hidx = 1; // keep pt hull[0]
+ tridx.push_back(hull[0].trid);
+ pidx.push_back(hull[0].id);
+
+ for( int h=1; h<numh; h++)
+ {
+ // if segment h is visible delete h
+ dr = rx- hull[h].r;
+ dc = cx- hull[h].c;
+ df = -dc* hull[h].tr + dr*hull[h].tc;
+ pidx.push_back(hull[h].id);
+ tridx.push_back(hull[h].trid);
+ if( df < 0 ) // visible
+ {
+ hull.erase(hull.begin() + h);
+ h--;
+ numh--;
+ }
+ else // quit on invisibility
+ {
+ ptx.tr = hull[h].r - ptx.r;
+ ptx.tc = hull[h].c - ptx.c;
+
+ hull[h-1].tr = ptx.r - hull[h-1].r;
+ hull[h-1].tc = ptx.c - hull[h-1].c;
+
+ hull.insert( hull.begin()+h, ptx);
+ break;
+ }
+ }
+ }
+
+ df = 8;
+
+ }
+ else
+ {
+ int e1 = -1, e2 = numh;
+ for( int h=1; h<numh; h++)
+ {
+ dr = rx- hull[h].r;
+ dc = cx- hull[h].c;
+ df = -dc* hull[h].tr + dr*hull[h].tc;
+ if( df < 0 )
+ {
+ if( e1 < 0 ) e1 = h; // fist visible
+ }
+ else
+ {
+ if( e1 > 0 ) // first invisible segment.
+ {
+ e2 = h;
+ break;
+ }
+ }
+
+ }
+
+
+ // triangle pidx starts at e1 and ends at e2 (inclusive).
+ if( e2 < numh )
+ {
+ for( int e=e1; e<=e2; e++)
+ {
+ pidx.push_back(hull[e].id);
+ tridx.push_back(hull[e].trid);
+ }
+ }
+ else
+ {
+ for( int e=e1; e<e2; e++)
+ {
+ pidx.push_back(hull[e].id);
+ tridx.push_back(hull[e].trid); // there are only n-1 triangles from n hull pts.
+ }
+ pidx.push_back(hull[0].id);
+ }
+
+
+ // erase elements e1+1 : e2-1 inclusive.
+
+ if( e1 < e2-1)
+ {
+ hull.erase(hull.begin() + e1+1, hull.begin()+ e2);
+ }
+
+ // insert ptx at location e1+1.
+ if( e2 == numh)
+ {
+ ptx.tr = hull[0].r - ptx.r;
+ ptx.tc = hull[0].c - ptx.c;
+ }
+ else
+ {
+ ptx.tr = hull[e1+1].r - ptx.r;
+ ptx.tc = hull[e1+1].c - ptx.c;
+ }
+
+ hull[e1].tr = ptx.r - hull[e1].r;
+ hull[e1].tc = ptx.c - hull[e1].c;
+
+ hull.insert( hull.begin()+e1+1, ptx);
+ hidx = e1+1;
+
+ }
+
+
+ int a = ptx.id, T0;
+ Triad trx( a, 0,0);
+ r1 = pts[slump[a]].r;
+ c1 = pts[slump[a]].c;
+
+ int npx = (int) pidx.size()-1;
+ numt = (int) triads.size();
+ T0 = numt;
+
+ if( npx == 1)
+ {
+ trx.b = pidx[0];
+ trx.c = pidx[1];
+
+ trx.bc = tridx[0];
+ trx.ab = -1;
+ trx.ac = -1;
+
+ // index back into the triads.
+ Triad &txx = triads[tridx[0]];
+ if( ( trx.b == txx.a && trx.c == txx.b) |( trx.b == txx.b && trx.c == txx.a))
+ {
+ txx.ab = numt;
+ }
+ else if( ( trx.b == txx.a && trx.c == txx.c) |( trx.b == txx.c && trx.c == txx.a))
+ {
+ txx.ac = numt;
+ }
+ else if( ( trx.b == txx.b && trx.c == txx.c) |( trx.b == txx.c && trx.c == txx.b))
+ {
+ txx.bc = numt;
+ }
+
+
+ hull[hidx].trid = numt;
+ if( hidx > 0 )
+ hull[hidx-1].trid = numt;
+ else
+ {
+ numh = (int) hull.size();
+ hull[numh-1].trid = numt;
+ }
+ triads.push_back( trx );
+ numt++;
+ }
+
+ else
+ {
+ trx.ab = -1;
+ for(int p=0; p<npx; p++)
+ {
+ trx.b = pidx[p];
+ trx.c = pidx[p+1];
+
+
+ trx.bc = tridx[p];
+ if( p > 0 )
+ trx.ab = numt-1;
+ trx.ac = numt+1;
+
+ // index back into the triads.
+ Triad &txx = triads[tridx[p]];
+ if( ( trx.b == txx.a && trx.c == txx.b) |( trx.b == txx.b && trx.c == txx.a))
+ {
+ txx.ab = numt;
+ }
+ else if( ( trx.b == txx.a && trx.c == txx.c) |( trx.b == txx.c && trx.c == txx.a))
+ {
+ txx.ac = numt;
+ }
+ else if( ( trx.b == txx.b && trx.c == txx.c) |( trx.b == txx.c && trx.c == txx.b))
+ {
+ txx.bc = numt;
+ }
+
+ triads.push_back( trx );
+ numt++;
+ }
+ triads[numt-1].ac=-1;
+
+ hull[hidx].trid = numt-1;
+ if( hidx > 0 )
+ hull[hidx-1].trid = T0;
+ else
+ {
+ numh = (int) hull.size();
+ hull[numh-1].trid = T0;
+ }
+
+
+ }
+
+ }
+
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "of triangles " << triads.size() << " to be flipped. "<< endl;
+
+ // write_Triads(triads, "tris0.mat");
+
+ std::set<int> ids, ids2;
+
+ int tf = T_flip_pro( pts, triads, slump, numt, 0, ids);
+ if( tf < 0 )
+ {
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "cannot triangualte this set " << endl;
+ return(-3);
+ }
+
+ // write_Triads(triads, "tris1.mat");
+
+ int nits = (int) ids.size(), nit=1;
+ while( nits > 0 && nit < 50)
+ {
+
+ tf = T_flip_pro_idx( pts, triads, slump, ids);
+ nits = (int) ids.size();
+ nit ++;
+ if( tf < 0 )
+ {
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "cannot triangualte this set " << endl;
+ return(-4);
+ }
+ }
+ return(1);
+}
+
+
+void circle_cent4(float r1,float c1, float r2,float c2, float r3,float c3,
+ float &r,float &c, float &ro2)
+{
+ /*
+ * function to return the center of a circle and its radius
+ * degenerate case should never be passed to this routine!!!!!!!!!!!!!
+ * but will return r0 = -1 if it is.
+ */
+
+ double rd, cd;
+ double v1 = 2*(r2-r1), v2 = 2*(c2-c1), v3 = r2*r2 - r1*r1 + c2*c2 - c1*c1;
+ double v4 = 2*(r3-r1),
+ v5 = 2*(c3-c1),
+ v6 = r3*r3 - r1*r1 + c3*c3 - c1*c1,
+
+ v7 = v2*v4 - v1*v5;
+ if( v7 == 0 )
+ {
+ r=0;
+ c=0;
+ ro2 = -1;
+ return;
+ }
+
+ cd = (v4*v3 - v1*v6)/v7;
+ if( v1 != 0 )
+ rd = (v3 - c*v2)/v1;
+ else
+ rd = (v6 - c*v5)/v4;
+
+ ro2 = (float) ( (rd-r1)*(rd-r1) + (cd-c1)*(cd-c1) );
+ r = (float) rd;
+ c = (float) cd;
+
+ return;
+}
+
+
+/* test a set of points for duplicates.
+
+ erase duplicate points, do not change point ids.
+
+*/
+
+int de_duplicate( std::vector<Shx> &pts, std::vector<int> &outx )
+{
+
+ int nump = (int) pts.size();
+ std::vector<Dupex> dpx;
+ Dupex d;
+ for( int k=0; k<nump; k++)
+ {
+ d.r = pts[k].r;
+ d.c = pts[k].c;
+ d.id = k;
+ dpx.push_back(d);
+ }
+
+ sort(dpx.begin(), dpx.end());
+
+ for( int k=0; k<nump-1; k++)
+ {
+ if( dpx[k].r == dpx[k+1].r && dpx[k].c == dpx[k+1].c )
+ {
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "duplicate-point ids " << dpx[k].id << " " << dpx[k+1].id << " at (" << pts[dpx[k+1].id].r << "," << pts[dpx[k+1].id].c << ")" << endl;
+ outx.push_back( dpx[k+1].id);
+ }
+ }
+
+ if( outx.size() == 0 )
+ return(0);
+
+ sort(outx.begin(), outx.end());
+
+ int nx = (int) outx.size();
+ for( int k=nx-1; k>=0; k--)
+ {
+ pts.erase(pts.begin()+outx[k]);
+ }
+
+ return(nx);
+}
+
+
+
+
+/*
+ flip pairs of triangles that are not valid delaunay triangles
+ the Cline-Renka test is used rather than the less stable circum
+ circle center computation test of s-hull.
+
+ or the more expensive determinant test.
+
+ */
+
+
+int T_flip_pro( std::vector<Shx> &pts, std::vector<Triad> &triads, std::vector<int> &slump, int numt, int start, std::set<int> &ids)
+{
+
+ float r3,c3;
+ int pa,pb,pc, pd, D, L1, L2, L3, L4, T2;
+
+ Triad tx, tx2;
+
+
+ for( int t=start; t<numt; t++)
+ {
+
+ Triad &tri = triads[t];
+ // test all 3 neighbours of tri
+
+ int flipped = 0;
+
+ if( tri.bc >= 0 )
+ {
+
+ pa = slump[tri.a];
+ pb = slump[tri.b];
+ pc = slump[tri.c];
+
+ T2 = tri.bc;
+ Triad &t2 = triads[T2];
+ // find relative orientation (shared limb).
+ if( t2.ab == t )
+ {
+ D = t2.c;
+ pd = slump[t2.c];
+
+ if( tri.b == t2.a)
+ {
+ L3 = t2.ac;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ac;
+ }
+ }
+ else if( t2.ac == t )
+ {
+ D = t2.b;
+ pd = slump[t2.b];
+
+ if( tri.b == t2.a)
+ {
+ L3 = t2.ab;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ab;
+ }
+ }
+ else if( t2.bc == t )
+ {
+ D = t2.a;
+ pd = slump[t2.a];
+
+ if( tri.b == t2.b)
+ {
+ L3 = t2.ab;
+ L4 = t2.ac;
+ }
+ else
+ {
+ L3 = t2.ac;
+ L4 = t2.ab;
+ }
+ }
+ else
+ {
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "triangle flipping error. " << t << endl;
+ return(-5);
+ }
+
+ r3 = pts[pd].r;
+ c3 = pts[pd].c;
+
+ int XX = Cline_Renka_test( pts[pa].r, pts[pa].c, pts[pb].r, pts[pb].c,
+ pts[pc].r, pts[pc].c, r3, c3 );
+
+ if( XX < 0 )
+ {
+
+ L1 = tri.ab;
+ L2 = tri.ac;
+ if( L1 != L3 && L2 != L4 ) // need this check for stability.
+ {
+
+ tx.a = tri.a;
+ tx.b = tri.b;
+ tx.c = D;
+
+ tx.ab = L1;
+ tx.ac = T2;
+ tx.bc = L3;
+
+
+ // triangle 2;
+ tx2.a = tri.a;
+ tx2.b = tri.c;
+ tx2.c = D;
+
+ tx2.ab = L2;
+ tx2.ac = t;
+ tx2.bc = L4;
+
+
+ ids.insert(t);
+ ids.insert(T2);
+
+ t2 = tx2;
+ tri = tx;
+ flipped = 1;
+
+ // change knock on triangle labels.
+ if( L3 >= 0 )
+ {
+ Triad &t3 = triads[L3];
+ if( t3.ab == T2 ) t3.ab = t;
+ else if( t3.bc == T2 ) t3.bc = t;
+ else if( t3.ac == T2 ) t3.ac = t;
+ }
+
+ if(L2 >= 0 )
+ {
+ Triad &t4 = triads[L2];
+ if( t4.ab == t ) t4.ab = T2;
+ else if( t4.bc == t ) t4.bc = T2;
+ else if( t4.ac == t ) t4.ac = T2;
+ }
+ }
+ }
+ }
+
+
+ if( flipped == 0 && tri.ab >= 0 )
+ {
+
+ pc = slump[tri.c];
+ pb = slump[tri.b];
+ pa = slump[tri.a];
+
+ T2 = tri.ab;
+ Triad &t2 = triads[T2];
+ // find relative orientation (shared limb).
+ if( t2.ab == t )
+ {
+ D = t2.c;
+ pd = slump[t2.c];
+
+ if( tri.a == t2.a)
+ {
+ L3 = t2.ac;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ac;
+ }
+ }
+ else if( t2.ac == t )
+ {
+ D = t2.b;
+ pd = slump[t2.b];
+
+ if( tri.a == t2.a)
+ {
+ L3 = t2.ab;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ab;
+ }
+ }
+ else if( t2.bc == t )
+ {
+ D = t2.a;
+ pd = slump[t2.a];
+
+ if( tri.a == t2.b)
+ {
+ L3 = t2.ab;
+ L4 = t2.ac;
+ }
+ else
+ {
+ L3 = t2.ac;
+ L4 = t2.ab;
+ }
+ }
+ else
+ {
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "triangle flipping error. " << t << endl;
+ return(-5);
+ }
+
+ r3 = pts[pd].r;
+ c3 = pts[pd].c;
+
+ int XX = Cline_Renka_test( pts[pc].r, pts[pc].c, pts[pb].r, pts[pb].c,
+ pts[pa].r, pts[pa].c,r3, c3);
+
+ if( XX < 0)
+ {
+
+
+ L1 = tri.ac;
+ L2 = tri.bc;
+ if( L1 != L3 && L2 != L4 ) // need this check for stability.
+ {
+
+ tx.a = tri.c;
+ tx.b = tri.a;
+ tx.c = D;
+
+ tx.ab = L1;
+ tx.ac = T2;
+ tx.bc = L3;
+
+
+ // triangle 2;
+ tx2.a = tri.c;
+ tx2.b = tri.b;
+ tx2.c = D;
+
+ tx2.ab = L2;
+ tx2.ac = t;
+ tx2.bc = L4;
+
+
+ ids.insert(t);
+ ids.insert(T2);
+
+ t2 = tx2;
+ tri = tx;
+ flipped = 1;
+
+ // change knock on triangle labels.
+ if( L3 >= 0 )
+ {
+ Triad &t3 = triads[L3];
+ if( t3.ab == T2 ) t3.ab = t;
+ else if( t3.bc == T2 ) t3.bc = t;
+ else if( t3.ac == T2 ) t3.ac = t;
+ }
+
+ if(L2 >= 0 )
+ {
+ Triad &t4 = triads[L2];
+ if( t4.ab == t ) t4.ab = T2;
+ else if( t4.bc == t ) t4.bc = T2;
+ else if( t4.ac == t ) t4.ac = T2;
+ }
+
+ }
+
+ }
+ }
+
+
+ if( flipped == 0 && tri.ac >= 0 )
+ {
+
+ pc = slump[tri.c];
+ pb = slump[tri.b];
+ pa = slump[tri.a];
+
+ T2 = tri.ac;
+ Triad &t2 = triads[T2];
+ // find relative orientation (shared limb).
+ if( t2.ab == t )
+ {
+ D = t2.c;
+ pd = slump[t2.c];
+
+ if( tri.a == t2.a)
+ {
+ L3 = t2.ac;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ac;
+ }
+ }
+ else if( t2.ac == t )
+ {
+ D = t2.b;
+ pd = slump[t2.b];
+
+ if( tri.a == t2.a)
+ {
+ L3 = t2.ab;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ab;
+ }
+ }
+ else if( t2.bc == t )
+ {
+ D = t2.a;
+ pd = slump[t2.a];
+
+ if( tri.a == t2.b)
+ {
+ L3 = t2.ab;
+ L4 = t2.ac;
+ }
+ else
+ {
+ L3 = t2.ac;
+ L4 = t2.ab;
+ }
+ }
+ else
+ {
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "triangle flipping error. " << t << endl;
+ return(-5);
+ }
+
+ r3 = pts[pd].r;
+ c3 = pts[pd].c;
+
+ int XX = Cline_Renka_test( pts[pb].r, pts[pb].c, pts[pa].r, pts[pa].c,
+ pts[pc].r, pts[pc].c,r3, c3);
+
+ if( XX < 0 )
+ {
+
+ L1 = tri.ab; // .ac shared limb
+ L2 = tri.bc;
+ if( L1 != L3 && L2 != L4 ) // need this check for stability.
+ {
+
+ tx.a = tri.b;
+ tx.b = tri.a;
+ tx.c = D;
+
+ tx.ab = L1;
+ tx.ac = T2;
+ tx.bc = L3;
+
+
+ // triangle 2;
+ tx2.a = tri.b;
+ tx2.b = tri.c;
+ tx2.c = D;
+
+ tx2.ab = L2;
+ tx2.ac = t;
+ tx2.bc = L4;
+
+ ids.insert(t);
+ ids.insert(T2);
+
+ t2 = tx2;
+ tri = tx;
+
+ // change knock on triangle labels.
+ if( L3 >= 0 )
+ {
+ Triad &t3 = triads[L3];
+ if( t3.ab == T2 ) t3.ab = t;
+ else if( t3.bc == T2 ) t3.bc = t;
+ else if( t3.ac == T2 ) t3.ac = t;
+ }
+
+ if(L2 >= 0 )
+ {
+ Triad &t4 = triads[L2];
+ if( t4.ab == t ) t4.ab = T2;
+ else if( t4.bc == t ) t4.bc = T2;
+ else if( t4.ac == t ) t4.ac = T2;
+ }
+
+ }
+ }
+ }
+
+
+ }
+
+
+ return(1);
+}
+
+/* minimum angle cnatraint for circum circle test.
+ due to Cline & Renka
+
+ A -- B
+
+ | / |
+
+ C -- D
+
+
+ */
+
+int Cline_Renka_test(float &Ax, float &Ay,
+ float &Bx, float &By,
+ float &Cx, float &Cy,
+ float &Dx, float &Dy)
+{
+
+ float v1x = Bx-Ax, v1y = By-Ay, v2x = Cx-Ax, v2y = Cy-Ay,
+ v3x = Bx-Dx, v3y = By-Dy, v4x = Cx-Dx, v4y = Cy-Dy;
+ float cosA = v1x*v2x + v1y*v2y;
+ float cosD = v3x*v4x + v3y*v4y;
+
+ if( cosA < 0 && cosD < 0 ) // two obtuse angles
+ return(-1);
+
+// float ADX = Ax-Dx, ADy = Ay-Dy; // commented by A.Balakin 6 July 2012 -- unused variable
+
+
+ if( cosA > 0 && cosD > 0 ) // two acute angles
+ return(1);
+
+
+ float sinA = fabs(v1x*v2y - v1y*v2x);
+ float sinD = fabs(v3x*v4y - v3y*v4x);
+
+ if( cosA*sinD + sinA*cosD < 0 )
+ return(-1);
+
+ return(1);
+
+}
+
+
+
+
+// same again but with set of triangle ids to be iterated over.
+
+
+int T_flip_pro_idx( std::vector<Shx> &pts, std::vector<Triad> &triads, std::vector<int> &slump, std::set<int> &ids)
+{
+
+ float r3,c3;
+ int pa,pb,pc, pd, D, L1, L2, L3, L4, T2;
+
+ Triad tx, tx2;
+ std::set<int> ids2;
+ ids2.clear();
+
+ std::set<int> :: const_iterator x=ids.begin();
+ while(x != ids.end() )
+ {
+ int t = *x;
+ x++;
+
+
+ Triad &tri = triads[t];
+ // test all 3 neighbours of tri
+ int flipped = 0;
+
+
+
+ if( tri.bc >= 0 )
+ {
+
+ pa = slump[tri.a];
+ pb = slump[tri.b];
+ pc = slump[tri.c];
+
+ T2 = tri.bc;
+ Triad &t2 = triads[T2];
+ // find relative orientation (shared limb).
+ if( t2.ab == t )
+ {
+ D = t2.c;
+ pd = slump[t2.c];
+
+ if( tri.b == t2.a)
+ {
+ L3 = t2.ac;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ac;
+ }
+ }
+ else if( t2.ac == t )
+ {
+ D = t2.b;
+ pd = slump[t2.b];
+
+ if( tri.b == t2.a)
+ {
+ L3 = t2.ab;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ab;
+ }
+ }
+ else if( t2.bc == t )
+ {
+ D = t2.a;
+ pd = slump[t2.a];
+
+ if( tri.b == t2.b)
+ {
+ L3 = t2.ab;
+ L4 = t2.ac;
+ }
+ else
+ {
+ L3 = t2.ac;
+ L4 = t2.ab;
+ }
+ }
+ else
+ {
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "triangle flipping error. " << t << " T2: " << T2<< endl;
+ return(-6);
+ }
+
+ r3 = pts[pd].r;
+ c3 = pts[pd].c;
+
+ int XX = Cline_Renka_test( pts[pa].r, pts[pa].c, pts[pb].r, pts[pb].c,
+ pts[pc].r, pts[pc].c,r3, c3);
+
+ if( XX < 0 )
+ {
+ L1 = tri.ab;
+ L2 = tri.ac;
+
+ if( L1 != L3 && L2 != L4 ) // need this check for stability.
+ {
+
+
+ tx.a = tri.a;
+ tx.b = tri.b;
+ tx.c = D;
+
+ tx.ab = L1;
+ tx.ac = T2;
+ tx.bc = L3;
+
+
+ // triangle 2;
+ tx2.a = tri.a;
+ tx2.b = tri.c;
+ tx2.c = D;
+
+ tx2.ab = L2;
+ tx2.ac = t;
+ tx2.bc = L4;
+
+ ids2.insert(t);
+ ids2.insert(T2);
+
+ t2 = tx2;
+ tri = tx;
+ flipped = 1;
+
+ // change knock on triangle labels.
+ if( L3 >= 0 )
+ {
+ Triad &t3 = triads[L3];
+ if( t3.ab == T2 ) t3.ab = t;
+ else if( t3.bc == T2 ) t3.bc = t;
+ else if( t3.ac == T2 ) t3.ac = t;
+ }
+
+ if(L2 >= 0 )
+ {
+ Triad &t4 = triads[L2];
+ if( t4.ab == t ) t4.ab = T2;
+ else if( t4.bc == t ) t4.bc = T2;
+ else if( t4.ac == t ) t4.ac = T2;
+ }
+
+ }
+ }
+ }
+
+
+ if( flipped == 0 && tri.ab >= 0 )
+ {
+
+ pc = slump[tri.c];
+ pb = slump[tri.b];
+ pa = slump[tri.a];
+
+ T2 = tri.ab;
+ Triad &t2 = triads[T2];
+ // find relative orientation (shared limb).
+ if( t2.ab == t )
+ {
+ D = t2.c;
+ pd = slump[t2.c];
+
+ if( tri.a == t2.a)
+ {
+ L3 = t2.ac;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ac;
+ }
+ }
+ else if( t2.ac == t )
+ {
+ D = t2.b;
+ pd = slump[t2.b];
+
+ if( tri.a == t2.a)
+ {
+ L3 = t2.ab;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ab;
+ }
+ }
+ else if( t2.bc == t )
+ {
+ D = t2.a;
+ pd = slump[t2.a];
+
+ if( tri.a == t2.b)
+ {
+ L3 = t2.ab;
+ L4 = t2.ac;
+ }
+ else
+ {
+ L3 = t2.ac;
+ L4 = t2.ab;
+ }
+ }
+ else
+ {
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "triangle flipping error. " << t << endl;
+ return(-6);
+ }
+
+ r3 = pts[pd].r;
+ c3 = pts[pd].c;
+
+ int XX = Cline_Renka_test( pts[pc].r, pts[pc].c, pts[pb].r, pts[pb].c,
+ pts[pa].r, pts[pa].c,r3, c3);
+
+ if( XX < 0 )
+ {
+ L1 = tri.ac;
+ L2 = tri.bc;
+ if( L1 != L3 && L2 != L4 ) // need this check for stability.
+ {
+
+ tx.a = tri.c;
+ tx.b = tri.a;
+ tx.c = D;
+
+ tx.ab = L1;
+ tx.ac = T2;
+ tx.bc = L3;
+
+
+ // triangle 2;
+ tx2.a = tri.c;
+ tx2.b = tri.b;
+ tx2.c = D;
+
+ tx2.ab = L2;
+ tx2.ac = t;
+ tx2.bc = L4;
+
+
+ ids2.insert(t);
+ ids2.insert(T2);
+
+ t2 = tx2;
+ tri = tx;
+ flipped = 1;
+
+ // change knock on triangle labels.
+ if( L3 >= 0 )
+ {
+ Triad &t3 = triads[L3];
+ if( t3.ab == T2 ) t3.ab = t;
+ else if( t3.bc == T2 ) t3.bc = t;
+ else if( t3.ac == T2 ) t3.ac = t;
+ }
+
+ if(L2 >= 0 )
+ {
+ Triad &t4 = triads[L2];
+ if( t4.ab == t ) t4.ab = T2;
+ else if( t4.bc == t ) t4.bc = T2;
+ else if( t4.ac == t ) t4.ac = T2;
+ }
+
+ }
+ }
+ }
+
+
+ if( flipped == 0 && tri.ac >= 0 )
+ {
+
+ pc = slump[tri.c];
+ pb = slump[tri.b];
+ pa = slump[tri.a];
+
+ T2 = tri.ac;
+ Triad &t2 = triads[T2];
+ // find relative orientation (shared limb).
+ if( t2.ab == t )
+ {
+ D = t2.c;
+ pd = slump[t2.c];
+
+ if( tri.a == t2.a)
+ {
+ L3 = t2.ac;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ac;
+ }
+ }
+ else if( t2.ac == t )
+ {
+ D = t2.b;
+ pd = slump[t2.b];
+
+ if( tri.a == t2.a)
+ {
+ L3 = t2.ab;
+ L4 = t2.bc;
+ }
+ else
+ {
+ L3 = t2.bc;
+ L4 = t2.ab;
+ }
+ }
+ else if( t2.bc == t )
+ {
+ D = t2.a;
+ pd = slump[t2.a];
+
+ if( tri.a == t2.b)
+ {
+ L3 = t2.ab;
+ L4 = t2.ac;
+ }
+ else
+ {
+ L3 = t2.ac;
+ L4 = t2.ab;
+ }
+ }
+ else
+ {
+// Commented by A.Balakin 2 July 2012 -- library shouldn't print anything
+// cerr << "triangle flipping error. " << t << endl;
+ return(-6);
+ }
+
+ r3 = pts[pd].r;
+ c3 = pts[pd].c;
+
+ int XX = Cline_Renka_test( pts[pb].r, pts[pb].c, pts[pc].r, pts[pc].c,
+ pts[pa].r, pts[pa].c,r3, c3);
+
+ if( XX < 0 )
+ {
+ L1 = tri.ab; // .ac shared limb
+ L2 = tri.bc;
+ if( L1 != L3 && L2 != L4 ) // need this check for stability.
+ {
+
+
+ tx.a = tri.b;
+ tx.b = tri.a;
+ tx.c = D;
+
+ tx.ab = L1;
+ tx.ac = T2;
+ tx.bc = L3;
+
+
+ // triangle 2;
+ tx2.a = tri.b;
+ tx2.b = tri.c;
+ tx2.c = D;
+
+
+
+ tx2.ab = L2;
+ tx2.ac = t;
+ tx2.bc = L4;
+
+
+ ids2.insert(t);
+ ids2.insert(T2);
+
+ t2 = tx2;
+ tri = tx;
+
+ // change knock on triangle labels.
+ if( L3 >= 0 )
+ {
+ Triad &t3 = triads[L3];
+ if( t3.ab == T2 ) t3.ab = t;
+ else if( t3.bc == T2 ) t3.bc = t;
+ else if( t3.ac == T2 ) t3.ac = t;
+ }
+
+ if(L2 >= 0 )
+ {
+ Triad &t4 = triads[L2];
+ if( t4.ab == t ) t4.ab = T2;
+ else if( t4.bc == t ) t4.bc = T2;
+ else if( t4.ac == t ) t4.ac = T2;
+ }
+
+
+ }
+ }
+ }
+
+
+ }
+
+ ids.clear();
+ ids.insert(ids2.begin(), ids2.end());
+
+ return(1);
+}
+
--- /dev/null
+#ifndef _structures_h
+#define _structures_h
+
+
+
+
+// for FILE
+
+#include <stdlib.h>
+#include <vector>
+#include <set>
+
+
+
+/*
+ for use in s_hull_pro.cpp
+
+S-hull-pro, Copyright (c) 2012
+Dr David SInclair
+Cambridge, UK
+
+email david@s-hull.org
+
+
+*/
+
+struct Triad
+{
+ int a,b, c;
+ int ab, bc, ac; // adjacent edges index to neighbouring triangle.
+ float ro, R,C;
+ //std::set<int> idx;
+ Triad() {a=b=c=ab=bc=ac=0; ro=R=C=0;}; // added by A.Balakin 6 July 2012 -- uninitialised variable
+ Triad(int x, int y) : a(x), b(y),c(0), ab(-1), bc(-1), ac(-1), ro(-1), R(0), C(0) {};
+ Triad(int x, int y, int z) : a(x), b(y), c(z), ab(-1), bc(-1), ac(-1), ro(-1), R(0), C(0) {};
+ Triad(const Triad &p) : a(p.a), b(p.b), c(p.c), ab(p.ab), bc(p.bc), ac(p.ac), ro(p.ro), R(p.R), C(p.C) {};
+
+ Triad &operator=(const Triad &p)
+ {
+ a = p.a;
+ b = p.b;
+ c = p.c;
+
+ ab = p.ab;
+ bc = p.bc;
+ ac = p.ac;
+
+ ro = p.ro;
+ R = p.R;
+ C = p.C;
+
+ return *this;
+ };
+};
+
+
+
+/* point structure for s_hull only.
+ has to keep track of triangle ids as hull evolves.
+*/
+
+
+struct Shx
+{
+ int id, trid;
+ float r,c, tr,tc ;
+ float ro;
+ Shx() {r=c=tr=tc=ro=0; id=trid=0;}; // added by A.Balakin 6 July 2012 -- uninitialised variable
+ Shx(float a, float b) : r(a), c(b), tr(0.0), tc(0.0), ro(0.0), id(-1)
+ { trid=0; }; // added by A.Balakin 6 July 2012 -- uninitialised variable
+ Shx(float a, float b, float x) : r(a), c(b), ro(x), tr(0), tc(0), id(-1)
+ { trid=0; }; // added by A.Balakin 6 July 2012 -- uninitialised variable
+ Shx(const Shx &p) : id(p.id), trid(p.trid), r(p.r), c(p.c), tr(p.tr), tc(p.tc), ro(p.ro) {};
+
+ Shx &operator=(const Shx &p)
+ {
+ id = p.id;
+ trid = p.trid;
+ r = p.r;
+ c = p.c;
+ tr = p.tr;
+ tc = p.tc;
+ ro = p.ro;
+ return *this;
+ };
+
+};
+
+
+// sort into descending order (for use in corner responce ranking).
+inline bool operator<(const Shx &a, const Shx &b)
+{
+ if( a.ro == b.ro)
+ return a.r < b.r;
+ return a.ro < b.ro;
+};
+
+
+struct Dupex
+{
+ int id;
+ float r,c;
+
+ Dupex() {};
+ Dupex(float a, float b) : id(-1), r(a), c(b) {};
+ Dupex(float a, float b, int x) : r(a), c(b), id(x) {};
+ Dupex(const Dupex &p) : id(p.id), r(p.r), c(p.c) {};
+
+ Dupex &operator=(const Dupex &p)
+ {
+ id = p.id;
+ r = p.r;
+ c = p.c;
+ return *this;
+ };
+};
+
+
+
+// sort into descending order (for use in corner responce ranking).
+inline bool operator<(const Dupex &a, const Dupex &b)
+{
+ if( a.r == b.r)
+ return a.c < b.c;
+ return a.r < b.r;
+};
+
+
+
+
+
+// from s_hull.C
+
+
+int s_hull_pro( std::vector<Shx> &pts, std::vector<Triad> &triads);
+void circle_cent2(float r1,float c1, float r2,float c2, float r3,float c3,float &r,float &c, float &ro2);
+void circle_cent4(float r1,float c1, float r2,float c2, float r3,float c3,float &r,float &c, float &ro2);
+void write_Shx(std::vector<Shx> &pts, char * fname);
+void write_Triads(std::vector<Triad> &ts, char * fname);
+int Cline_Renka_test(float &Ax, float &Ay, float &Bx, float &By, float &Cx, float &Cy, float &Dx, float &Dy);
+int T_flip_pro( std::vector<Shx> &pts, std::vector<Triad> &triads, std::vector<int> &slump, int numt, int start, std::set<int> &ids);
+int T_flip_pro_idx( std::vector<Shx> &pts, std::vector<Triad> &triads, std::vector<int> &slump, std::set<int> &ids);
+
+int read_Shx(std::vector<Shx> &pts, char * fname);
+
+
+int de_duplicate( std::vector<Shx> &pts, std::vector<int> &outx );
+
+#endif
void mgl_fsurf(HMGL gr, const char *eqZ, const char *sch, const char *opt)\r
{ // TODO: Add strong function variation analisys ???\r
if(eqZ==0 || eqZ[0]==0) return; // nothing to plot\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long n = (mgl_isnan(r) || r<=0) ? 100:long(r+0.5);\r
mglData z(n,n);\r
mglFormula *eq = new mglFormula(eqZ);\r
register int i,j;\r
- float dx = (gr->Max.x - gr->Min.x)/(n-1.), dy = (gr->Max.y - gr->Min.y)/(n-1.);\r
+ mreal dx = (gr->Max.x - gr->Min.x)/(n-1.), dy = (gr->Max.y - gr->Min.y)/(n-1.);\r
for(j=0;j<n;j++) for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete eq; return; }\r
void mgl_fsurf_xyz(HMGL gr, const char *eqX, const char *eqY, const char *eqZ, const char *sch, const char *opt)\r
{ // TODO: Add strong function variation analisys ???\r
if(eqZ==0 || eqZ[0]==0) return; // nothing to plot\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long n = (mgl_isnan(r) || r<=0) ? 100:long(r+0.5);\r
mglData x(n,n), y(n,n), z(n,n);\r
if(n<=0) n=100;\r
ey = new mglFormula(eqY ? eqY : "v");\r
ez = new mglFormula(eqZ);\r
register int i,j;\r
- register float u,v;\r
+ register mreal u,v;\r
for(j=0;j<n;j++) for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete ex; delete ey; delete ez; return; }\r
void mgl_mesh_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,k,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Mesh"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Mesh"); return; }\r
- if(y->GetNx()!=m && (x->GetNy()!=m || y->GetNx()!=n || y->GetNy()!=m))\r
- { gr->SetWarn(mglWarnDim); return; };\r
+ if(mgl_check_dim2(gr,x,y,z,0,"Mesh")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Mesh",cgid++);\r
gr->SetPenPal("-");\r
gr->Reserve(n*m*z->GetNz());\r
\r
mglPoint p;\r
- float c;\r
+ mreal c;\r
for(k=0;k<z->GetNz();k++)\r
{\r
for(j=0;j<m;j++) for(i=0;i<n;i++)\r
//-----------------------------------------------------------------------------\r
void mgl_mesh(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Mesh"); return; }\r
gr->SaveState(opt);\r
mglData x(z->GetNx()), y(z->GetNy());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_mesh_xy(gr,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_mesh_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
void mgl_fall_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,k,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=z->GetNx()) { gr->SetWarn(mglWarnDim,"Fall"); return; }\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Fall"); return; }\r
- if(y->GetNx()!=z->GetNy() && (x->GetNy()!=z->GetNy() || y->GetNx()!=z->GetNx() || y->GetNy()!=z->GetNy()))\r
- { gr->SetWarn(mglWarnDim); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,0,"Fall")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Fall",cgid++);\r
gr->SetPenPal("-");\r
gr->Reserve(n*m*z->GetNz());\r
\r
mglPoint p;\r
- float c;\r
+ mreal c;\r
for(k=0;k<z->GetNz();k++)\r
{\r
for(j=0;j<m;j++) for(i=0;i<n;i++)\r
//-----------------------------------------------------------------------------\r
void mgl_fall(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Fall"); return; }\r
gr->SaveState(opt);\r
mglData x(z->GetNx()), y(z->GetNy());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_fall_xy(gr,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_fall_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
void mgl_grid_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,k,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=z->GetNx()) { gr->SetWarn(mglWarnDim,"Grid"); return; }\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Grid"); return; }\r
- if(y->GetNx()!=z->GetNy() && (x->GetNy()!=z->GetNy() || y->GetNx()!=z->GetNx() || y->GetNy()!=z->GetNy()))\r
- { gr->SetWarn(mglWarnDim); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,0,"Grid")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Grid",cgid++);\r
- float zVal = gr->Min.z;\r
+ mreal zVal = gr->Min.z;\r
gr->SetPenPal(sch?sch:"k-");\r
long *pos = new long[n*m];\r
gr->Reserve(n*m*z->GetNz());\r
mglPoint p;\r
for(k=0;k<z->GetNz();k++)\r
{\r
- if(z->GetNz()>1) zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*float(k)/(z->GetNz()-1);\r
+ if(z->GetNz()>1) zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*mreal(k)/(z->GetNz()-1);\r
for(j=0;j<m;j++) for(i=0;i<n;i++)\r
{\r
if(gr->Stop) { delete []pos; return; }\r
//-----------------------------------------------------------------------------\r
void mgl_grid(HMGL gr, HCDT z,const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Grid"); return; }\r
gr->SaveState(opt);\r
mglData x(z->GetNx()), y(z->GetNy());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_grid_xy(gr,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_grid_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
void mgl_surf_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,k,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=n) { gr->SetWarn(mglWarnDim,"Surf"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Surf"); return; }\r
- if(y->GetNx()!=m && (x->GetNy()!=m || y->GetNx()!=n || y->GetNy()!=m))\r
- { gr->SetWarn(mglWarnDim); return; };\r
+ if(mgl_check_dim2(gr,x,y,z,0,"Surf")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Surf",cgid++);\r
long ss = gr->AddTexture(sch);\r
gr->Reserve(n*m*z->GetNz()*(wire?2:1));\r
\r
mglPoint p,q,s,xx,yy;\r
- float c;\r
+ mreal c;\r
for(k=0;k<z->GetNz();k++)\r
{\r
for(j=0;j<m;j++) for(i=0;i<n;i++)\r
//-----------------------------------------------------------------------------\r
void mgl_surf(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Surf"); return; }\r
gr->SaveState(opt);\r
mglData x(z->GetNx()), y(z->GetNy());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_surf_xy(gr,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_surf_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
void mgl_belt_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,k,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=z->GetNx()) { gr->SetWarn(mglWarnDim,"Belt"); return; }\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Belt"); return; }\r
- if(y->GetNx()!=z->GetNy() && (x->GetNy()!=z->GetNy() || y->GetNx()!=z->GetNx() || y->GetNy()!=z->GetNy()))\r
- { gr->SetWarn(mglWarnDim); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,0,"Belt")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Belt",cgid++);\r
-\r
long ss = gr->AddTexture(sch);\r
long *pos = new long[2*(n>m?n:m)];\r
gr->Reserve(2*n*m*z->GetNz());\r
bool how = !(sch && strchr(sch,'x'));\r
\r
mglPoint p1,p2,q,s,xx,yy;\r
- float c;\r
+ mreal c;\r
for(k=0;k<z->GetNz();k++)\r
{\r
if(how) for(i=0;i<n-1;i++)\r
//-----------------------------------------------------------------------------\r
void mgl_belt(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Belt"); return; }\r
gr->SaveState(opt);\r
mglData x(z->GetNx()), y(z->GetNy());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_belt_xy(gr,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_belt_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
void mgl_dens_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,k,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=z->GetNx()) { gr->SetWarn(mglWarnDim,"Dens"); return; }\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Dens"); return; }\r
- if(y->GetNx()!=z->GetNy() && (x->GetNy()!=z->GetNy() || y->GetNx()!=z->GetNx() || y->GetNy()!=z->GetNy()))\r
- { gr->SetWarn(mglWarnDim); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,0,"Dens")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Dens",cgid++);\r
- float zVal = gr->Min.z;\r
+ mreal zVal = gr->Min.z;\r
\r
long ss = gr->AddTexture(sch);\r
long *pos = new long[n*m];\r
gr->Reserve(n*m*z->GetNz());\r
\r
mglPoint p,s=mglPoint(0,0,1);\r
- float zz, c;\r
+ mreal zz, c;\r
for(k=0;k<z->GetNz();k++)\r
{\r
if(z->GetNz()>1)\r
- zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*float(k)/(z->GetNz()-1);\r
+ zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*mreal(k)/(z->GetNz()-1);\r
for(j=0;j<m;j++) for(i=0;i<n;i++) // ñîçäàåì ìàññèâ òî÷åê\r
{\r
if(gr->Stop) { delete []pos; return; }\r
x.Fill(gr->Min.x, gr->Max.x);\r
y.Fill(gr->Min.y, gr->Max.y);\r
mgl_dens_xy(gr,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_dens_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
void mgl_surfc_xy(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT c, const char *sch, const char *opt)\r
{\r
register long i,j,k,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=z->GetNx()) { gr->SetWarn(mglWarnDim,"SurfC"); return; }\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"SurfC"); return; }\r
- if(z->GetNx()*z->GetNy()*z->GetNz()!=c->GetNx()*c->GetNy()*c->GetNz())\r
- { gr->SetWarn(mglWarnDim); return; }\r
- if(y->GetNx()!=z->GetNy() && (x->GetNy()!=z->GetNy() || y->GetNx()!=z->GetNx() || y->GetNy()!=z->GetNy()))\r
- { gr->SetWarn(mglWarnDim); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,c,"SurfC")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("SurfC",cgid++);\r
-\r
long ss = gr->AddTexture(sch);\r
long *pos = new long[n*m];\r
gr->Reserve(n*m*z->GetNz());\r
- float col;\r
+ mreal col;\r
\r
mglPoint p,q,s,xx,yy;\r
for(k=0;k<z->GetNz();k++)\r
//-----------------------------------------------------------------------------\r
void mgl_surfc(HMGL gr, HCDT z, HCDT c, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"SurfC"); return; }\r
gr->SaveState(opt);\r
mglData x(z->GetNx()), y(z->GetNy());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_surfc_xy(gr,&x,&y,z,c,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_surfc_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
{\r
register long i,j;\r
long k,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()!=z->GetNx()) { gr->SetWarn(mglWarnDim,"SurfA"); return; }\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"SurfA"); return; }\r
- if(z->GetNx()*z->GetNy()*z->GetNz()!=c->GetNx()*c->GetNy()*c->GetNz())\r
- { gr->SetWarn(mglWarnDim); return; }\r
- if(y->GetNx()!=z->GetNy() && (x->GetNy()!=z->GetNy() || y->GetNx()!=z->GetNx() || y->GetNy()!=z->GetNy()))\r
- { gr->SetWarn(mglWarnDim); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,c,"SurfA")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("SurfA",cgid++);\r
-\r
long ss = gr->AddTexture(sch);\r
long *pos = new long[n*m];\r
gr->Reserve(n*m*z->GetNz());\r
{\r
if(gr->Stop) { delete []pos; return; }\r
xx = GetX(x,i,j,k); yy = GetY(y,i,j,k);\r
- p = mglPoint(xx.x, yy.x, z->v(i,j,k));\r
+ mreal vv = z->v(i,j,k); p = mglPoint(xx.x, yy.x, vv);\r
q = mglPoint(xx.y, yy.y, z->dvx(i,j,k));\r
s = mglPoint(xx.z, yy.z, z->dvy(i,j,k));\r
- pos[i+n*j] = gr->AddPnt(p,gr->GetC(ss,z->v(i,j,k)),q^s,gr->GetA(c->v(i,j,k)));\r
+ pos[i+n*j] = gr->AddPnt(p,gr->GetC(ss,vv),q^s,gr->GetA(c->v(i,j,k)));\r
}\r
mgl_surf_plot(gr,pos,n,m);\r
if(sch && strchr(sch,'#'))\r
//-----------------------------------------------------------------------------\r
void mgl_surfa(HMGL gr, HCDT z, HCDT c, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"SurfC"); return; }\r
+ gr->SaveState(opt);\r
mglData x(z->GetNx()), y(z->GetNy());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
- gr->SaveState(opt);\r
mgl_surfa_xy(gr,&x,&y,z,c,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_surfa_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
void mgl_boxs_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,k,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()<z->GetNx()) { gr->SetWarn(mglWarnDim,"Boxs"); return; }\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Boxs"); return; }\r
- long ly = x->GetNy()>=z->GetNy() ? y->GetNy() : y->GetNx(), lx = x->GetNx();\r
+ if(mgl_check_dim2(gr,x,y,z,0,"Boxs",true)) return;\r
\r
- if(y->GetNx()<z->GetNy() && (x->GetNy()<z->GetNy() || y->GetNx()<z->GetNx() || y->GetNy()<z->GetNy()))\r
- { gr->SetWarn(mglWarnDim); return; }\r
+ long ly = x->GetNy()>=m ? y->GetNy() : y->GetNx(), lx = x->GetNx();\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Boxs",cgid++);\r
\r
gr->Reserve(8*n*m*z->GetNz());\r
\r
mglPoint p1,p2,p3,p4,q,s,t(wire||full?NAN:0,0,1),xx,yy;\r
- float zz,z1,z2,x1,y1,c,z0=gr->GetOrgZ('x');\r
+ mreal zz,z1,z2,x1,y1,c,z0=gr->GetOrgZ('x');\r
long k1,k2,k3,k4,k5,k6,k7,k8;\r
for(k=0;k<z->GetNz();k++)\r
{\r
//-----------------------------------------------------------------------------\r
void mgl_boxs(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Boxs"); return; }\r
gr->SaveState(opt);\r
mglData x(z->GetNx()+1), y(z->GetNy()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_boxs_xy(gr,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_boxs_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
void mgl_tile_xy(HMGL gr, HCDT x, HCDT y, HCDT z, const char *sch, const char *opt)\r
{\r
register long i,j,k,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()<n) { gr->SetWarn(mglWarnDim,"Tile"); return; }\r
- if(n<2 || m<2){ gr->SetWarn(mglWarnLow,"Tile"); return; }\r
- long ly = x->GetNy()>=m ? y->GetNy() : y->GetNx(), lx = x->GetNx();\r
- if(y->GetNx()<z->GetNy() && (x->GetNy()<z->GetNy() || y->GetNx()<z->GetNx() || y->GetNy()<z->GetNy()))\r
- { gr->SetWarn(mglWarnDim); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,0,"Tile",true)) return;\r
+\r
+ long ly = x->GetNy()>=z->GetNy() ? y->GetNy() : y->GetNx(), lx = x->GetNx();\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Tile",cgid++);\r
\r
gr->Reserve(4*n*m*z->GetNz());\r
\r
mglPoint p1,p2,p3,p4,s=mglPoint(0,0,1);\r
- float zz,x1,x2,y1,y2,c;\r
+ mreal zz,x1,x2,y1,y2,c;\r
long k1,k2,k3,k4;\r
for(k=0;k<z->GetNz();k++)\r
{\r
//-----------------------------------------------------------------------------\r
void mgl_tile(HMGL gr, HCDT z, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Tile"); return; }\r
gr->SaveState(opt);\r
mglData x(z->GetNx()+1), y(z->GetNy()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_tile_xy(gr,&x,&y,z,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_tile_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_tile(_GR_, _DA_(a), s, o); delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
+//\r
+// TileS series\r
+//\r
+//-----------------------------------------------------------------------------\r
void mgl_tiles_xy(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT s, const char *sch, const char *opt)\r
{\r
register long i,j,k,n=z->GetNx(),m=z->GetNy();\r
- if(x->GetNx()<n || s->GetNx()*s->GetNy()*s->GetNz()!=n*m*z->GetNz())\r
- { gr->SetWarn(mglWarnDim,"Tile"); return; }\r
- if(n<2 || m<2){ gr->SetWarn(mglWarnLow,"Tile"); return; }\r
+ if(mgl_check_dim2(gr,x,y,z,s,"TileS",true)) return;\r
+\r
long ly = x->GetNy()>=z->GetNy() ? y->GetNy() : y->GetNx(), lx = x->GetNx();\r
- if(y->GetNx()<z->GetNy() && (x->GetNy()<z->GetNy() || y->GetNx()<z->GetNx() || y->GetNy()<z->GetNy()))\r
- { gr->SetWarn(mglWarnDim); return; }\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("TileS",cgid++);\r
\r
gr->Reserve(4*n*m*z->GetNz());\r
\r
mglPoint p1,p2,p3,p4,t=mglPoint(0,0,1);\r
- float zz,x1,x2,x3,x4,y1,y2,y3,y4,ss,sm,c;\r
+ mreal zz,x1,x2,x3,x4,y1,y2,y3,y4,ss,sm,c;\r
long k1,k2,k3,k4;\r
for(k=0;k<z->GetNz();k++)\r
{\r
//-----------------------------------------------------------------------------\r
void mgl_tiles(HMGL gr, HCDT z, HCDT s, const char *sch, const char *opt)\r
{\r
- if(z->GetNx()<2 || z->GetNy()<2){ gr->SetWarn(mglWarnLow,"Tile"); return; }\r
gr->SaveState(opt);\r
mglData x(z->GetNx()+1), y(z->GetNy()+1);\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_tiles_xy(gr,&x,&y,z,s,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_tiles_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, uintptr_t *r, const char *sch, const char *opt,int l,int lo)\r
void mgl_map_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt)\r
{\r
register long i,j,n=ax->GetNx(),m=ax->GetNy();\r
- if(n*m!=ay->GetNx()*ay->GetNy()) { gr->SetWarn(mglWarnDim,"Map"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Map"); return; }\r
+ if(mgl_check_dim2(gr,x,y,ax,ay,"Map")) return;\r
+\r
bool both = x->GetNx()==n && y->GetNx()==n && x->GetNy()==m && y->GetNy()==m;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m)))\r
- { gr->SetWarn(mglWarnDim,"Map"); return; }\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Map",cgid++);\r
\r
long ss = gr->AddTexture(mgl_have_color(sch)?sch:"rgb",2);\r
long s = both ? n:1, s1, s2;\r
\r
- float xdy,xdx,ydx,ydy,xx,yy;\r
+ mreal xdy,xdx,ydx,ydy,xx,yy;\r
mglPoint p,t=mglPoint(NAN);\r
long *pos = new long[n*m];\r
gr->Reserve(n*m);\r
xx = (x->v(i) - gr->Min.x)/(gr->Max.x - gr->Min.x);\r
yy = (y->v(j) - gr->Min.y)/(gr->Max.y - gr->Min.y);\r
}\r
- if(xx<0) xx=0; if(xx>=1) xx=1/MGL_FLT_EPS;\r
- if(yy<0) yy=0; if(yy>=1) yy=1/MGL_FLT_EPS;\r
+ if(xx<0) xx=0; if(xx>=1) xx=1/MGL_EPSILON;\r
+ if(yy<0) yy=0; if(yy>=1) yy=1/MGL_EPSILON;\r
pos[i+n*j] = gr->AddPnt(p,gr->GetC(ss,xx,false),t,yy);\r
}\r
if(sch && strchr(sch,'.')) for(i=0;i<n*m;i++) gr->mark_plot(pos[i],'.',-1);\r
//-----------------------------------------------------------------------------\r
void mgl_map(HMGL gr, HCDT ax, HCDT ay, const char *sch, const char *opt)\r
{\r
- if(ax->GetNx()<2 || ax->GetNy()<2) { gr->SetWarn(mglWarnLow,"Map"); return; }\r
gr->SaveState(opt);\r
mglData x(ax->GetNx()), y(ax->GetNy());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_map_xy(gr,&x,&y,ax,ay,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_map_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
#include "mgl2/vect.h"\r
#include "mgl2/eval.h"\r
#include "mgl2/data.h"\r
-#include <stdlib.h>\r
//-----------------------------------------------------------------------------\r
//\r
// Traj series\r
void mgl_traj_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt)\r
{\r
long m,mx,my,mz,nx,ny,nz,n=ax->GetNx(),pal;\r
- if(n<2) { gr->SetWarn(mglWarnLow,"Traj"); return; }\r
- if(n!=x->GetNx() || z->GetNx()!=n || y->GetNx()!=n || ay->GetNx()!=n || az->GetNx()!=n)\r
- { gr->SetWarn(mglWarnDim,"Traj"); return; }\r
- float len=gr->SaveState(opt); if(mgl_isnan(len)) len = 0;\r
+ if(mgl_check_dim1(gr,x,z,y,ax,"Traj")) return;\r
+ if(mgl_check_dim1(gr,ax,az,ay,0,"Traj")) return;\r
+\r
+ mreal len=gr->SaveState(opt); if(mgl_isnan(len)) len = 0;\r
static int cgid=1; gr->StartGroup("Traj",cgid++);\r
\r
register long i, j;\r
m = x->GetNy()>y->GetNy() ? x->GetNy():y->GetNy(); if(i>m) m=i; if(j>m) m=j;\r
gr->SetPenPal(sch,&pal); gr->Reserve(4*n*m);\r
\r
- float dx,dy,dz,dd,da,xm=0;\r
+ mreal dx,dy,dz,dd,da,xm=0;\r
mglPoint p1,p2;\r
for(j=0;j<m;j++) for(i=0;i<n;i++) // find maximal amplitude of vector field\r
{\r
if(gr->Stop) return;\r
nx = j<x->GetNy() ? j:0; ny = j<y->GetNy() ? j:0; nz = j<z->GetNy() ? j:0;\r
mx = j<ax->GetNy() ? j:0; my = j<ay->GetNy() ? j:0; mz = j<az->GetNy() ? j:0;\r
- da = sqrt(ax->v(i,mx)*ax->v(i,mx)+ay->v(i,my)*ay->v(i,my)+az->v(i,mz)*az->v(i,mz));\r
+ p1 = mglPoint(x->v(i,nx), y->v(i,ny), z->v(i,nz));\r
+ p2 = mglPoint(ax->v(i,mx),ay->v(i,my),az->v(i,mz));\r
+ da = p2.norm();\r
if(len==0)\r
{\r
if(i<n-1)\r
- { dx=x->v(i+1,nx)-x->v(i,nx); dy=y->v(i+1,ny)-y->v(i,ny); dz=z->v(i+1,nz)-z->v(i,nz); }\r
+ { dx=x->v(i+1,nx)-p1.x; dy=y->v(i+1,ny)-p1.y; dz=z->v(i+1,nz)-p1.z; }\r
else\r
- { dx=x->v(i,nx)-x->v(i-1,nx); dy=y->v(i,ny)-y->v(i-1,ny); dz=z->v(i,nz)-z->v(i-1,nz); }\r
+ { dx=p1.x-x->v(i-1,nx); dy=p1.y-y->v(i-1,ny); dz=p1.z-z->v(i-1,nz); }\r
dd = da ? 1/da : 0; dd *= sqrt(dx*dx+dy*dy+dz*dz);\r
}\r
else dd = len;\r
\r
- p1 = mglPoint(x->v(i,nx), y->v(i,ny), z->v(i,nz));\r
- p2 = mglPoint(x->v(i,nx)+dd*ax->v(i,mx), y->v(i,ny)+dd*ay->v(i,my), z->v(i,nz)+dd*az->v(i,mz));\r
- nx = gr->AddPnt(p1); ny = gr->AddPnt(p2);\r
+ nx = gr->AddPnt(p1); ny = gr->AddPnt(p1+dd*p2,-1,mglPoint(NAN),-1,2);\r
gr->vect_plot(nx,ny);\r
}\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_traj_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt)\r
{\r
- if(ax->GetNx()<2) { gr->SetWarn(mglWarnLow,"Traj"); return; }\r
- if(x->GetNx()!=ax->GetNx() || y->GetNx()!=ax->GetNx() || ay->GetNx()!=ax->GetNx())\r
- { gr->SetWarn(mglWarnDim,"Traj"); return; }\r
gr->SaveState(opt);\r
mglData z(x->GetNx()), az(x->GetNx()); z.Fill(gr->Min.z,gr->Min.z);\r
mgl_traj_xyz(gr,x,y,&z,ax,ay,&az,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_traj_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int l,int lo)\r
void mgl_vect_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt)\r
{\r
long i,j,n=ax->GetNx(),m=ax->GetNy(),k;\r
- if(n*m*ax->GetNz()!=ay->GetNx()*ay->GetNy()*ay->GetNz()) { gr->SetWarn(mglWarnDim,"Vect"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Vect"); return; }\r
- bool both = x->GetNx()==n && y->GetNx()==n && x->GetNy()==m && y->GetNy()==m;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m))) { gr->SetWarn(mglWarnDim,"Vect"); return; }\r
+ if(mgl_check_dim2(gr,x,y,ax,ay,"Vect")) return;\r
\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Vect",cgid++);\r
\r
long ss = gr->AddTexture(sch);\r
gr->Reserve(4*n*m);\r
- float zVal = gr->Min.z;\r
+ mreal zVal = gr->Min.z;\r
\r
long tx=1,ty=1;\r
if(gr->MeshNum>1) { tx=(n-1)/(gr->MeshNum-1); ty=(m-1)/(gr->MeshNum-1); }\r
if(tx<1) tx=1; if(ty<1) ty=1;\r
- float xm=0,ym,dx,dy;\r
- float dd,dm=(fabs(gr->Max.c)+fabs(gr->Min.c))*1e-5;\r
+ mreal xm=0,ym,dx,dy;\r
+ mreal dd,dm=(fabs(gr->Max.c)+fabs(gr->Min.c))*1e-5;\r
+ mreal vx,vy;\r
\r
for(k=0;k<ax->GetNz();k++) for(j=0;j<m;j++) for(i=0;i<n;i++)\r
{\r
- ym = ax->v(i,j,k)*ax->v(i,j,k)+ay->v(i,j,k)*ay->v(i,j,k);\r
- xm = xm>ym ? xm : ym;\r
+ vx = ax->v(i,j,k); vy = ay->v(i,j,k);\r
+ ym = vx*vx+vy*vy; xm = xm>ym ? xm : ym;\r
}\r
xm = 1./(xm==0 ? 1:sqrt(xm));\r
long n1,n2;\r
mglPoint p1,p2;\r
- float c1,c2, xx,yy;\r
+ mreal c1,c2, xx,yy;\r
\r
for(k=0;k<ax->GetNz();k++)\r
{\r
- if(ax->GetNz()>1) zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*float(k)/(ax->GetNz()-1);\r
+ if(ax->GetNz()>1) zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*mreal(k)/(ax->GetNz()-1);\r
for(i=0;i<n;i+=tx) for(j=0;j<m;j+=ty)\r
{\r
if(gr->Stop) return;\r
xx = GetX(x,i,j,k).x; yy = GetY(y,i,j,k).x;\r
dx = i<n-1 ? (GetX(x,i+1,j,k).x-xx) : (xx-GetX(x,i-1,j,k).x);\r
dy = j<m-1 ? (GetY(y,i,j+1,k).x-yy) : (yy-GetY(y,i,j-1,k).x);\r
- dx *= tx; dy *= ty; dd = hypot(ax->v(i,j,k),ay->v(i,j,k));\r
- dx *= fix ? (dd>dm ? ax->v(i,j,k)/dd : 0) : ax->v(i,j,k)*xm;\r
- dy *= fix ? (dd>dm ? ay->v(i,j,k)/dd : 0) : ay->v(i,j,k)*xm;\r
+ vx = ax->v(i,j,k); vy = ay->v(i,j,k);\r
+ dx *= tx; dy *= ty; dd = hypot(vx,vy);\r
+ dx *= fix ? (dd>dm ? vx/dd : 0) : vx*xm;\r
+ dy *= fix ? (dd>dm ? vy/dd : 0) : vy*xm;\r
\r
if(end) { p1 = mglPoint(xx-dx,yy-dy,zVal); p2 = mglPoint(xx,yy,zVal); }\r
else if(beg) { p1 = mglPoint(xx,yy,zVal); p2 = mglPoint(xx+dx,yy+dy,zVal); }\r
if(grd) { c1=gr->GetC(ss,dd*xm-0.5,false); c2=gr->GetC(ss,dd*xm,false);}\r
else c1 = c2 = gr->GetC(ss,dd*xm,false);\r
n1=gr->AddPnt(p1,c1); n2=gr->AddPnt(p2,c2);\r
+ // allow vectors outside bounding box\r
+ if(n1<0 && n2>=0) n1=gr->AddPnt(p1,c1,mglPoint(NAN),-1,2);\r
+ if(n2<0 && n1>=0) n2=gr->AddPnt(p2,c2,mglPoint(NAN),-1,2);\r
if(dot) { gr->line_plot(n1,n2); gr->mark_plot(n1,'.'); }\r
else gr->vect_plot(n1,n2);\r
}\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_vect_xy(gr,&x,&y,ax,ay,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_vect_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int l,int lo)\r
void mgl_vect_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt)\r
{\r
register long i,j,n=ax->GetNx(),m=ax->GetNy(),l=ax->GetNz(),k;\r
- if(n*m*l!=ay->GetNx()*ay->GetNy()*ay->GetNz() || ax->GetNx()*ax->GetNy()*ax->GetNz()!=az->GetNx()*az->GetNy()*az->GetNz())\r
- { gr->SetWarn(mglWarnDim,"Vect"); return; }\r
- if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,"Vect"); return; }\r
- bool both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim,"Vect"); return; }\r
+ if(mgl_check_vec3(gr,x,y,z,ax,ay,az,"Vect3")) return;\r
\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Vect3",cgid++);\r
bool beg = sch && strchr(sch,'<');\r
bool grd = sch && strchr(sch,'=');\r
\r
- float xm=0,ym,dx,dy,dz,dd,dm=(fabs(gr->Max.c)+fabs(gr->Min.c))*1e-5;\r
+ mreal xm=0,ym,dx,dy,dz,dd,dm=(fabs(gr->Max.c)+fabs(gr->Min.c))*1e-5;\r
long ss = gr->AddTexture(sch);\r
gr->Reserve(2*n*m*l);\r
long tx=1,ty=1,tz=1;\r
if(gr->MeshNum>1)\r
{ tx=(n-1)/(gr->MeshNum-1); ty=(m-1)/(gr->MeshNum-1); tz=(l-1)/(gr->MeshNum-1);}\r
if(tx<1) tx=1; if(ty<1) ty=1; if(tz<1) tz=1;\r
+ mglPoint p;\r
\r
for(k=0;k<l;k++) for(j=0;j<m;j++) for(i=0;i<n;i++)\r
{\r
- ym = ax->v(i,j,k)*ax->v(i,j,k)+ay->v(i,j,k)*ay->v(i,j,k)+az->v(i,j,k)*az->v(i,j,k);\r
- xm = xm>ym ? xm : ym;\r
+ p = mglPoint(ax->v(i,j,k),ay->v(i,j,k),az->v(i,j,k));\r
+ ym = p.x*p.x+p.y*p.y+p.z*p.z; xm = xm>ym ? xm : ym;\r
}\r
xm = 1./(xm==0 ? 1:sqrt(xm));\r
\r
long n1,n2;\r
mglPoint p1,p2;\r
- float c1,c2, xx,yy,zz;\r
+ mreal c1,c2, xx,yy,zz;\r
\r
for(k=0;k<l;k+=tz) for(i=0;i<n;i+=tx) for(j=0;j<m;j+=ty)\r
{\r
dy = j<m-1 ? (GetY(y,i,j+1,k).x-yy) : (yy-GetY(y,i,j-1,k).x);\r
dz = k<l-1 ? (GetZ(z,i,j,k+1).x-zz) : (zz-GetZ(z,i,j,k-1).x);\r
dx *= tx; dy *= ty; dz *= tz;\r
- dd = sqrt(ax->v(i,j,k)*ax->v(i,j,k)+ay->v(i,j,k)*ay->v(i,j,k)+az->v(i,j,k)*az->v(i,j,k));\r
- dx *= fix ? (dd>dm ? ax->v(i,j,k)/dd : 0) : ax->v(i,j,k)*xm;\r
- dy *= fix ? (dd>dm ? ay->v(i,j,k)/dd : 0) : ay->v(i,j,k)*xm;\r
- dz *= fix ? (dd>dm ? az->v(i,j,k)/dd : 0) : az->v(i,j,k)*xm;\r
+ p = mglPoint(ax->v(i,j,k),ay->v(i,j,k),az->v(i,j,k)); dd = p.norm();\r
+ dx *= fix ? (dd>dm ? p.x/dd : 0) : p.x*xm;\r
+ dy *= fix ? (dd>dm ? p.y/dd : 0) : p.y*xm;\r
+ dz *= fix ? (dd>dm ? p.z/dd : 0) : p.z*xm;\r
\r
if(end) { p1 = mglPoint(xx-dx,yy-dy,zz-dz); p2 = mglPoint(xx,yy,zz); }\r
else if(beg) { p1 = mglPoint(xx,yy,zz); p2 = mglPoint(xx+dx,yy+dy,zz+dz); }\r
if(grd) { c1=gr->GetC(ss,dd*xm-0.5,false); c2=gr->GetC(ss,dd*xm,false); }\r
else c1 = c2 = gr->GetC(ss,dd*xm,false);\r
n1=gr->AddPnt(p1,c1); n2=gr->AddPnt(p2,c2);\r
+ // allow vectors outside bounding box\r
+ if(n1<0 && n2>=0) n1=gr->AddPnt(p1,c1,mglPoint(NAN),-1,2);\r
+ if(n2<0 && n1>=0) n2=gr->AddPnt(p2,c2,mglPoint(NAN),-1,2);\r
if(dot) { gr->line_plot(n1,n2); gr->mark_plot(n1,'.'); }\r
else gr->vect_plot(n1,n2);\r
}\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_vect_xyz(gr,&x,&y,&z,ax,ay,az,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_vect_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int l,int lo)\r
// Flow 2d series\r
//\r
//-----------------------------------------------------------------------------\r
-void flow(mglBase *gr, float zVal, float u, float v, const mglData &x, const mglData &y, const mglData &ax, const mglData &ay, long ss, bool vv)\r
+void flow(mglBase *gr, mreal zVal, mreal u, mreal v, const mglData &x, const mglData &y, const mglData &ax, const mglData &ay, long ss, bool vv)\r
{\r
long n=10*(ax.nx+ax.ny);\r
bool both = x.nx==ax.nx && y.nx==ax.nx && x.ny==ax.ny && y.ny==ax.ny;\r
\r
mglPoint *pp = new mglPoint[n], dp;\r
- float *cc = new float[n];\r
+ mreal *cc = new mreal[n];\r
mglPoint dx(1/fabs(gr->Max.x-gr->Min.x),1/fabs(gr->Max.y-gr->Min.y),1/fabs(gr->Max.z-gr->Min.z));\r
\r
- float dt = 0.5/(ax.nx > ax.ny ? ax.nx : ax.ny),e,f,g,ff[4],gg[4],h,s=1;\r
+ mreal dt = 0.5/(ax.nx > ax.ny ? ax.nx : ax.ny),e,f,g,ff[4],gg[4],h,s=1;\r
if(u<0 || v<0) { dt = -dt; u = -u; v = -v; s = -1;}\r
register long k=0,m;\r
bool end = false;\r
//-----------------------------------------------------------------------------\r
void mgl_flow_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt)\r
{\r
- float u,v;\r
- long n=ax->GetNx(), m=ax->GetNy();\r
- if(n*m*ax->GetNz()!=ay->GetNx()*ay->GetNy()*ay->GetNz()) { gr->SetWarn(mglWarnDim,"Flow"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Flow"); return; }\r
- bool both = x->GetNx()==n && y->GetNx()==n && x->GetNy()==m && y->GetNy()==m;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m))) { gr->SetWarn(mglWarnDim,"Flow"); return; }\r
- float r = gr->SaveState(opt);\r
+ mreal u,v;\r
+ if(mgl_check_dim2(gr,x,y,ax,ay,"Flow")) return;\r
+\r
+ mreal r = gr->SaveState(opt);\r
long num = mgl_isnan(r)?5:long(r+0.5);\r
static int cgid=1; gr->StartGroup("Flow",cgid++);\r
\r
long ss = gr->AddTexture(sch);\r
bool vv = sch && strchr(sch,'v');\r
// allocate memory\r
- float zVal = gr->Min.z;\r
+ mreal zVal = gr->Min.z;\r
bool cnt=!(sch && strchr(sch,'#'));\r
mglData xx(x), yy(y), bx(ax), by(ay);\r
\r
for(long k=0;k<ax->GetNz();k++)\r
{\r
- if(ax->GetNz()>1) zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*float(k)/(ax->GetNz()-1);\r
+ if(ax->GetNz()>1) zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*mreal(k)/(ax->GetNz()-1);\r
for(long i=0;i<num;i++)\r
{\r
if(gr->Stop) return;\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_flow_xy(gr,&x,&y,ax,ay,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_flow_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt,int l,int lo)\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_flow_2d(_GR_, _DA_(ax), _DA_(ay), s, o); delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_flowp_xy(HMGL gr, float x0, float y0, float z0, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt)\r
+void mgl_flowp_xy(HMGL gr, mreal x0, mreal y0, mreal z0, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, const char *opt)\r
{\r
mglPoint p(x0,y0,z0);\r
- float u,v;\r
+ mreal u,v;\r
long n=ax->GetNx(), m=ax->GetNy();\r
- if(n*m*ax->GetNz()!=ay->GetNx()*ay->GetNy()*ay->GetNz()) { gr->SetWarn(mglWarnDim,"Flow"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Flow"); return; }\r
bool both = x->GetNx()==n && y->GetNx()==n && x->GetNy()==m && y->GetNy()==m;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m))) { gr->SetWarn(mglWarnDim,"Flow"); return; }\r
+ if(mgl_check_dim2(gr,x,y,ax,ay,"FlowP")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("FlowP",cgid++);\r
\r
bool vv = sch && strchr(sch,'v');\r
// find coordinates u, v\r
register long i,j;\r
- register float d, dm=1e7;\r
+ register mreal d, dm=1e7;\r
long i0=0,j0=0;\r
for(i=0;i<n;i++) for(j=0;j<m;j++) // first find closest\r
{\r
d = both ? hypot(x->v(i,j)-p.x,y->v(i,j)-p.y) : hypot(x->v(i)-p.x,y->v(j)-p.y);\r
if(d<dm) { i0=i; j0=j; dm=d; }\r
}\r
- if(dm==0) { u = i0/float(n); v = j0/float(m); } // we find it\r
+ if(dm==0) { u = i0/mreal(n); v = j0/mreal(m); } // we find it\r
else\r
{\r
- float dxu,dxv,dyu,dyv, dx, dy;\r
+ mreal dxu,dxv,dyu,dyv, dx, dy;\r
if(both)\r
{\r
dx = x->v(i0,j0)-p.x; dy = y->v(i0,j0)-p.y;\r
gr->EndGroup();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_flowp_2d(HMGL gr, float x0, float y0, float z0, HCDT ax, HCDT ay, const char *sch, const char *opt)\r
+void mgl_flowp_2d(HMGL gr, mreal x0, mreal y0, mreal z0, HCDT ax, HCDT ay, const char *sch, const char *opt)\r
{\r
gr->SaveState(opt);\r
mglData x(ax->GetNx()), y(ax->GetNy());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_flowp_xy(gr,x0,y0,z0,&x,&y,ax,ay,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_flowp_xy_(uintptr_t *gr, float *x0, float *y0, float *z0, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt, int l,int lo)\r
+void mgl_flowp_xy_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt, int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_flowp_xy(_GR_, *x0,*y0,*z0, _DA_(x), _DA_(y), _DA_(ax), _DA_(ay), s, o); delete []o; delete []s;\r
}\r
-void mgl_flowp_2d_(uintptr_t *gr, float *x0, float *y0, float *z0, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt, int l,int lo)\r
+void mgl_flowp_2d_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0, uintptr_t *ax, uintptr_t *ay, const char *sch, const char *opt, int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_flowp_2d(_GR_, *x0,*y0,*z0, _DA_(ax), _DA_(ay), s, o); delete []o; delete []s; }\r
// Flow 3d series\r
//\r
//-----------------------------------------------------------------------------\r
-void flow(mglBase *gr, float u, float v, float w, const mglData &x, const mglData &y, const mglData &z, const mglData &ax, const mglData &ay, const mglData &az,long ss,bool vv, bool xo, bool zo)\r
+void flow(mglBase *gr, mreal u, mreal v, mreal w, const mglData &x, const mglData &y, const mglData &z, const mglData &ax, const mglData &ay, const mglData &az,long ss,bool vv, bool xo, bool zo)\r
{\r
static long n=10*(ax.nx+ax.ny);\r
long nn = ax.nx*ax.ny*ax.nz;\r
bool both = x.nx*x.ny*x.nz==nn && y.nx*y.ny*y.nz==nn && z.nx*z.ny*z.nz==nn;\r
mglPoint *pp = new mglPoint[n], dp;\r
- float *cc = new float[n];\r
+ mreal *cc = new mreal[n];\r
mglPoint dx(1/fabs(gr->Max.x-gr->Min.x),1/fabs(gr->Max.y-gr->Min.y),1/fabs(gr->Max.z-gr->Min.z));\r
\r
nn = (ax.nx > ax.ny ? ax.nx : ax.ny);\r
nn = (nn > ax.nz ? nn : ax.nz);\r
- float dt = 0.2/nn, e,f,g,ee[4],ff[4],gg[4],h,s=1,u1,v1,w1;\r
+ mreal dt = 0.2/nn, e,f,g,ee[4],ff[4],gg[4],h,s=1,u1,v1,w1;\r
if(u<0 || v<0 || w<0)\r
{ dt = -dt; u = -u; v = -v; w = -w; s = -1;}\r
register long k=0,m;\r
if(k>1)\r
{\r
long i,j,jj,a=long(1./fabs(dt));\r
- float rr = mgl_norm(gr->Max-gr->Min)*gr->BarWidth/25, ll;\r
+ mreal rr = mgl_norm(gr->Max-gr->Min)*gr->BarWidth/25, ll;\r
mglPoint q1,q2,l;\r
long n1=-1,n2=-1,n3=-1,n4=-1, m1=-1,m2=-1,m3=-1,m4=-1;\r
\r
//-----------------------------------------------------------------------------\r
void mgl_flow_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt)\r
{\r
- float u,v,w;\r
- long i,j,n=ax->GetNx(),m=ax->GetNy(),l=ax->GetNz();\r
- if(ax->GetNx()*ax->GetNy()*ax->GetNz()!=ay->GetNx()*ay->GetNy()*ay->GetNz() || ax->GetNx()*ax->GetNy()*ax->GetNz()!=az->GetNx()*az->GetNy()*az->GetNz())\r
- { gr->SetWarn(mglWarnDim,"Flow"); return; }\r
- if(ax->GetNx()<2 || ax->GetNy()<2 || ax->GetNz()<2)\r
- { gr->SetWarn(mglWarnLow,"Flow"); return; }\r
- bool both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim,"Flow"); return; }\r
- float r = gr->SaveState(opt);\r
+ mreal u,v,w;\r
+ long i,j;\r
+ if(mgl_check_vec3(gr,x,y,z,ax,ay,az,"Flow3")) return;\r
+\r
+ mreal r = gr->SaveState(opt);\r
long num = mgl_isnan(r)?3:long(r+0.5);\r
static int cgid=1; gr->StartGroup("Flow3",cgid++);\r
bool cnt=!(sch && strchr(sch,'#'));\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_flow_xyz(gr,&x,&y,&z,ax,ay,az,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_flow_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt,int l,int lo)\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_flow_3d(_GR_, _DA_(ax), _DA_(ay), _DA_(az), s, o); delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_flowp_xyz(HMGL gr, float x0, float y0, float z0, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt)\r
+void mgl_flowp_xyz(HMGL gr, mreal x0, mreal y0, mreal z0, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt)\r
{\r
mglPoint p(x0,y0,z0);\r
- float u,v,w;\r
+ mreal u,v,w;\r
long n=ax->GetNx(),m=ax->GetNy(),l=ax->GetNz();\r
- if(ax->GetNx()*ax->GetNy()*ax->GetNz()!=ay->GetNx()*ay->GetNy()*ay->GetNz() || ax->GetNx()*ax->GetNy()*ax->GetNz()!=az->GetNx()*az->GetNy()*az->GetNz())\r
- { gr->SetWarn(mglWarnDim,"Flow"); return; }\r
- if(ax->GetNx()<2 || ax->GetNy()<2 || ax->GetNz()<2)\r
- { gr->SetWarn(mglWarnLow,"Flow"); return; }\r
bool both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim,"Flow"); return; }\r
+ if(mgl_check_vec3(gr,x,y,z,ax,ay,az,"FlowP3")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("FlowP3",cgid++);\r
long ss = gr->AddTexture(sch);\r
\r
// find coordinates u, v, w\r
register long i,j,k;\r
- register float d, dm=1e7;\r
+ register mreal d, dm=1e7;\r
long i0=0,j0=0,k0=0;\r
- float dx,dy,dz;\r
+ mreal dx,dy,dz;\r
for(i=0;i<n;i++) for(j=0;j<m;j++) for(k=0;k<l;k++) // first find closest\r
{\r
if(both)\r
if(d<dm) { i0=i; j0=j; k0=k; dm=d; }\r
}\r
if(dm==0) // we find it\r
- { u=i0/float(n); v=j0/float(m); w=k0/float(l); }\r
+ { u=i0/mreal(n); v=j0/mreal(m); w=k0/mreal(l); }\r
else\r
{\r
- float dxu,dxv,dxw,dyu,dyv,dyw,dzu,dzv,dzw;\r
+ mreal dxu,dxv,dxw,dyu,dyv,dyw,dzu,dzv,dzw;\r
if(both)\r
{\r
dx = x->v(i0,j0,k0)-p.x; dy = y->v(i0,j0,k0)-p.y; dz = z->v(i0,j0,k0)-p.z;\r
gr->EndGroup();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_flowp_3d(HMGL gr, float x0, float y0, float z0, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt)\r
+void mgl_flowp_3d(HMGL gr, mreal x0, mreal y0, mreal z0, HCDT ax, HCDT ay, HCDT az, const char *sch, const char *opt)\r
{\r
gr->SaveState(opt);\r
mglData x(ax->GetNx()), y(ax->GetNy()), z(ax->GetNz());\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_flowp_xyz(gr, x0,y0,z0, &x,&y,&z,ax,ay,az,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_flowp_xyz_(uintptr_t *gr, float *x0, float *y0, float *z0, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt, int l,int lo)\r
+void mgl_flowp_xyz_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt, int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_flowp_xyz(_GR_, *x0,*y0,*z0, _DA_(x), _DA_(y), _DA_(z), _DA_(ax), _DA_(ay), _DA_(az), s, o);\r
delete []o; delete []s; }\r
-void mgl_flowp_3d_(uintptr_t *gr, float *x0, float *y0, float *z0, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt, int l,int lo)\r
+void mgl_flowp_3d_(uintptr_t *gr, mreal *x0, mreal *y0, mreal *z0, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, const char *opt, int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_flowp_3d(_GR_, *x0,*y0,*z0, _DA_(ax), _DA_(ay), _DA_(az), s, o); delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
void mgl_grad_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT phi, const char *sch, const char *opt)\r
{\r
- mglData ax(phi), ay(phi),az(phi),xx(phi),yy(phi),zz(phi);\r
+ mglData ax(phi), ay,az,xx,yy,zz;\r
+ ay.Set(ax); az.Set(ax); xx.Set(ax); yy.Set(ax); zz.Set(ax);\r
long n=xx.nx, m=xx.ny, l=xx.nz, nn = n*m*l;\r
if(x->GetNx()*x->GetNy()*x->GetNz()==nn && y->GetNx()*y->GetNy()*y->GetNz()==nn && x->GetNx()*x->GetNy()*x->GetNz()==nn)\r
{ xx.Set(x); yy.Set(y); zz.Set(z); } // nothing to do\r
//-----------------------------------------------------------------------------\r
void mgl_grad_xy(HMGL gr, HCDT x, HCDT y, HCDT phi, const char *sch, const char *opt)\r
{\r
- mglData ax(phi), ay(phi),xx(phi),yy(phi);\r
+ mglData ax(phi), ay,xx,yy;\r
+ ay.Set(ax); xx.Set(ax); yy.Set(ax);\r
long n = phi->GetNx(), m=phi->GetNy(), nn=n*m;\r
if(x->GetNx()*x->GetNy()==nn && y->GetNx()*y->GetNy()==nn) { xx.Set(x); yy.Set(y); }\r
else if(x->GetNx()==n && y->GetNx()==m)\r
x.Fill(gr->Min.x,gr->Max.x); y.Fill(gr->Min.y,gr->Max.y); z.Fill(gr->Min.z,gr->Max.z);\r
if(phi->GetNz()==1) mgl_grad_xy(gr,&x,&y,phi,sch,0);\r
else mgl_grad_xyz(gr,&x,&y,&z,phi,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_grad_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ph, const char *sch, const char *opt, int l,int lo)\r
// Pipe 2d series\r
//\r
//-----------------------------------------------------------------------------\r
-void flowr(mglBase *gr, float zVal, float u, float v, const mglData &x, const mglData &y, const mglData &ax, const mglData &ay, float r0,long sc)\r
+void flowr(mglBase *gr, mreal zVal, mreal u, mreal v, const mglData &x, const mglData &y, const mglData &ax, const mglData &ay, mreal r0,long sc)\r
{\r
long n=10*(ax.nx+ax.ny);\r
bool both = x.nx==ax.nx && y.nx==ax.nx && x.ny==ax.ny && y.ny==ax.ny;\r
\r
mglPoint *pp = new mglPoint[n], dp;\r
- float *cc = new float[n];\r
+ mreal *cc = new mreal[n];\r
mglPoint dx(1/fabs(gr->Max.x-gr->Min.x),1/fabs(gr->Max.y-gr->Min.y),1/fabs(gr->Max.z-gr->Min.z));\r
\r
- float dt = 0.5/(ax.nx > ax.ny ? ax.nx : ax.ny),e,f,g,ff[4],gg[4],h,s=1;\r
- float ss = 4./mgl_ipow(gr->Max.c - gr->Min.c,2);\r
+ mreal dt = 0.5/(ax.nx > ax.ny ? ax.nx : ax.ny),e,f,g,ff[4],gg[4],h,s=1;\r
+ mreal ss = 4./mgl_ipow(gr->Max.c - gr->Min.c,2);\r
if(u<0 || v<0) { dt = -dt; u = -u; v = -v; s = -1;}\r
register long k=0,m;\r
bool end = false;\r
long i,j,*id=new long[2*num];\r
mglPoint p,l=pp[1]-pp[0],t,q,d;\r
t = !l; t.Normalize(); q = t^l; q.Normalize();\r
- float si,co,fi, rr=pp[0].c,dr=l.c;\r
+ mreal si,co,fi, rr=pp[0].c,dr=l.c;\r
gr->Reserve(num*k);\r
\r
for(j=0;j<num;j++)\r
delete []pp; delete []cc;\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_pipe_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, float r0, const char *opt)\r
+void mgl_pipe_xy(HMGL gr, HCDT x, HCDT y, HCDT ax, HCDT ay, const char *sch, mreal r0, const char *opt)\r
{\r
- float u,v;\r
- long n=ax->GetNx(), m=ax->GetNy();\r
- if(n*m*ax->GetNz()!=ay->GetNx()*ay->GetNy()*ay->GetNz()) { gr->SetWarn(mglWarnDim,"Pipe"); return; }\r
- if(n<2 || m<2) { gr->SetWarn(mglWarnLow,"Pipe"); return; }\r
- bool both = x->GetNx()==n && y->GetNx()==n && x->GetNy()==m && y->GetNy()==m;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m))) { gr->SetWarn(mglWarnDim,"Pipe"); return; }\r
- float r = gr->SaveState(opt);\r
+ mreal u,v;\r
+ if(mgl_check_dim2(gr,x,y,ax,ay,"Pipe")) return;\r
+\r
+ mreal r = gr->SaveState(opt);\r
long num = mgl_isnan(r)?5:long(r+0.5);\r
static int cgid=1; gr->StartGroup("Pipe",cgid++);\r
\r
long ss = gr->AddTexture(sch);\r
// allocate memory\r
- float zVal = gr->Min.z;\r
+ mreal zVal = gr->Min.z;\r
bool cnt=!(sch && strchr(sch,'#'));\r
if(sch && strchr(sch,'i')) r0 = -fabs(r0);\r
\r
mglData xx(x), yy(y), bx(ax), by(ay);\r
for(long k=0;k<ax->GetNz();k++)\r
{\r
- if(ax->GetNz()>1) zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*float(k)/(ax->GetNz()-1);\r
+ if(ax->GetNz()>1) zVal = gr->Min.z+(gr->Max.z-gr->Min.z)*mreal(k)/(ax->GetNz()-1);\r
for(long i=0;i<num;i++)\r
{\r
if(gr->Stop) return;\r
gr->EndGroup();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_pipe_2d(HMGL gr, HCDT ax, HCDT ay, const char *sch, float r0, const char *opt)\r
+void mgl_pipe_2d(HMGL gr, HCDT ax, HCDT ay, const char *sch, mreal r0, const char *opt)\r
{\r
gr->SaveState(opt);\r
mglData x(ax->GetNx()), y(ax->GetNy());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
mgl_pipe_xy(gr,&x,&y,ax,ay,sch,r0,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_pipe_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, float *r0, const char *opt,int l,int lo)\r
+void mgl_pipe_xy_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *ax, uintptr_t *ay, const char *sch, mreal *r0, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_pipe_xy(_GR_, _DA_(x), _DA_(y), _DA_(ax), _DA_(ay), s, *r0, o); delete []o; delete []s; }\r
-void mgl_pipe_2d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, const char *sch, float *r0, const char *opt,int l,int lo)\r
+void mgl_pipe_2d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, const char *sch, mreal *r0, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_pipe_2d(_GR_, _DA_(ax), _DA_(ay), s, *r0, o); delete []o; delete []s; }\r
// Pipe 3d series\r
//\r
//-----------------------------------------------------------------------------\r
-void flowr(mglBase *gr, float u, float v, float w, const mglData &x, const mglData &y, const mglData &z, const mglData &ax, const mglData &ay, const mglData &az, float r0,long sc)\r
+void flowr(mglBase *gr, mreal u, mreal v, mreal w, const mglData &x, const mglData &y, const mglData &z, const mglData &ax, const mglData &ay, const mglData &az, mreal r0,long sc)\r
{\r
static long n=10*(ax.nx+ax.ny);\r
long nn = ax.nx*ax.ny*ax.nz;\r
bool both = x.nx*x.ny*x.nz==nn && y.nx*y.ny*y.nz==nn && z.nx*z.ny*z.nz==nn;\r
mglPoint *pp = new mglPoint[n], dp;\r
- float *cc = new float[n];\r
+ mreal *cc = new mreal[n];\r
mglPoint dx(1/fabs(gr->Max.x-gr->Min.x),1/fabs(gr->Max.y-gr->Min.y),1/fabs(gr->Max.z-gr->Min.z));\r
\r
nn = (ax.nx > ax.ny ? ax.nx : ax.ny);\r
nn = (nn > ax.nz ? nn : ax.nz);\r
- float dt = 0.2/nn, e,f,g,ee[4],ff[4],gg[4],h,s=1,u1,v1,w1;\r
- float ss = 4./mgl_ipow(gr->Max.c - gr->Min.c,2);\r
+ mreal dt = 0.2/nn, e,f,g,ee[4],ff[4],gg[4],h,s=1,u1,v1,w1;\r
+ mreal ss = 4./mgl_ipow(gr->Max.c - gr->Min.c,2);\r
\r
if(u<0 || v<0 || w<0)\r
{ dt = -dt; u = -u; v = -v; w = -w; s = -1;}\r
long i,j,*id=new long[2*num];\r
mglPoint p,l=pp[1]-pp[0],t,q,d;\r
t = !l; t.Normalize(); q = t^l; q.Normalize();\r
- float si,co,fi, rr=pp[0].c,dr=l.c;\r
+ mreal si,co,fi, rr=pp[0].c,dr=l.c;\r
gr->Reserve(num*k);\r
\r
for(j=0;j<num;j++)\r
delete []pp; delete []cc;\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_pipe_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, float r0, const char *opt)\r
+void mgl_pipe_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT ax, HCDT ay, HCDT az, const char *sch, mreal r0, const char *opt)\r
{\r
- float u,v,w;\r
- long i,j,n=ax->GetNx(),m=ax->GetNy(),l=ax->GetNz();\r
- if(ax->GetNx()*ax->GetNy()*ax->GetNz()!=ay->GetNx()*ay->GetNy()*ay->GetNz() || ax->GetNx()*ax->GetNy()*ax->GetNz()!=az->GetNx()*az->GetNy()*az->GetNz())\r
- { gr->SetWarn(mglWarnDim,"Pipe"); return; }\r
- if(ax->GetNx()<2 || ax->GetNy()<2 || ax->GetNz()<2)\r
- { gr->SetWarn(mglWarnLow,"Pipe"); return; }\r
- bool both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim,"Pipe"); return; }\r
- float r = gr->SaveState(opt);\r
+ mreal u,v,w;\r
+ long i,j;\r
+ if(mgl_check_vec3(gr,x,y,z,ax,ay,az,"Vect")) return;\r
+\r
+ mreal r = gr->SaveState(opt);\r
long num = mgl_isnan(r)?3:long(r+0.5);\r
static int cgid=1; gr->StartGroup("Pipe3",cgid++);\r
if(sch && strchr(sch,'i')) r0 = -fabs(r0);\r
gr->EndGroup();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_pipe_3d(HMGL gr, HCDT ax, HCDT ay, HCDT az, const char *sch, float r0, const char *opt)\r
+void mgl_pipe_3d(HMGL gr, HCDT ax, HCDT ay, HCDT az, const char *sch, mreal r0, const char *opt)\r
{\r
gr->SaveState(opt);\r
mglData x(ax->GetNx()), y(ax->GetNy()), z(ax->GetNz());\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_pipe_xyz(gr,&x,&y,&z,ax,ay,az,sch,r0,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_pipe_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, float *r0, const char *opt,int l,int lo)\r
+void mgl_pipe_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, mreal *r0, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_pipe_xyz(_GR_, _DA_(x), _DA_(y), _DA_(z), _DA_(ax), _DA_(ay), _DA_(az), s, *r0, o);\r
delete []o; delete []s; }\r
-void mgl_pipe_3d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, float *r0, const char *opt,int l,int lo)\r
+void mgl_pipe_3d_(uintptr_t *gr, uintptr_t *ax, uintptr_t *ay, uintptr_t *az, const char *sch, mreal *r0, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_pipe_3d(_GR_, _DA_(ax), _DA_(ay), _DA_(az), s, *r0, o); delete []o; delete []s; }\r
{\r
if(!(gr->GetQuality()&3)) return; // do nothing in fast_draw\r
long i,j,k,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
- register int i0;\r
- if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,"Cloud"); return; }\r
- bool both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim); return; }\r
+ register long i0;\r
+ bool both = mgl_isboth(x,y,z,a);\r
+ if(mgl_check_dim3(gr,both,x,y,z,a,0,"Cloud")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Cloud",cgid++);\r
\r
- int tx=1,ty=1,tz=1;\r
+ long tx=1,ty=1,tz=1;\r
if(gr->MeshNum>1)\r
{ tx=(n-1)/(gr->MeshNum-1); ty=(m-1)/(gr->MeshNum-1); tz=(l-1)/(gr->MeshNum-1);}\r
if(tx<1) tx=1; if(ty<1) ty=1; if(tz<1) tz=1;\r
\r
- float alpha = gr->AlphaDef;\r
+ mreal alpha = gr->AlphaDef;\r
bool inv = sch && strchr(sch,'!');\r
bool dot = sch && strchr(sch,'.');\r
alpha /= pow(n/tx*m/ty*l/tz,1./3)/20;\r
- float aa,bb;\r
+ mreal aa,bb;\r
if(alpha>1) alpha = 1;\r
long ss = gr->AddTexture(sch);\r
\r
//-----------------------------------------------------------------------------\r
void mgl_cloud(HMGL gr, HCDT a, const char *sch, const char *opt)\r
{\r
- if(a->GetNx()<2 || a->GetNy()<2 || a->GetNz()<2)\r
- { gr->SetWarn(mglWarnLow,"Cloud"); return; }\r
gr->SaveState(opt);\r
mglData x(a->GetNx()), y(a->GetNy()),z(a->GetNz());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_cloud_xyz(gr,&x,&y,&z,a,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_cloud_xyz_(uintptr_t *gr, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
// Surf3 series\r
//\r
//-----------------------------------------------------------------------------\r
-mglPoint mgl_normal_3d(const mglDataA *a, mglPoint p, bool inv, long n,long m,long l)\r
+mglPoint mgl_normal_3d(HCDT a, mglPoint p, bool inv, long n,long m,long l)\r
{\r
register long i,j,k;\r
- register float x=p.x, y=p.y, z=p.z;\r
- float nx=0, ny=0, nz=0;\r
+ register mreal x=p.x, y=p.y, z=p.z;\r
+ mreal nx=0, ny=0, nz=0;\r
i=long(x); j=long(y); k=long(z);\r
i = i<n-1 ? i:n-2; j = j<m-1 ? j:m-2; k = k<l-1 ? k:l-2;\r
x-=i; y-=j; z-=k;\r
return inv ? mglPoint(nx,ny,nz) : mglPoint(-nx,-ny,-nz);\r
}\r
//-----------------------------------------------------------------------------\r
-float mgl_normal_1d(const mglDataA *a, float x, bool inv, long n)\r
+mreal mgl_normal_1d(HCDT a, mreal x, bool inv, long n)\r
{\r
register long i=long(x); x-=i;\r
- float nx = a->dvx(i);\r
+ mreal nx = a->dvx(i);\r
if(i<n-1) nx = nx*(1-x) + a->dvx(i+1)*x;\r
return inv ? nx : -nx;\r
}\r
return q;\r
}\r
//-----------------------------------------------------------------------------\r
-inline float mgl_cos_pp(const mglPoint *kk,long i0,long i1,long i2)\r
+inline mreal mgl_cos_pp(const mglPoint *kk,long i0,long i1,long i2)\r
{\r
mglPoint dp1 = kk[i1]-kk[i0], dp2 = kk[i2]-kk[i0];\r
- float p1=dp1*dp1,p2=dp2*dp2,pc=dp1*dp2;\r
+ mreal p1=dp1*dp1,p2=dp2*dp2,pc=dp1*dp2;\r
return p1*p2>1e-10 ? pc/sqrt(p1*p2) : NAN;\r
}\r
//-----------------------------------------------------------------------------\r
register long i,j,k,i0,ii,jj;\r
long id[12],us[12],pd[12],ni;\r
mglPoint pp[12];\r
- float d,d0;\r
+ mreal d,d0;\r
\r
for(i=0;i<n-1;i++) for(j=0;j<m-1;j++)\r
{\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3_xyz_val(HMGL gr, float val, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, const char *opt)\r
+void mgl_surf3_xyz_val(HMGL gr, mreal val, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, const char *opt)\r
{\r
long i,j,k,i1,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
long *kx1,*kx2,*ky1,*ky2,*kz;\r
- bool both, wire = sch && strchr(sch,'#');\r
- float d;\r
- if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,"Surf3"); return; }\r
- both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim,"Surf3"); return; }\r
+ bool both = mgl_isboth(x,y,z,a), wire = sch && strchr(sch,'#');\r
+ mreal d;\r
+ if(mgl_check_dim3(gr,both,x,y,z,a,0,"Surf3")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Surf3",cgid++);\r
\r
kx1 = new long[n*m]; kx2 = new long[n*m];\r
ky1 = new long[n*m]; ky2 = new long[n*m];\r
kz = new long[n*m];\r
- float c=gr->GetC(ss,val);\r
+ mreal c=gr->GetC(ss,val);\r
std::vector<mglPoint> kk;\r
kk.reserve(n*m*l);\r
\r
- mglPoint p,q,u;\r
- float a0;\r
+ mglPoint p,q,u, p0;\r
+ mreal a0;\r
for(k=0;k<l;k++)\r
{\r
memcpy(kx1,kx2,n*m*sizeof(long)); memset(kx2,-1,n*m*sizeof(long));\r
if(gr->Stop) { delete []kx1; delete []kx2; delete []ky1;\r
delete []ky2; delete []kz; return; }\r
i1 = i+n*j; a0 = a->v(i,j,k);\r
+ p0 = both?mglPoint(x->v(i,j,k), y->v(i,j,k), z->v(i,j,k)) : mglPoint(x->v(i), y->v(j), z->v(k));\r
if(i<n-1)\r
{\r
d = mgl_d(val,a0,a->v(i+1,j,k));\r
if(d>=0 && d<1)\r
{\r
- if(both) p = mglPoint(x->v(i,j,k)*(1-d)+x->v(i+1,j,k)*d,\r
- y->v(i,j,k)*(1-d)+y->v(i+1,j,k)*d,\r
- z->v(i,j,k)*(1-d)+z->v(i+1,j,k)*d);\r
- else p = mglPoint(x->v(i)*(1-d)+x->v(i+1)*d, y->v(j), z->v(k));\r
+ if(both) p = mglPoint(p0.x*(1-d)+x->v(i+1,j,k)*d,\r
+ p0.y*(1-d)+y->v(i+1,j,k)*d,\r
+ p0.z*(1-d)+z->v(i+1,j,k)*d);\r
+ else p = mglPoint(p0.x*(1-d)+x->v(i+1)*d, p0.y, p0.z);\r
u = mglPoint(i+d,j,k);\r
q = mgl_find_norm(both, x,y,z,a, u, inv,n,m,l);\r
pos = gr->AddPnt(p,c,q); u.c=pos;\r
d = mgl_d(val,a0,a->v(i,j+1,k));\r
if(d>=0 && d<1)\r
{\r
- if(both) p = mglPoint(x->v(i,j,k)*(1-d)+x->v(i,j+1,k)*d,\r
- y->v(i,j,k)*(1-d)+y->v(i,j+1,k)*d,\r
- z->v(i,j,k)*(1-d)+z->v(i,j+1,k)*d);\r
- else p = mglPoint(x->v(i), y->v(j)*(1-d)+y->v(j+1)*d, z->v(k));\r
+ if(both) p = mglPoint(p0.x*(1-d)+x->v(i,j+1,k)*d,\r
+ p0.y*(1-d)+y->v(i,j+1,k)*d,\r
+ p0.z*(1-d)+z->v(i,j+1,k)*d);\r
+ else p = mglPoint(p0.x, p0.y*(1-d)+y->v(j+1)*d, p0.z);\r
u = mglPoint(i,j+d,k);\r
q = mgl_find_norm(both, x,y,z,a, u, inv,n,m,l);\r
pos = gr->AddPnt(p,c,q); u.c=pos;\r
d = mgl_d(val,a->v(i,j,k-1),a0);\r
if(d>=0 && d<1)\r
{\r
- if(both) p = mglPoint(x->v(i,j,k-1)*(1-d)+x->v(i,j,k)*d,\r
- y->v(i,j,k-1)*(1-d)+y->v(i,j,k)*d,\r
- z->v(i,j,k-1)*(1-d)+z->v(i,j,k)*d);\r
- else p = mglPoint(x->v(i), y->v(j), z->v(k-1)*(1-d)+z->v(k)*d);\r
+ if(both) p = mglPoint(x->v(i,j,k-1)*(1-d)+p0.x*d,\r
+ y->v(i,j,k-1)*(1-d)+p0.y*d,\r
+ z->v(i,j,k-1)*(1-d)+p0.z*d);\r
+ else p = mglPoint(p0.x, p0.y, z->v(k-1)*(1-d)+p0.z*d);\r
u = mglPoint(i,j,k+d-1);\r
q = mgl_find_norm(both, x,y,z,a, u, inv,n,m,l);\r
pos = gr->AddPnt(p,c,q); u.c=pos;\r
delete []ky2; delete []kz;\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3_val(HMGL gr, float val, HCDT a, const char *sch, const char *opt)\r
+void mgl_surf3_val(HMGL gr, mreal val, HCDT a, const char *sch, const char *opt)\r
{\r
- if(a->GetNx()<2 || a->GetNy()<2 || a->GetNz()<2) { gr->SetWarn(mglWarnLow,"Surf3"); return; }\r
gr->SaveState(opt);\r
- mglData x(a->GetNx()), y(a->GetNy()),z(a->GetNz());\r
+ mglData x(a->GetNx()), y(a->GetNy()), z(a->GetNz());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_surf3_xyz_val(gr,val,&x,&y,&z,a,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_surf3_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long num = mgl_isnan(r)?3:long(r+0.5);\r
for(long i=0;i<num;i++)\r
{\r
- float v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
+ mreal v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
mgl_surf3_xyz_val(gr,v,x,y,z,a,sch,0);\r
}\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_surf3(HMGL gr, HCDT a, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
- long num = mgl_isnan(r)?3:long(r+0.5);\r
- for(long i=0;i<num;i++)\r
- {\r
- float v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
- mgl_surf3_val(gr,v,a,sch,0);\r
- }\r
+ gr->SaveState(opt);\r
+ mglData x(a->GetNx()), y(a->GetNy()), z(a->GetNz());\r
+ x.Fill(gr->Min.x,gr->Max.x);\r
+ y.Fill(gr->Min.y,gr->Max.y);\r
+ z.Fill(gr->Min.z,gr->Max.z);\r
+ mgl_surf3_xyz(gr,&x,&y,&z,a,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3_xyz_val_(uintptr_t *gr, float *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
+void mgl_surf3_xyz_val_(uintptr_t *gr, mreal *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_surf3_xyz_val(_GR_, *Val, _DA_(x), _DA_(y), _DA_(z), _DA_(a), s, o); delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3_val_(uintptr_t *gr, float *Val, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
+void mgl_surf3_val_(uintptr_t *gr, mreal *Val, uintptr_t *a, const char *sch, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_surf3_val(_GR_, *Val, _DA_(a), s, o); delete []o; delete []s; }\r
// Surf3A series\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3a_xyz_val(HMGL gr, float val, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *sch, const char *opt)\r
+void mgl_surf3a_xyz_val(HMGL gr, mreal val, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *sch, const char *opt)\r
{\r
long i,j,k,i1,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
long *kx1,*kx2,*ky1,*ky2,*kz;\r
- bool both, wire = sch && strchr(sch,'#');\r
- float d;\r
- if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,"Surf3A"); return; }\r
- both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim,"Surf3A"); return; }\r
- if(b->GetNx()*b->GetNy()*b->GetNz()!=n*m*l) { gr->SetWarn(mglWarnDim,"Surf3A"); return; }\r
+ bool both = mgl_isboth(x,y,z,a), wire = sch && strchr(sch,'#');\r
+ mreal d;\r
+ if(mgl_check_dim3(gr,both,x,y,z,a,b,"Surf3A")) return;\r
+\r
gr->SaveState(opt);\r
static int cgid=1; gr->StartGroup("Surf3A",cgid++);\r
\r
kx1 = new long[n*m]; kx2 = new long[n*m];\r
ky1 = new long[n*m]; ky2 = new long[n*m];\r
kz = new long[n*m];\r
- float c=gr->GetC(ss,val),aa;\r
+ mreal c=gr->GetC(ss,val),aa;\r
std::vector<mglPoint> kk;\r
kk.reserve(n*m*l);\r
\r
- mglPoint p,q,u;\r
- float a0,b0;\r
+ mglPoint p,q,u, p0;\r
+ mreal a0,b0;\r
for(k=0;k<l;k++)\r
{\r
memcpy(kx1,kx2,n*m*sizeof(long)); memset(kx2,-1,n*m*sizeof(long));\r
delete []ky2; delete []kz; return; }\r
i1 = i+n*j;\r
a0 = a->v(i,j,k); b0 = b->v(i,j,k);\r
+ p0 = both?mglPoint(x->v(i,j,k), y->v(i,j,k), z->v(i,j,k)) : mglPoint(x->v(i), y->v(j), z->v(k));\r
if(i<n-1)\r
{\r
d = mgl_d(val,a0,a->v(i+1,j,k));\r
if(d>=0 && d<1)\r
{\r
- if(both) p = mglPoint(x->v(i,j,k)*(1-d)+x->v(i+1,j,k)*d,\r
- y->v(i,j,k)*(1-d)+y->v(i+1,j,k)*d,\r
- z->v(i,j,k)*(1-d)+z->v(i+1,j,k)*d);\r
- else p = mglPoint(x->v(i)*(1-d)+x->v(i+1)*d, y->v(j), z->v(k));\r
+ if(both) p = mglPoint(p0.x*(1-d)+x->v(i+1,j,k)*d,\r
+ p0.y*(1-d)+y->v(i+1,j,k)*d,\r
+ p0.z*(1-d)+z->v(i+1,j,k)*d);\r
+ else p = mglPoint(p0.x*(1-d)+x->v(i+1)*d, p0.y, p0.z);\r
aa = gr->GetA(b0*(1-d)+b->v(i+1,j,k)*d);\r
u = mglPoint(i+d,j,k);\r
q = mgl_find_norm(both, x,y,z,a, u, inv,n,m,l);\r
d = mgl_d(val,a0,a->v(i,j+1,k));\r
if(d>=0 && d<1)\r
{\r
- if(both) p = mglPoint(x->v(i,j,k)*(1-d)+x->v(i,j+1,k)*d,\r
- y->v(i,j,k)*(1-d)+y->v(i,j+1,k)*d,\r
- z->v(i,j,k)*(1-d)+z->v(i,j+1,k)*d);\r
- else p = mglPoint(x->v(i), y->v(j)*(1-d)+y->v(j+1)*d, z->v(k));\r
+ if(both) p = mglPoint(p0.x*(1-d)+x->v(i,j+1,k)*d,\r
+ p0.y*(1-d)+y->v(i,j+1,k)*d,\r
+ p0.z*(1-d)+z->v(i,j+1,k)*d);\r
+ else p = mglPoint(p0.x, p0.y*(1-d)+y->v(j+1)*d, p0.z);\r
aa = gr->GetA(b0*(1-d)+b->v(i,j+1,k)*d);\r
u = mglPoint(i,j+d,k);\r
q = mgl_find_norm(both, x,y,z,a, u, inv,n,m,l);\r
d = mgl_d(val,a->v(i,j,k-1),a0);\r
if(d>=0 && d<1)\r
{\r
- if(both) p = mglPoint(x->v(i,j,k-1)*(1-d)+x->v(i,j,k)*d,\r
- y->v(i,j,k-1)*(1-d)+y->v(i,j,k)*d,\r
- z->v(i,j,k-1)*(1-d)+z->v(i,j,k)*d);\r
- else p = mglPoint(x->v(i), y->v(j), z->v(k-1)*(1-d)+z->v(k)*d);\r
+ if(both) p = mglPoint(x->v(i,j,k-1)*(1-d)+p0.x*d,\r
+ y->v(i,j,k-1)*(1-d)+p0.y*d,\r
+ z->v(i,j,k-1)*(1-d)+p0.z*d);\r
+ else p = mglPoint(p0.x, p0.y, z->v(k-1)*(1-d)+p0.z*d);\r
aa = gr->GetA(b->v(i,j,k-1)*(1-d)+b0*d);\r
u = mglPoint(i,j,k+d-1);\r
q = mgl_find_norm(both, x,y,z,a, u, inv,n,m,l);\r
delete []ky2; delete []kz;\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3a_val(HMGL gr, float val, HCDT a, HCDT b, const char *sch, const char *opt)\r
+void mgl_surf3a_val(HMGL gr, mreal val, HCDT a, HCDT b, const char *sch, const char *opt)\r
{\r
- if(a->GetNx()<2 || a->GetNy()<2 || a->GetNz()<2)\r
- { gr->SetWarn(mglWarnLow,"Surf3A"); return; }\r
gr->SaveState(opt);\r
mglData x(a->GetNx()), y(a->GetNy()),z(a->GetNz());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_surf3a_xyz_val(gr,val,&x,&y,&z,a,b,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_surf3a_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long num = mgl_isnan(r)?3:long(r+0.5);\r
if(b->GetNx()==num && b->GetNy()==1 && b->GetNz()==1)\r
{\r
- float v,a0=gr->AlphaDef;\r
+ mreal v,a0=gr->AlphaDef;\r
for(long i=0;i<num;i++)\r
{\r
v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
}\r
else for(long i=0;i<num;i++)\r
{\r
- float v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
+ mreal v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
mgl_surf3a_xyz_val(gr,v,x,y,z,a,b,sch,0);\r
}\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_surf3a(HMGL gr, HCDT a, HCDT b, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
- long num = mgl_isnan(r)?3:long(r);\r
- if(b->GetNx()==num && b->GetNy()==1 && b->GetNz()==1)\r
- {\r
- float v,a0=gr->AlphaDef;\r
- for(long i=0;i<num;i++)\r
- {\r
- v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
- gr->AlphaDef = b->v(i);\r
- mgl_surf3_val(gr,v,a,sch,0);\r
- }\r
- gr->AlphaDef = a0;\r
- }\r
- else for(long i=0;i<num;i++)\r
- {\r
- float v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
- mgl_surf3a_val(gr,v,a,b,sch,0);\r
- }\r
+ gr->SaveState(opt);\r
+ mglData x(a->GetNx()), y(a->GetNy()),z(a->GetNz());\r
+ x.Fill(gr->Min.x,gr->Max.x);\r
+ y.Fill(gr->Min.y,gr->Max.y);\r
+ z.Fill(gr->Min.z,gr->Max.z);\r
+ mgl_surf3a_xyz(gr,&x,&y,&z,a,b,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3a_xyz_val_(uintptr_t *gr, float *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
+void mgl_surf3a_xyz_val_(uintptr_t *gr, mreal *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_surf3a_xyz_val(_GR_, *Val, _DA_(x), _DA_(y), _DA_(z), _DA_(a), _DA_(b), s, o);\r
delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3a_val_(uintptr_t *gr, float *Val, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
+void mgl_surf3a_val_(uintptr_t *gr, mreal *Val, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_surf3a_val(_GR_, *Val, _DA_(a), _DA_(b), s, o); delete []o; delete []s; }\r
// Surf3C series\r
//\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3c_xyz_val(HMGL gr, float val, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *sch, const char *opt)\r
+void mgl_surf3c_xyz_val(HMGL gr, mreal val, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *sch, const char *opt)\r
{\r
long i,j,k,i1,n=a->GetNx(),m=a->GetNy(),l=a->GetNz();\r
long *kx1,*kx2,*ky1,*ky2,*kz;\r
- bool both, wire = sch && strchr(sch,'#');\r
- float d;\r
- if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,"Surf3A"); return; }\r
- both = x->GetNx()*x->GetNy()*x->GetNz()==n*m*l && y->GetNx()*y->GetNy()*y->GetNz()==n*m*l && z->GetNx()*z->GetNy()*z->GetNz()==n*m*l;\r
- if(!(both || (x->GetNx()==n && y->GetNx()==m && z->GetNx()==l)))\r
- { gr->SetWarn(mglWarnDim,"Surf3A"); return; }\r
- if(b->GetNx()*b->GetNy()*b->GetNz()!=n*m*l) { gr->SetWarn(mglWarnDim,"Surf3A"); return; }\r
+ bool both = mgl_isboth(x,y,z,a), wire = sch && strchr(sch,'#');\r
+ mreal d;\r
+ if(mgl_check_dim3(gr,both,x,y,z,a,b,"Surf3C")) return;\r
+\r
gr->SaveState(opt);\r
- static int cgid=1; gr->StartGroup("Surf3A",cgid++);\r
+ static int cgid=1; gr->StartGroup("Surf3C",cgid++);\r
\r
bool inv = (sch && strchr(sch,'-'));\r
long ss = gr->AddTexture(sch), pos;\r
kx1 = new long[n*m]; kx2 = new long[n*m];\r
ky1 = new long[n*m]; ky2 = new long[n*m];\r
kz = new long[n*m];\r
- float c;\r
+ mreal c;\r
std::vector<mglPoint> kk;\r
kk.reserve(n*m*l);\r
\r
- mglPoint p,q,u;\r
- float a0,b0;\r
+ mglPoint p,q,u, p0;\r
+ mreal a0,b0;\r
for(k=0;k<l;k++)\r
{\r
memcpy(kx1,kx2,n*m*sizeof(long)); memset(kx2,-1,n*m*sizeof(long));\r
delete []ky2; delete []kz; return; }\r
i1 = i+n*j;\r
a0 = a->v(i,j,k); b0 = b->v(i,j,k);\r
+ p0 = both?mglPoint(x->v(i,j,k), y->v(i,j,k), z->v(i,j,k)) : mglPoint(x->v(i), y->v(j), z->v(k));\r
if(i<n-1)\r
{\r
d = mgl_d(val,a0,a->v(i+1,j,k));\r
if(d>=0 && d<1)\r
{\r
- if(both) p = mglPoint(x->v(i,j,k)*(1-d)+x->v(i+1,j,k)*d,\r
- y->v(i,j,k)*(1-d)+y->v(i+1,j,k)*d,\r
- z->v(i,j,k)*(1-d)+z->v(i+1,j,k)*d);\r
- else p = mglPoint(x->v(i)*(1-d)+x->v(i+1)*d, y->v(j), z->v(k));\r
+ if(both) p = mglPoint(p0.x*(1-d)+x->v(i+1,j,k)*d,\r
+ p0.y*(1-d)+y->v(i+1,j,k)*d,\r
+ p0.z*(1-d)+z->v(i+1,j,k)*d);\r
+ else p = mglPoint(p0.x*(1-d)+x->v(i+1)*d, p0.y, p0.z);\r
c = gr->GetC(ss,b0*(1-d)+b->v(i+1,j,k)*d);\r
u = mglPoint(i+d,j,k);\r
q = mgl_find_norm(both, x,y,z,a, u, inv,n,m,l);\r
d = mgl_d(val,a0,a->v(i,j+1,k));\r
if(d>=0 && d<1)\r
{\r
- if(both) p = mglPoint(x->v(i,j,k)*(1-d)+x->v(i,j+1,k)*d,\r
- y->v(i,j,k)*(1-d)+y->v(i,j+1,k)*d,\r
- z->v(i,j,k)*(1-d)+z->v(i,j+1,k)*d);\r
- else p = mglPoint(x->v(i), y->v(j)*(1-d)+y->v(j+1)*d, z->v(k));\r
+ if(both) p = mglPoint(p0.x*(1-d)+x->v(i,j+1,k)*d,\r
+ p0.y*(1-d)+y->v(i,j+1,k)*d,\r
+ p0.z*(1-d)+z->v(i,j+1,k)*d);\r
+ else p = mglPoint(p0.x, p0.y*(1-d)+y->v(j+1)*d, p0.z);\r
c = gr->GetC(ss,b0*(1-d)+b->v(i,j+1,k)*d);\r
u = mglPoint(i,j+d,k);\r
q = mgl_find_norm(both, x,y,z,a, u, inv,n,m,l);\r
d = mgl_d(val,a->v(i,j,k-1),a0);\r
if(d>=0 && d<1)\r
{\r
- if(both) p = mglPoint(x->v(i,j,k-1)*(1-d)+x->v(i,j,k)*d,\r
- y->v(i,j,k-1)*(1-d)+y->v(i,j,k)*d,\r
- z->v(i,j,k-1)*(1-d)+z->v(i,j,k)*d);\r
- else p = mglPoint(x->v(i), y->v(j), z->v(k-1)*(1-d)+z->v(k)*d);\r
+ if(both) p = mglPoint(x->v(i,j,k-1)*(1-d)+p0.x*d,\r
+ y->v(i,j,k-1)*(1-d)+p0.y*d,\r
+ z->v(i,j,k-1)*(1-d)+p0.z*d);\r
+ else p = mglPoint(p0.x, p0.y, z->v(k-1)*(1-d)+p0.z*d);\r
c = gr->GetC(ss,b->v(i,j,k-1)*(1-d)+b0*d);\r
u = mglPoint(i,j,k+d-1);\r
q = mgl_find_norm(both, x,y,z,a, u, inv,n,m,l);\r
delete []ky2; delete []kz;\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3c_val(HMGL gr, float val, HCDT a, HCDT b, const char *sch, const char *opt)\r
+void mgl_surf3c_val(HMGL gr, mreal val, HCDT a, HCDT b, const char *sch, const char *opt)\r
{\r
- if(a->GetNx()<2 || a->GetNy()<2 || a->GetNz()<2) { gr->SetWarn(mglWarnLow,"Surf3C"); return; }\r
gr->SaveState(opt);\r
mglData x(a->GetNx()), y(a->GetNy()),z(a->GetNz());\r
x.Fill(gr->Min.x,gr->Max.x);\r
y.Fill(gr->Min.y,gr->Max.y);\r
z.Fill(gr->Min.z,gr->Max.z);\r
mgl_surf3c_xyz_val(gr,val,&x,&y,&z,a,b,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_surf3c_xyz(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT a, HCDT b, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
+ mreal r = gr->SaveState(opt);\r
long num = mgl_isnan(r)?3:long(r+0.5);\r
for(long i=0;i<num;i++)\r
{\r
- float v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
+ mreal v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
mgl_surf3c_xyz_val(gr,v,x,y,z,a,b,sch,0);\r
}\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
void mgl_surf3c(HMGL gr, HCDT a, HCDT b, const char *sch, const char *opt)\r
{\r
- float r = gr->SaveState(opt);\r
- long num = mgl_isnan(r)?3:long(r+0.5);\r
- for(long i=0;i<num;i++)\r
- {\r
- float v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
- mgl_surf3c_val(gr,v,a,b,sch,0);\r
- }\r
+ gr->SaveState(opt);\r
+ mglData x(a->GetNx()), y(a->GetNy()),z(a->GetNz());\r
+ x.Fill(gr->Min.x,gr->Max.x);\r
+ y.Fill(gr->Min.y,gr->Max.y);\r
+ z.Fill(gr->Min.z,gr->Max.z);\r
+ mgl_surf3c_xyz(gr,&x,&y,&z,a,b,sch,0);\r
+ gr->LoadState();\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3c_xyz_val_(uintptr_t *gr, float *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
+void mgl_surf3c_xyz_val_(uintptr_t *gr, mreal *Val, uintptr_t *x, uintptr_t *y, uintptr_t *z, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_surf3c_xyz_val(_GR_, *Val, _DA_(x), _DA_(y), _DA_(z), _DA_(a), _DA_(b), s, o);\r
delete []o; delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_surf3c_val_(uintptr_t *gr, float *Val, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
+void mgl_surf3c_val_(uintptr_t *gr, mreal *Val, uintptr_t *a, uintptr_t *b, const char *sch, const char *opt,int l,int lo)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
char *o=new char[lo+1]; memcpy(o,opt,lo); o[lo]=0;\r
mgl_surf3c_val(_GR_, *Val, _DA_(a), _DA_(b), s, o); delete []o; delete []s; }\r
// flag & 0x1 -- accompanied coordinates\r
// flag & 0x2 -- project to r*z\r
// flag & 0x4 -- normalize field\r
-void mgl_beam_val(HMGL gr, float val, HCDT tr, HCDT g1, HCDT g2, HCDT a, float r, const char *stl, int flag)\r
+void mgl_beam_md(HMGL gr, mreal val, const mglData *tr, const mglData *g1, const mglData *g2, const mglData *a, mreal r, const char *stl, int flag)\r
{\r
+ long n = a->nz,m=a->nx,l=a->ny;\r
+ if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,"Beam"); return; }\r
+ if(a->Minimal()<0) { gr->SetWarn(mglWarnNeg,"Beam"); return; }\r
+ if(tr->nx<3 || tr->ny<n || g1->nx<3 || g1->ny<n || g2->nx<3 || g2->ny<n)\r
+ { gr->SetWarn(mglWarnDim,"Beam"); return; }\r
+ mglData x(a),y(a),z(a),b(a);\r
+ register long i,j,k,i0;\r
+ mreal asum=1, asum0=1, amax, aa;\r
+ r = fabs(r);\r
+ if(flag & 4) for(j=0;j<m*l;j++) asum0 += a->a[j]*a->a[j];\r
+ if(asum0==0) { gr->SetWarn(mglWarnZero,"Beam"); return; }\r
+ for(i=0;i<n;i++)\r
+ {\r
+ asum=amax=0;\r
+ if(flag & 4)\r
+ {\r
+ for(j=0;j<m*l;j++)\r
+ {\r
+ aa = a->a[j+m*l*i];\r
+ asum += aa*aa;\r
+ amax = amax>aa ? amax : aa;\r
+ }\r
+ if(amax==0) { asum=0; amax=1; }\r
+ for(j=0;j<m*l;j++) b.a[j+m*l*i] = b.a[j+m*l*i]*sqrt(asum/asum0)/amax;\r
+ }\r
+ for(j=0;j<m;j++) for(k=0;k<l;k++)\r
+ {\r
+ if(gr->Stop) return;\r
+ i0 = j+m*(k+l*i);\r
+ if(flag & 1)\r
+ {\r
+ x.a[i0] = 2*j/(m-1.)-1;\r
+ y.a[i0] = 2*k/(l-1.)-1;\r
+ z.a[i0] = gr->Max.z*i/(n-1.);\r
+ }\r
+ else\r
+ {\r
+ x.a[i0] = tr->a[3*i] + g1->a[3*i]*(2*j/(m-1.)-1)*r + g2->a[3*i]*(2*k/(l-1.)-1)*r;\r
+ y.a[i0] = tr->a[3*i+1] + g1->a[3*i+1]*(2*j/(m-1.)-1)*r + g2->a[3*i+1]*(2*k/(l-1.)-1)*r;\r
+ z.a[i0] = tr->a[3*i+2] + g1->a[3*i+2]*(2*j/(m-1.)-1)*r + g2->a[3*i+2]*(2*k/(l-1.)-1)*r;\r
+ }\r
+ if(flag & 2) x.a[i0] = hypot(x.a[i0],y.a[i0]);\r
+ }\r
+ }\r
+ mgl_surf3_xyz_val(gr,val,&x,&y,&z,&b,stl,0);\r
+}\r
+//-----------------------------------------------------------------------------\r
+void mgl_beam_val(HMGL gr, mreal val, HCDT tr, HCDT g1, HCDT g2, HCDT a, mreal r, const char *stl, int flag)\r
+{\r
+\r
+ const mglData *dtr=dynamic_cast<const mglData *>(tr);\r
+ const mglData *dg2=dynamic_cast<const mglData *>(g1);\r
+ const mglData *dg1=dynamic_cast<const mglData *>(g2);\r
+ const mglData *da=dynamic_cast<const mglData *>(a);\r
+ if(dtr&&dg1&&dg2&&da)\r
+ { mgl_beam_md(gr,val,dtr,dg1,dg2,da,r,stl,flag); return; }\r
+\r
long n = a->GetNz(),m=a->GetNx(),l=a->GetNy();\r
- if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow); return; }\r
- if(a->Minimal()<0) { gr->SetWarn(mglWarnNeg); return; }\r
+ if(n<2 || m<2 || l<2) { gr->SetWarn(mglWarnLow,"Beam"); return; }\r
+ if(a->Minimal()<0) { gr->SetWarn(mglWarnNeg,"Beam"); return; }\r
if(tr->GetNx()<3 || tr->GetNy()<n || g1->GetNx()<3 || g1->GetNy()<n || g2->GetNx()<3 || g2->GetNy()<n)\r
{ gr->SetWarn(mglWarnDim,"Beam"); return; }\r
mglData x(a),y(a),z(a),b(a);\r
register long i,j,k,i0;\r
- float asum=1, asum0=1, amax, aa;\r
+ mreal asum=1, asum0=1, amax, aa;\r
r = fabs(r);\r
if(flag & 4) for(j=0;j<m*l;j++) asum0 += a->vthr(j)*a->vthr(j);\r
if(asum0==0) { gr->SetWarn(mglWarnZero,"Beam"); return; }\r
mgl_surf3_xyz_val(gr,val,&x,&y,&z,&b,stl,0);\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_beam(HMGL gr, HCDT tr, HCDT g1, HCDT g2, HCDT a, float r, const char *stl, int flag, int num)\r
+void mgl_beam(HMGL gr, HCDT tr, HCDT g1, HCDT g2, HCDT a, mreal r, const char *stl, int flag, int num)\r
{\r
num = num<=0 ? 1 : num;\r
for(long i=0;i<num;i++)\r
{\r
- float v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
+ mreal v = gr->Max.c + (gr->Min.c-gr->Max.c)*(i+1.)/(num+1);\r
mgl_beam_val(gr,v,tr,g1,g2,a,r,stl,flag);\r
}\r
}\r
//-----------------------------------------------------------------------------\r
-void mgl_beam_val_(uintptr_t *gr, float *val, uintptr_t *tr, uintptr_t *g1, uintptr_t *g2, uintptr_t *a, float *r, const char *sch, int *norm,int l)\r
+void mgl_beam_val_(uintptr_t *gr, mreal *val, uintptr_t *tr, uintptr_t *g1, uintptr_t *g2, uintptr_t *a, mreal *r, const char *sch, int *norm,int l)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
mgl_beam_val(_GR_, *val,_DA_(tr),_DA_(g1),_DA_(g2),_DA_(a),*r,s,*norm); delete []s; }\r
//-----------------------------------------------------------------------------\r
-void mgl_beam_(uintptr_t *gr, uintptr_t *tr, uintptr_t *g1, uintptr_t *g2, uintptr_t *a, float *r, const char *sch, int *norm, int *num,int l)\r
+void mgl_beam_(uintptr_t *gr, uintptr_t *tr, uintptr_t *g1, uintptr_t *g2, uintptr_t *a, mreal *r, const char *sch, int *norm, int *num,int l)\r
{ char *s=new char[l+1]; memcpy(s,sch,l); s[l]=0;\r
mgl_beam(_GR_, _DA_(tr), _DA_(g1), _DA_(g2), _DA_(a), *r,s,*norm,*num); delete []s; }\r
//-----------------------------------------------------------------------------\r
-
-# Warning!!!!!
-# new files and destination for html docs.
-
if(MGL_HAVE_DOC)
- set(MGL_PNG alpha.png area.png aspect.png axial.png axis.png barh.png bars.png belt.png boxplot.png
- box.png boxs.png candle.png chart.png cloud.png colorbar.png combined.png cones.png conta.png contd.png
- contfa.png contf.png contf_xyz.png cont.png contv.png cont_xyz.png curvcoor.png cut.png dat_diff.png
- dat_extra.png densa.png dens.png dens_xyz.png dew.png dots.png error.png fall.png fit.png flow.png
- fog.png grad.png hist.png inplot.png label.png legend.png loglog.png map.png mark.png mesh.png mirror.png
- molecule.png parser.png pde.png pipe.png plot.png primitives.png qo2d.png radar.png region.png schemes.png
- several_light.png stem.png step.png stereo.png stfa.png style.png surf3a.png surf3c.png surf3.png
- surfa.png surfc.png surf.png tape.png tens.png ternary.png textmark.png text.png ticks.png tile.png
- tiles.png torus.png traj.png triplot.png tube.png type0.png type1.png type2.png vect.png venn.png)
+ set(MGL_PNG alpha area aspect axial axis barh bars belt boxplot
+ box boxs candle chart cloud colorbar combined cones conta contd
+ contfa contf contf_xyz cont contv cont_xyz curvcoor cut dat_diff
+ dat_extra densa dens dens_xyz dew dots error fall fit flow
+ fog grad hist inplot label legend loglog map mark mesh mirror
+ molecule parser pde pipe plot primitives qo2d radar region schemes
+ several_light stem step stereo stfa style surf3a surf3c surf3
+ surfa surfc surf tape tens ternary textmark text ticks tile
+ tiles torus traj triangulation triplot tube type0 type1 type2 vect venn )
+ set(MGL_PNG_N )
+ set(MGL_PNG_S )
-# foreach(SAMPLE ${MGL_PNG})
-# add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/texinfo/png/${SAMPLE}
-# COMMAND ${CMAKE_BINARY_DIR}/examples/mgl_example --kind=${SAMPLE}
-# WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/texinfo/png )
-# endforeach(SAMPLE)
+ set(MGL_OUT ${CMAKE_BINARY_DIR}/texinfo)
+ set(MGL_TEX ${CMAKE_SOURCE_DIR}/texinfo)
+ file(MAKE_DIRECTORY ${MGL_OUT}/png)
+ file(MAKE_DIRECTORY ${MGL_OUT}/small)
+ file(COPY ${MGL_TEX}/qt.png ${MGL_TEX}/fltk.png ${MGL_TEX}/classes.png DESTINATION ${MGL_OUT})
+ file(COPY ${MGL_TEX}/toc_ru.html ${MGL_TEX}/toc_fr.html ${MGL_TEX}/toc_en.html ${MGL_TEX}/title.html ${MGL_TEX}/index.html DESTINATION ${MGL_OUT})
+
+ foreach(SAMPLE ${MGL_PNG})
+ set(MGL_PNG_N ${MGL_PNG_N} ${MGL_OUT}/png/${SAMPLE}.png)
+ add_custom_command(OUTPUT ${MGL_OUT}/png/${SAMPLE}.png
+ COMMAND ${CMAKE_BINARY_DIR}/examples/mgl_example -kind=${SAMPLE}
+ DEPENDS mgl_example
+ WORKING_DIRECTORY ${MGL_OUT}/png )
+ set(MGL_PNG_S ${MGL_PNG_S} ${MGL_OUT}/small/${SAMPLE}-sm.png)
+ add_custom_command(OUTPUT ${MGL_OUT}/small/${SAMPLE}-sm.png
+ COMMAND ${CMAKE_BINARY_DIR}/examples/mgl_example -kind=${SAMPLE} -mini
+ DEPENDS mgl_example
+ WORKING_DIRECTORY ${MGL_OUT}/small )
+ endforeach(SAMPLE)
- add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/texinfo/png/all.png
- COMMAND ${CMAKE_BINARY_DIR}/examples/mgl_example
- COMMAND touch ${CMAKE_SOURCE_DIR}/texinfo/png/all.png
- WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/texinfo/png
- )
- add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/texinfo/small/all.png
- COMMAND ${CMAKE_BINARY_DIR}/examples/mgl_example -mini
- COMMAND touch ${CMAKE_SOURCE_DIR}/texinfo/small/all.png
- WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/texinfo/small
- )
-# set_source_files_properties(${CMAKE_BINARY_DIR}/examples/mgl_example PROPERTIES GENERATED 1)
-# ADD_CUSTOM_TARGET(gen_all_png DEPENDS ${CMAKE_SOURCE_DIR}/texinfo/png/all.png)
-# ADD_DEPENDENCIES(gen_all_png mgl_example)
set(list_texi_files_en mathgl_en.texi mgl_en.texi overview_en.texi example_en.texi ex_mgl_en.texi parse_en.texi
core_en.texi concept_en.texi widget_en.texi data_en.texi other_en.texi appendix_en.texi fdl.texi)
set(list_texi_files_ru mathgl_ru.texi mgl_ru.texi overview_ru.texi example_ru.texi ex_mgl_ru.texi parse_ru.texi
core_ru.texi concept_ru.texi widget_ru.texi data_ru.texi other_ru.texi appendix_ru.texi fdl.texi)
- add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/texinfo/web_en.pdf
- COMMAND ${findtp} -I ${CMAKE_SOURCE_DIR}/texinfo/png web_en.texi
- COMMAND ${findth} -I=${CMAKE_SOURCE_DIR}/texinfo/png --split=section web_en.texi -o web_en
- DEPENDS ${CMAKE_SOURCE_DIR}/texinfo/small/all.png web_en.texi
- WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/texinfo
- )
+ add_custom_command(OUTPUT ${MGL_OUT}/web_en.pdf
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/web_en.texi
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/web_en.texi
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/web_en.texi
+ DEPENDS web_en.texi ${MGL_PNG_S}
+ WORKING_DIRECTORY ${MGL_OUT}
+ )
+ add_custom_command(OUTPUT ${MGL_OUT}/web_en/web_en.html
+ COMMAND ${findth} -I=${MGL_OUT}/png --split=section -o web_en ${MGL_TEX}/web_en.texi
+ DEPENDS web_en.texi ${MGL_PNG_S}
+ WORKING_DIRECTORY ${MGL_OUT}
+ )
- add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/texinfo/mathgl_en.info
- COMMAND ${findth} -I=${CMAKE_SOURCE_DIR}/texinfo/png --split=section mathgl_en.texi -o mathgl_en
- COMMAND ${findth} -I=${CMAKE_SOURCE_DIR}/texinfo/png --split=node --frames -o doc_en mathgl_en.texi
- COMMAND ${findth} -I=${CMAKE_SOURCE_DIR}/texinfo/png --split=no mgl_en.texi -o mgl_en.html
- COMMAND ${findmi} --no-validate mathgl_en.texi
- DEPENDS ${CMAKE_SOURCE_DIR}/texinfo/png/all.png
- DEPENDS ${list_texi_files_en}
- WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/texinfo
+ add_custom_command(OUTPUT ${MGL_OUT}/mathgl_en.info
+ COMMAND ${findmi} --no-validate ${MGL_TEX}/mathgl_en.texi
+ DEPENDS ${list_texi_files_en} ${MGL_PNG_N}
+ WORKING_DIRECTORY ${MGL_OUT}
)
- add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/texinfo/mathgl_ru.info
- COMMAND ${findth} -I=${CMAKE_SOURCE_DIR}/texinfo/png --split=section mathgl_ru.texi -o mathgl_ru
- COMMAND ${findth} -I=${CMAKE_SOURCE_DIR}/texinfo/png --split=node --frames -o doc_ru mathgl_ru.texi
- COMMAND ${findth} -I=${CMAKE_SOURCE_DIR}/texinfo/png --split=no mgl_ru.texi -o mgl_ru.html
- COMMAND ${findmi} --no-validate mathgl_ru.texi
- DEPENDS ${CMAKE_SOURCE_DIR}/texinfo/png/all.png
- DEPENDS ${list_texi_files_ru}
- WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/texinfo
+ add_custom_command(OUTPUT ${MGL_OUT}/mathgl_en/mathgl_en.html
+ COMMAND ${findth} -I=${MGL_OUT}/png --split=section -o mathgl_en ${MGL_TEX}/mathgl_en.texi
+ DEPENDS ${list_texi_files_en} ${MGL_PNG_N}
+ WORKING_DIRECTORY ${MGL_OUT}
)
- add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/texinfo/mathgl_en.pdf
- COMMAND ${findtp} -I ${CMAKE_SOURCE_DIR}/texinfo/png mathgl_en.texi
- COMMAND ${findtp} -I ${CMAKE_SOURCE_DIR}/texinfo/png mathgl_en.texi
- COMMAND ${findtp} -I ${CMAKE_SOURCE_DIR}/texinfo/png mathgl_en.texi
- DEPENDS ${CMAKE_SOURCE_DIR}/texinfo/png/all.png
- DEPENDS ${list_texi_files_en}
-# DEPENDS ${list_texi_files_ru}
- WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/texinfo
+ add_custom_command(OUTPUT ${MGL_OUT}/doc_en/doc_en.html
+ COMMAND ${findth} -I=${MGL_OUT}/png --split=node --frames -o doc_en ${MGL_TEX}/doc_en.texi
+ DEPENDS ${list_texi_files_en} ${MGL_PNG_N}
+ WORKING_DIRECTORY ${MGL_OUT}
)
- add_custom_target(documentation ALL
- DEPENDS ${CMAKE_SOURCE_DIR}/texinfo/mathgl_en.info
- DEPENDS ${CMAKE_SOURCE_DIR}/texinfo/mathgl_en.pdf
- DEPENDS ${CMAKE_SOURCE_DIR}/texinfo/web_en.pdf
-# DEPENDS ${CMAKE_SOURCE_DIR}/texinfo/mathgl_ru.info
-# DEPENDS ${CMAKE_SOURCE_DIR}/texinfo/mathgl_ru.pdf
+ add_custom_command(OUTPUT ${MGL_OUT}/mgl_en.html
+ COMMAND ${findth} -I=${MGL_OUT}/png --split=no -o mgl_en.html ${MGL_TEX}/mgl_en.texi
+ DEPENDS ${list_texi_files_en} ${MGL_PNG_N}
+ WORKING_DIRECTORY ${MGL_OUT}
+ )
+
+ add_custom_command(OUTPUT ${MGL_OUT}/mathgl_en.pdf
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/mathgl_en.texi
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/mathgl_en.texi
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/mathgl_en.texi
+ DEPENDS ${list_texi_files_en} ${MGL_PNG_N}
+ WORKING_DIRECTORY ${MGL_OUT}
+ )
+
+ add_custom_command(OUTPUT ${MGL_OUT}/web_ru.pdf
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/web_ru.texi
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/web_ru.texi
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/web_ru.texi
+ DEPENDS web_ru.texi ${MGL_PNG_S}
+ WORKING_DIRECTORY ${MGL_OUT}
+ )
+ add_custom_command(OUTPUT ${MGL_OUT}/web_ru/web_ru.html
+ COMMAND ${findth} -I=${MGL_OUT}/png --split=section -o web_ru ${MGL_TEX}/web_ru.texi
+ DEPENDS web_ru.texi ${MGL_PNG_S}
+ WORKING_DIRECTORY ${MGL_OUT}
)
- add_custom_target(clean
- COMMAND rm -f mathgl*.[hali]* mathgl*.?? mathgl_*/* *~ #png/*.png
- WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/texinfo
+
+ add_custom_command(OUTPUT ${MGL_OUT}/mathgl_ru.info
+ COMMAND ${findmi} --no-validate ${MGL_TEX}/mathgl_ru.texi
+ DEPENDS ${list_texi_files_ru} ${MGL_PNG_N}
+ WORKING_DIRECTORY ${MGL_OUT}
+ )
+ add_custom_command(OUTPUT ${MGL_OUT}/mathgl_ru/mathgl_ru.html
+ COMMAND ${findth} -I=${MGL_OUT}/png --split=section -o mathgl_ru ${MGL_TEX}/mathgl_ru.texi
+ DEPENDS ${list_texi_files_ru} ${MGL_PNG_N}
+ WORKING_DIRECTORY ${MGL_OUT}
+ )
+ add_custom_command(OUTPUT ${MGL_OUT}/doc_ru/doc_ru.html
+ COMMAND ${findth} -I=${MGL_OUT}/png --split=node --frames -o doc_ru ${MGL_TEX}/doc_ru.texi
+ DEPENDS ${list_texi_files_ru} ${MGL_PNG_N}
+ WORKING_DIRECTORY ${MGL_OUT}
+ )
+ add_custom_command(OUTPUT ${MGL_OUT}/mgl_ru.html
+ COMMAND ${findth} -I=${MGL_OUT}/png --split=no -o mgl_ru.html ${MGL_TEX}/mgl_ru.texi
+ DEPENDS ${list_texi_files_ru} ${MGL_PNG_N}
+ WORKING_DIRECTORY ${MGL_OUT}
+ )
+
+ add_custom_command(OUTPUT ${MGL_OUT}/mathgl_ru.pdf
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/mathgl_ru.texi
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/mathgl_ru.texi
+ COMMAND ${findtp} -I ${MGL_OUT}/png ${MGL_TEX}/mathgl_ru.texi
+ DEPENDS ${list_texi_files_ru} ${MGL_PNG_N}
+ WORKING_DIRECTORY ${MGL_OUT}
+ )
+
+ add_custom_target(documentation ALL
+ DEPENDS ${MGL_OUT}/mathgl_en.info
+ DEPENDS ${MGL_OUT}/mathgl_en.pdf
+ DEPENDS ${MGL_OUT}/mgl_en.html
+ DEPENDS ${MGL_OUT}/mathgl_en/mathgl_en.html
+
+ DEPENDS ${MGL_OUT}/doc_en/doc_en.html
+ DEPENDS ${MGL_OUT}/web_en/web_en.html
+
+# DEPENDS ${MGL_OUT}/mathgl_ru.info
+# DEPENDS ${MGL_OUT}/mathgl_ru.pdf
+ DEPENDS ${MGL_OUT}/mgl_ru.html
+ DEPENDS ${MGL_OUT}/mathgl_ru/mathgl_ru.html
+
+# DEPENDS ${MGL_OUT}/doc_ru/doc_ru.html
+# DEPENDS ${MGL_OUT}/web_ru/web_ru.html
)
- install(DIRECTORY ./ DESTINATION ${MGL_DOC_PATH}
- FILES_MATCHING PATTERN ".svn" EXCLUDE
- PATTERN "CMakeFiles" EXCLUDE
- PATTERN "*.png"
- PATTERN "*.html"
- PATTERN "*/*.html"
- PATTERN "./mathgl*.info*"
- PATTERN "./mathgl*.pdf")
- install(DIRECTORY ./ DESTINATION ${MGL_MAN_PATH}/man1
- FILES_MATCHING PATTERN ".svn" EXCLUDE
- PATTERN "CMakeFiles" EXCLUDE
- PATTERN "*_en" EXCLUDE
- PATTERN "png" EXCLUDE
- PATTERN "small" EXCLUDE
- PATTERN "*.1")
- install(DIRECTORY ./ DESTINATION ${MGL_MAN_PATH}/man5
- FILES_MATCHING PATTERN ".svn" EXCLUDE
- PATTERN "CMakeFiles" EXCLUDE
- PATTERN "*_en" EXCLUDE
- PATTERN "png" EXCLUDE
- PATTERN "small" EXCLUDE
- PATTERN "*.5")
+# add_custom_target(clean
+# COMMAND rm -f * */*
+# WORKING_DIRECTORY ${MGL_OUT}
+# )
+ set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "doc_en;mathgl_en;web_en;./mathgl*.*;small/*.*;png/*.*")
+ install(FILES ${MGL_TEX}/qt.png ${MGL_TEX}/fltk.png ${MGL_TEX}/classes.png DESTINATION ${MGL_DOC_PATH})
+ install(FILES ${MGL_OUT}/mathgl_en.pdf ${MGL_OUT}/mgl_en.html DESTINATION ${MGL_DOC_PATH})
+ install(DIRECTORY ${MGL_OUT}/mathgl_en DESTINATION ${MGL_DOC_PATH})
+ install(DIRECTORY ${MGL_OUT}/png DESTINATION ${MGL_DOC_PATH})
+ install(FILES ${MGL_TEX}/mglconv.1 ${MGL_TEX}/mglview.1 DESTINATION ${MGL_MAN_PATH}/man1)
+ install(FILES ${MGL_TEX}/mgl.5 DESTINATION ${MGL_MAN_PATH}/man5)
+# TODO: try to install all mathgl*.info* in future!!!
+ install(FILES ${MGL_OUT}/mathgl_en.info ${MGL_OUT}/mathgl_en.info-1 ${MGL_OUT}/mathgl_en.info-2 DESTINATION ${MGL_INFO_PATH})
endif(MGL_HAVE_DOC)
@item
@strong{All functions have ``simplified'' and ``advanced'' forms.} It is done for user's convenience. One needs to specify only one data array in the ``simplified'' form in order to see the result. But one may set parametric dependence of coordinates and produce rather complex curves and surfaces in the ``advanced'' form. In both cases the order of function arguments is the same: first data arrays, second the string with style, and later string with options for additional plot tuning.
@item
-@strong{All data arrays for plotting are encapsulated in mglData(A) class.} This reduces the number of errors while working with memory and provides a uniform interface for data of different types (float, double and so on) or for formula plotting.
+@strong{All data arrays for plotting are encapsulated in mglData(A) class.} This reduces the number of errors while working with memory and provides a uniform interface for data of different types (mreal, double and so on) or for formula plotting.
@item
@strong{All plots are vector plots.} The MathGL library is intended for handling scientific data which have vector nature (lines, faces, matrices and so on). As a result, vector representation is used in all cases! In addition, the vector representation allows one to scale the plot easily -- change the canvas size by a factor of 2, and the picture will be proportionally scaled.
@item
@end menu
@c ------------------------------------------------------------------
+@external
@node Coordinate axes, Color styles, , General concepts
@section Coordinate axes
-Two axis representations are used in MathGL. The first one consists of normalizing coordinates of data points in a box @var{Min} x @var{Max} (see @ref{Axis settings}). If @code{SetCut()} is @code{true} then the outlier points are omitted, otherwise they are projected to the bounding box (see @ref{Cutting}). Also, the point will be omitted if it lies inside the box defined by @code{SetCutBox()} or if the value of formula @code{CutOff()} is nonzero for its coordinates. After that, transformation formulas defined by @code{SetFunc()} or @code{SetCoor()} are applied to the data point (see @ref{Curved coordinates}). Finally, the data point is plotted by one of the functions.
+Two axis representations are used in MathGL. The first one consists of normalizing coordinates of data points in a box @var{Min}x@var{Max} (see @ref{Axis settings}). If @code{SetCut()} is @code{true} then the outlier points are omitted, otherwise they are projected to the bounding box (see @ref{Cutting}). Also, the point will be omitted if it lies inside the box defined by @code{SetCutBox()} or if the value of formula @code{CutOff()} is nonzero for its coordinates. After that, transformation formulas defined by @code{SetFunc()} or @code{SetCoor()} are applied to the data point (see @ref{Curved coordinates}). Finally, the data point is plotted by one of the functions.
The range of @emph{x, y, z}-axis can be specified by @code{SetRange()} or @code{SetRanges()} functions. Its origin is specified by @code{SetOrigin()} function. At this you can you can use @code{NAN} values for selecting axis origin automatically.
The form (appearence) of tick labels is controlled by @code{SetTicks()} function (@pxref{Ticks}). Function @var{SetTuneTicks} switches on/off tick enhancing by factoring out acommon multiplier (for small coordinate values, like 0.001 to 0.002, or large, like from 1000 to 2000) or common component (for narrow range, like from 0.999 to 1.000). Finally, you may use functions @code{SetTickTempl()} for setting templates for tick labels (it supports TeX symbols). Also, there is a possibility to print arbitrary text as tick labels the by help of @code{SetTicksVal()} function.
-
+@c ------------------------------------------------------------------
+@external
@node Color styles, Line styles, Coordinate axes, General concepts
@section Color styles
Base colors are defined by one of symbol @samp{wkrgbcymhRGBCYMHWlenupqLENUPQ}.
@ifhtml
@html
-The color types are: ‘<samp>k</samp>’ -- black, ‘<samp>r</samp>’ -- <span style="color: rgb(255, 0, 0);">red</span>, ‘<samp>R</samp>’ -- <span style="color: rgb(127, 0, 0);">dark red</span>, ‘<samp>g</samp>’ -- <span style="color: rgb(0, 255, 0);">green</span>, ‘<samp>G</samp>’ -- <span style="color: rgb(0, 127, 0);">dark green</span>, ‘<samp>b</samp>’ -- <span style="color: rgb(0, 0, 255);">blue</span>, ‘<samp>B</samp>’ -- <span style="color: rgb(0, 0, 127);">dark blue</span>, ‘<samp>c</samp>’ -- <span style="color: rgb(0, 255, 255);">cyan</span>, ‘<samp>C</samp>’ -- <span style="color: rgb(0, 127, 127);">dark cyan</span>, ‘<samp>m</samp>’ -- <span style="color: rgb(255, 0, 255);">magenta</span>, ‘<samp>M</samp>’ -- <span style="color: rgb(127, 0, 127);">dark magenta</span>, ‘<samp>y</samp>’ -- <span style="color: rgb(255, 255, 0);">yellow</span>, ‘<samp>Y</samp>’ -- <span style="color: rgb(127, 127, 0);">dark yellow (gold)</span>, ‘<samp>h</samp>’ -- <span style="color: rgb(127, 127, 127);">gray</span>, ‘<samp>H</samp>’ -- <span style="color: rgb(76, 76, 76);">dark gray</span>, ‘<samp>w</samp>’ -- white, ‘<samp>W</samp>’ -- <span style="color: rgb(178, 178, 178);">bright gray</span>, ‘<samp>l</samp>’ -- <span style="color: rgb(0, 255, 127);">green-blue</span>, ‘<samp>L</samp>’ -- <span style="color: rgb(0, 127, 63);">dark green-blue</span>, ‘<samp>e</samp>’ -- <span style="color: rgb(127, 255, 0);">green-yellow</span>, ‘<samp>E</samp>’ -- <span style="color: rgb(63, 127, 0);">dark green-yellow</span>, ‘<samp>n</samp>’ -- <span style="color: rgb(0, 127, 255);">sky-blue</span>, ‘<samp>N</samp>’ -- <span style="color: rgb(0, 63, 127);">dark sky-blue</span>, ‘<samp>u</samp>’ -- <span style="color: rgb(127, 0, 255);">blue-violet</span>, ‘<samp>U</samp>’ -- <span style="color: rgb(63, 0, 127);">dark blue-violet</span>, ‘<samp>p</samp>’ -- <span style="color: rgb(255, 0, 127);">purple</span>, ‘<samp>P</samp>’ -- <span style="color: rgb(127, 0, 63);">dark purple</span>, ‘<samp>q</samp>’ -- <span style="color: rgb(255, 127, 0);">orange</span>, ‘<samp>Q</samp>’ -- <span style="color: rgb(127, 63, 0);">dark orange (brown)</span>.</p>
+<p>The color types are: ‘<samp>k</samp>’ -- black, ‘<samp>r</samp>’ -- <span style="color: rgb(255, 0, 0);">red</span>, ‘<samp>R</samp>’ -- <span style="color: rgb(127, 0, 0);">dark red</span>, ‘<samp>g</samp>’ -- <span style="color: rgb(0, 255, 0);">green</span>, ‘<samp>G</samp>’ -- <span style="color: rgb(0, 127, 0);">dark green</span>, ‘<samp>b</samp>’ -- <span style="color: rgb(0, 0, 255);">blue</span>, ‘<samp>B</samp>’ -- <span style="color: rgb(0, 0, 127);">dark blue</span>, ‘<samp>c</samp>’ -- <span style="color: rgb(0, 255, 255);">cyan</span>, ‘<samp>C</samp>’ -- <span style="color: rgb(0, 127, 127);">dark cyan</span>, ‘<samp>m</samp>’ -- <span style="color: rgb(255, 0, 255);">magenta</span>, ‘<samp>M</samp>’ -- <span style="color: rgb(127, 0, 127);">dark magenta</span>, ‘<samp>y</samp>’ -- <span style="color: rgb(255, 255, 0);">yellow</span>, ‘<samp>Y</samp>’ -- <span style="color: rgb(127, 127, 0);">dark yellow (gold)</span>, ‘<samp>h</samp>’ -- <span style="color: rgb(127, 127, 127);">gray</span>, ‘<samp>H</samp>’ -- <span style="color: rgb(76, 76, 76);">dark gray</span>, ‘<samp>w</samp>’ -- white, ‘<samp>W</samp>’ -- <span style="color: rgb(178, 178, 178);">bright gray</span>, ‘<samp>l</samp>’ -- <span style="color: rgb(0, 255, 127);">green-blue</span>, ‘<samp>L</samp>’ -- <span style="color: rgb(0, 127, 63);">dark green-blue</span>, ‘<samp>e</samp>’ -- <span style="color: rgb(127, 255, 0);">green-yellow</span>, ‘<samp>E</samp>’ -- <span style="color: rgb(63, 127, 0);">dark green-yellow</span>, ‘<samp>n</samp>’ -- <span style="color: rgb(0, 127, 255);">sky-blue</span>, ‘<samp>N</samp>’ -- <span style="color: rgb(0, 63, 127);">dark sky-blue</span>, ‘<samp>u</samp>’ -- <span style="color: rgb(127, 0, 255);">blue-violet</span>, ‘<samp>U</samp>’ -- <span style="color: rgb(63, 0, 127);">dark blue-violet</span>, ‘<samp>p</samp>’ -- <span style="color: rgb(255, 0, 127);">purple</span>, ‘<samp>P</samp>’ -- <span style="color: rgb(127, 0, 63);">dark purple</span>, ‘<samp>q</samp>’ -- <span style="color: rgb(255, 127, 0);">orange</span>, ‘<samp>Q</samp>’ -- <span style="color: rgb(127, 63, 0);">dark orange (brown)</span>.</p>
@end html
@end ifhtml
@ifnothtml
You can also use ``bright'' colors. The ``bright'' color contain 2 symbols in brackets @samp{@{cN@}}: first one is the usual symbol for color id, the second one is a digit for its brightness. The digit can be in range @samp{1}...@samp{9}. Number @samp{5} corresponds to a normal color, @samp{1} is a very dark version of the color (practically black), and @samp{9} is a very bright version of the color (practically white). For example, the colors can be @samp{@{b2@}} @samp{@{b7@}} @samp{@{r7@}} and so on.
-
+@c ------------------------------------------------------------------
+@external
@node Line styles, Color scheme, Color styles, General concepts
@section Line styles
One may specify to draw a special symbol (an arrow) at the beginning and at the end of line. This is done if the specification string contains one of the following symbols: @samp{A} -- outer arrow, @samp{V} -- inner arrow, @samp{I} -- transverse hatches, @samp{K} -- arrow with hatches, @samp{T} -- triangle, @samp{S} -- square, @samp{D} -- rhombus, @samp{O} -- circle, @samp{_} -- nothing (the default). The following rule applies: the first symbol specifies the arrow at the end of line, the second specifies the arrow at the beginning of the line. For example, @samp{r-A} defines a red solid line with usual arrow at the end, @samp{b|AI} defines a blue dash line with an arrow at the end and with hatches at the beginning, @samp{_O} defines a line with the current style and with a circle at the beginning. These styles are applicable during the graphics plotting as well (for example, @ref{1D plotting}).
-@fig{png/style, Color and line styles.}
+@pfig{style, Color and line styles.}
@c ------------------------------------------------------------------
+@external
@node Color scheme, Font styles, Line styles, General concepts
@section Color scheme
There are several useful combinations. String @samp{kw} corresponds to the simplest gray color scheme where higher values are brighter. String @samp{wk} presents the inverse gray color scheme where higher value is darker. Strings @samp{kRryw}, @samp{kGgw}, @samp{kBbcw} present the well-known @emph{hot}, @emph{summer} and @emph{winter} color schemes. Strings @samp{BbwrR} and @samp{bBkRr} allow to view bi-color figure on white or black background, where negative values are blue and positive values are red. String @samp{BbcyrR} gives a color scheme similar to the well-known @emph{jet} color scheme.
-@fig{png/schemes, Most popular color schemes.}
+@pfig{schemes, Most popular color schemes.}
When coloring by @emph{coordinate} (used in @ref{map}), the final color is determined by the position of the point in 3d space and is calculated from formula c=x*c[1] + y*c[2]. Here, c[1], c[2] are the first two elements of color array; x, y are normalized to axis range coordinates of the point.
@c This type of coloring is useful for isosurface plot where color may show the exact position of a piece of surface.
@c ------------------------------------------------------------------
+@external
@node Font styles, Textual formulas, Color scheme, General concepts
@section Font styles
The font size can be defined explicitly (if @var{size}>0) or relatively to a base font size as |@var{size}|*@var{FontSize} (if @var{size}<0). The value @var{size}=0 specifies that the string will not be printed. The base font size is measured in internal ``MathGL'' units. Special functions @code{SetFontSizePT(), SetFontSizeCM(), SetFontSizeIN()} (see @ref{Font settings}) allow one to set it in more ``common'' variables for a given dpi value of the picture.
-
@c ------------------------------------------------------------------
+@external
@node Textual formulas, Command options, Font styles, General concepts
@section Textual formulas
@math{\pi=3.1415926...}
@end ifnothtml
-
Trigonometric functions are: @samp{sin(x)}, @samp{cos(x)}, @samp{tan(x)} (or @samp{tg(x)}). Inverse trigonometric functions are: @samp{asin(x)}, @samp{acos(x)}, @samp{atan(x)}. Hyperbolic functions are: @samp{sinh(x)} (or @samp{sh(x)}), @samp{cosh(x)} (or @samp{ch(x)}), @samp{tanh(x)} (or @samp{th(x)}). Inverse hyperbolic functions are: @samp{asinh(x)}, @samp{acosh(x)}, @samp{atanh(x)}.
@ifhtml
There is no difference between lower or upper case in formulas. If argument value lie outside the range of function definition then function returns NaN.
-
@c ------------------------------------------------------------------
+@external
@node Command options, Interfaces, Textual formulas, General concepts
@section Command options
+@c ------------------------------------------------------------------
+@external
@node Interfaces, , Command options, General concepts
@section Interfaces
* C++ interface::
@end menu
+@external
@node C interface, C++ interface, , Interfaces
@subsection C/Fortran interface
Fortran functions/subroutines have the same names as C functions. However, there is a difference. Variable of type @code{HMGL, HMDT} must be an integer with sufficient size (@code{integer*4} in the 32-bit operating system or @code{integer*8} in the 64-bit operating system). All C functions are subroutines in Fortran, which are called by operator @code{call}. The exceptions are functions, which return variables of types @code{HMGL} or @code{HMDT}. These functions should be declared as integer in Fortran code. Also, one should keep in mind that strings in Fortran are denoted by @code{'} symbol, not the @code{"} symbol.
+@external
@node C++ interface, , C interface, Interfaces
@subsection C++/Python interface
This becomes useful if you create many @code{mglData} objects, for example.
@end ifclear
+
+@external
+
+@chapter Основные принципы
+
+Возможности библиотеки MathGL довольно богаты -- число только основных типов графиков превышает 50 видов. Кроме того, есть функции для обработки данных, настройки вида графика и пр. и пр. Тем не менее, я старался придерживаться единого стиля в порядке аргументов функций и способе их ``настройки''. В основном все ниже сказанное относится к функциям рисования различных графиков.
+
+Всего основных концепций (базисных идей) шесть:
+@enumerate
+@item
+@strong{Все рисунки создаются в памяти.} Это могут быть как растровые картинки (для @code{SetQuality(MGL_DRAW_LMEM)}), так и векторные списки примитивов (по умолчанию). Дальнейшая судьба рисунков определяется пользователем: можно сохранить в файл, вывести на экран, создать анимацию/кино, дополнительно отредактировать и т.д. Такой подход обеспечивает высокую переносимость библиотеки -- один и тот же программный код создаст в точности одинаковый рисунок на @emph{любой} операционной системе. Кроме того, при таком подходе рисунки можно создавать непосредственно в консольной программе -- графическое окно не нужно!
+@item
+@strong{Все настройки графиков (стиль линий, цветовые схемы поверхностей, стиль и цвет текста) задаются строками.} Это обеспечивает: удобство для пользователя -- короткую строку легче читать и здесь тяжелее ошибиться, чем в большом списке параметров; переносимость -- строки выглядят одинаково на всех платформах и не надо заботиться о типе и числе аргументов.
+@item
+@strong{Все функции имеют ``упрощенный'' и ``продвинутый'' варианты.} Сделано опять из-за удобства. В ``упрощенном'' варианте для построения графика нужны только один-два массив(а) данных, которые автоматически равнораспределяются в заданном диапазоне осей координат. В ``продвинутой'' версии можно не только указать явно диапазон построения графика, но и задать его параметрически. Последнее позволяет легко строить довольно сложные кривые и поверхности. В обоих вариантах функций порядок аргументов стандартен: сначала идут массивы данных, потом необязательный строковый параметр стиля графика, а далее строка опций для более точной настройки графика.
+@item
+@strong{Все данные передаются через экземпляры класса mglData(A).} Такой подход позволяет избежать ошибок при работе с памятью и единообразно передавать данные разных типов (mreal, double, данные из файла, заполненных пользователем и пр.) в функции рисования.
+@item
+@strong{Все элементы рисунков векторные.} Изначально библиотека MathGL была ориентированна на работу с научными данными, которые по своей природе векторные (линии, грани, матрицы и т.д.). Поэтому векторность используется во всех рисунках! Причем иногда даже в ущерб производительности (например, при выводе шрифтов). Помимо всего прочего, векторность позволяет легко масштабировать рисунок -- измените размер картинки в 2 раза, и рисунок пропорционально растянется.
+@item
+@strong{Новые графики не удаляют уже нарисованное.} Этот, в чем-то неожиданный, подход позволяет создавать огромное количество ``комбинированных'' графиков. Например, поверхность с наложенными линиями уровня строится двумя последовательными вызовами функций рисования поверхности и линий уровня (в любом порядке). И совершенно не надо писать специальную функцию (как в Matlab и некоторых других программах) для рисования этого графика.
+@end enumerate
+
+Кроме основных концепций я хотел бы остановиться на нескольких, как оказалось, нетривиальных моментах -- способе указания положения графика, осей координат и строковых параметров линий, поверхностей, текста.
+
+@menu
+* Coordinate axes::
+* Color styles::
+* Line styles::
+* Color scheme::
+* Font styles::
+* Textual formulas::
+* Command options::
+* Interfaces::
+@end menu
+
@c ------------------------------------------------------------------
-@node Coordinate axes, Line styles, , General concepts
-@subsection Оси координат
+@external
+@node Coordinate axes, Color styles, , General concepts
+@section Оси координат
+
+Представление системы координат в MathGL состоит из двух частей. Вначале координаты нормируются в интервал @var{Min}x@var{Max} (@pxref{Axis settings}). Если флаг @code{SetCut()} установлен, то точки вне интервала отбрасываются, в противном случае, они проецируются на ограничивающий параллелепипед (см. @ref{Cutting}). Кроме того, отбрасываются точки внутри границ, определенных переменными @var{CutMin}x@var{CutMax} и точки, для которых значение функции @code{CutOff}() не равно нулю. После этого формулы перехода в криволинейную систему координат @code{SetFunc()}применяются к каждой точке. Наконец, точка данных отображается с помощью одной из графических функций.
-Ð\9fÑ\80едÑ\81Ñ\82авление Ñ\81иÑ\81Ñ\82емÑ\8b кооÑ\80динаÑ\82 в MathGL Ñ\81оÑ\81Ñ\82оиÑ\82 из двÑ\83Ñ\85 Ñ\87аÑ\81Ñ\82ей. Ð\92наÑ\87але кооÑ\80динаÑ\82Ñ\8b ноÑ\80миÑ\80Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f в инÑ\82еÑ\80вал @var{Min}x@var{Max} (@pxref{Axis settings}). Ð\95Ñ\81ли Ñ\84лаг @var{Cut} Ñ\83Ñ\81Ñ\82ановлен, Ñ\82о Ñ\82оÑ\87ки вне инÑ\82еÑ\80вала оÑ\82бÑ\80аÑ\81Ñ\8bваÑ\8eÑ\82Ñ\81Ñ\8f, в пÑ\80оÑ\82ивном Ñ\81лÑ\83Ñ\87ае, они пÑ\80оеÑ\86иÑ\80Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f на огÑ\80аниÑ\87иваÑ\8eÑ\89ий паÑ\80аллелепипед (@pxref{Cutting}). Ð\9aÑ\80оме Ñ\82ого, оÑ\82бÑ\80аÑ\81Ñ\8bваÑ\8eÑ\82Ñ\81Ñ\8f Ñ\82оÑ\87ки внÑ\83Ñ\82Ñ\80и гÑ\80аниÑ\86, опÑ\80еделеннÑ\8bÑ\85 пеÑ\80еменнÑ\8bми @var{CutMin}x@var{CutMax} и Ñ\82оÑ\87ки, длÑ\8f коÑ\82оÑ\80Ñ\8bÑ\85 знаÑ\87ение Ñ\84Ñ\83нкÑ\86ии @code{CutOff}() не Ñ\80авно нÑ\83лÑ\8e. Ð\9fоÑ\81ле Ñ\8dÑ\82ого Ñ\84оÑ\80мÑ\83лÑ\8b пеÑ\80еÑ\85ода в кÑ\80иволинейнÑ\83Ñ\8e Ñ\81иÑ\81Ñ\82емÑ\83 кооÑ\80динаÑ\82 @code{SetFunc()}пÑ\80именÑ\8fÑ\8eÑ\82Ñ\81Ñ\8f к каждой Ñ\82оÑ\87ке. Ð\9dаконеÑ\86, Ñ\82оÑ\87ка даннÑ\8bÑ\85 оÑ\82обÑ\80ажаеÑ\82Ñ\81Ñ\8f Ñ\81 помоÑ\89Ñ\8cÑ\8e одной из гÑ\80аÑ\84иÑ\87еÑ\81киÑ\85 Ñ\84Ñ\83нкÑ\86ий.
+Ð\94иапазон изменениÑ\8f @emph{x, y, z}-кооÑ\80динаÑ\82 задаеÑ\82Ñ\81Ñ\8f Ñ\84Ñ\83нкÑ\86иÑ\8fми @code{SetRange()} или @code{SetRanges()}. ТоÑ\87ка пеÑ\80еÑ\81еÑ\87ениÑ\8f оÑ\81ей кооÑ\80динаÑ\82 задаеÑ\82Ñ\81Ñ\8f Ñ\84Ñ\83нкÑ\86ией @code{SetOrigin()}. Ð\9fÑ\80и Ñ\8dÑ\82ом можно иÑ\81полÑ\8cзоваÑ\82Ñ\8c NAN знаÑ\87ениÑ\8f длÑ\8f авÑ\82омаÑ\82иÑ\87еÑ\81кого вÑ\8bбоÑ\80а положениÑ\8f оÑ\81и.
-Ð\92елиÑ\87инÑ\8b @var{Max}, @var{Min} можно изменÑ\8fÑ\82Ñ\8c вÑ\80Ñ\83Ñ\87нÑ\83Ñ\8e. Ð\9eднако, поÑ\81ле Ñ\8dÑ\82ого необÑ\85одимо вÑ\8bзваÑ\82Ñ\8c Ñ\84Ñ\83нкÑ\86иÑ\8e @code{RecalcBorder()} длÑ\8f наÑ\81Ñ\82Ñ\80ойки гÑ\80аÑ\84ика. Ð\91олее Ñ\83добнÑ\8bй и безопаÑ\81нÑ\8bй пÑ\83Ñ\82Ñ\8c Ñ\81оÑ\81Ñ\82оиÑ\82 в вÑ\8bзове Ñ\84Ñ\83нкÑ\86ий @code{Axis(), SetRanges()} и дÑ\80. Ð\92 поÑ\81леднем Ñ\81лÑ\83Ñ\87ае Ñ\84Ñ\83нкÑ\86иÑ\8f @code{RecalcBorder()} вÑ\8bзÑ\8bваеÑ\82Ñ\81Ñ\8f авÑ\82омаÑ\82иÑ\87еÑ\81ки. РазмеÑ\80Ñ\8b оÑ\81ей можно задаваÑ\82Ñ\8c и авÑ\82омаÑ\82иÑ\87еÑ\81ки по минималÑ\8cномÑ\83 и макÑ\81ималÑ\8cномÑ\83 знаÑ\87ениÑ\8fм маÑ\81Ñ\81ива даннÑ\8bÑ\85. Ð\94лÑ\8f Ñ\8dÑ\82ого пÑ\80едназнаÑ\87енÑ\8b Ñ\84Ñ\83нкÑ\86ии @code{XRange(), YRange(), ZRange()}. Ð\92Ñ\82оÑ\80ой не обÑ\8fзаÑ\82елÑ\8cнÑ\8bй аÑ\80гÑ\83менÑ\82 Ñ\83казÑ\8bваеÑ\82, заменÑ\8fÑ\82Ñ\8c ли новÑ\8bе знаÑ\87ениÑ\8f диапазона изменениÑ\8f оÑ\81и кооÑ\80динаÑ\82 (по Ñ\83молÑ\87аниÑ\8e) или Ñ\82олÑ\8cко Ñ\80аÑ\81Ñ\88иÑ\80иÑ\82Ñ\8c Ñ\83же Ñ\81Ñ\83Ñ\89еÑ\81Ñ\82вÑ\83Ñ\8eÑ\89ий диапазон.
+Ð\9aÑ\80оме пÑ\80ивÑ\8bÑ\87нÑ\8bÑ\85 оÑ\81ей @emph{x, y, z} еÑ\81Ñ\82Ñ\8c еÑ\89е одна оÑ\81Ñ\8c -- Ñ\86веÑ\82оваÑ\8f Ñ\88кала -- оÑ\81Ñ\8c @emph{c}. Ð\9eна иÑ\81полÑ\8cзÑ\83еÑ\82Ñ\81Ñ\8f пÑ\80и окÑ\80аÑ\88ивании повеÑ\80Ñ\85ноÑ\81Ñ\82ей и задаеÑ\82 гÑ\80аниÑ\86Ñ\8b изменениÑ\8f Ñ\84Ñ\83нкÑ\86ии пÑ\80и окÑ\80аÑ\88ивании. Ð\95е гÑ\80аниÑ\86Ñ\8b авÑ\82омаÑ\82иÑ\87еÑ\81ки Ñ\83Ñ\81Ñ\82анавливаÑ\8eÑ\82Ñ\81Ñ\8f Ñ\80авнÑ\8bми Min.z и Max.z пÑ\80и вÑ\8bзове @code{SetRanges()}. Ð\92озможно и Ñ\80Ñ\83Ñ\87ное изменение гÑ\80аниÑ\86 Ñ\86веÑ\82ового инÑ\82еÑ\80вала поÑ\81Ñ\80едÑ\81Ñ\82вом вÑ\8bзова @code{SetRange('c', ...)}. Ð\98Ñ\81полÑ\8cзÑ\83йÑ\82е @code{Colorbar()} длÑ\8f оÑ\82обÑ\80ажениÑ\8f Ñ\86веÑ\82овой Ñ\88калÑ\8b.
-ТоÑ\87ка пеÑ\80еÑ\81еÑ\87ениÑ\8f оÑ\81ей кооÑ\80динаÑ\82 задаеÑ\82Ñ\81Ñ\8f пеÑ\80еменной @var{Org} и дейÑ\81Ñ\82вÑ\83еÑ\82 на поÑ\81ледÑ\83Ñ\8eÑ\89ие вÑ\8bзовÑ\8b Ñ\84Ñ\83нкÑ\86ий Ñ\80иÑ\81ованиÑ\8f оÑ\81ей кооÑ\80динаÑ\82 и Ñ\81еÑ\82ки. Ð\9fо Ñ\83молÑ\87аниÑ\8e, еÑ\81ли Ñ\82оÑ\87ка пеÑ\80еÑ\81еÑ\87ениÑ\8f оÑ\81ей кооÑ\80динаÑ\82 попадаеÑ\82 вне диапазона оÑ\81ей кооÑ\80динаÑ\82, Ñ\82о она пÑ\80оеÑ\86иÑ\80Ñ\83еÑ\82Ñ\81Ñ\8f на гÑ\80аниÑ\86Ñ\83 облаÑ\81Ñ\82и. Ð\98змениÑ\82Ñ\8c Ñ\82акое поведение можно, задав @var{AutoOrg}=@code{false}. Ð\92 Ñ\81лÑ\83Ñ\87ае, еÑ\81ли одно из знаÑ\87ений @var{Org} Ñ\80авно NAN, Ñ\82о Ñ\81ооÑ\82веÑ\82Ñ\81Ñ\82вÑ\83Ñ\8eÑ\89ее знаÑ\87ение бÑ\83деÑ\82 вÑ\8bбÑ\80ано авÑ\82омаÑ\82иÑ\87еÑ\81ки.
+Ð\92ид меÑ\82ок по оÑ\81Ñ\8fм опÑ\80еделÑ\8fеÑ\82Ñ\81Ñ\8f Ñ\84Ñ\83нкÑ\86ией @code{SetTicks()} (@pxref{Ticks}). ФÑ\83нкÑ\86иÑ\8f @var{SetTuneTicks} вклÑ\8eÑ\87аеÑ\82/вÑ\8bклÑ\8eÑ\87аеÑ\82 вÑ\8bделение обÑ\89его множиÑ\82елÑ\8f (болÑ\8cÑ\88ого или малого Ñ\84акÑ\82оÑ\80ов в диапазоне) длÑ\8f меÑ\82ок оÑ\81ей кооÑ\80динаÑ\82. Ð\9dаконеÑ\86, еÑ\81ли Ñ\81Ñ\82андаÑ\80Ñ\82нÑ\8bй вид меÑ\82ок не Ñ\83Ñ\81Ñ\82Ñ\80аиваеÑ\82 полÑ\8cзоваÑ\82елÑ\8f, Ñ\82о иÑ\85 Ñ\88аблон можно задаÑ\82Ñ\8c Ñ\8fвно (можно иÑ\81полÑ\8cзоваÑ\82Ñ\8c и ТеХ Ñ\81имволÑ\8b), воÑ\81полÑ\8cзовавÑ\88иÑ\81Ñ\8c Ñ\84Ñ\83нкÑ\86ией @code{SetTickTempl()}. Ð\9aÑ\80оме Ñ\82ого, в каÑ\87еÑ\81Ñ\82ве меÑ\82ок можно вÑ\8bвеÑ\81Ñ\82и пÑ\80оизволÑ\8cнÑ\8bй Ñ\82екÑ\81Ñ\82 иÑ\81полÑ\8cзовав Ñ\84Ñ\83нкÑ\86иÑ\8e @code{SetTicksVal()}.
-Кроме привычных осей @emph{x, y, z} есть еще одна ось -- цветовая шкала -- ось @emph{c}. Она используется при окрашивании поверхностей и задает границы изменения функции при окрашивании. При вызове @code{Axis()} ее границы автоматически устанавливаются равными Min.z и Max.z. Возможно и ручное изменение границ цветового интервала посредством вызова функции @code{CAxis()} или изменение границ по заданному массиву @code{CRange()}. Используйте @code{Colorbar()} для отображения цветовой шкалы.
+@c ------------------------------------------------------------------
+@external
+@node Color styles, Line styles, Coordinate axes, General concepts
+@section Цвета
+
+Base colors are defined by one of symbol @samp{wkrgbcymhRGBCYMHWlenupqLENUPQ}.
+@ifhtml
+@html
+<p>Символы цвета: ‘<samp>k</samp>’ -- черный, ‘<samp>r</samp>’ -- <span style="color: rgb(255, 0, 0);">красный</span>, ‘<samp>R</samp>’ -- <span style="color: rgb(127, 0, 0);">темно красный</span>, ‘<samp>g</samp>’ -- <span style="color: rgb(0, 255, 0);">зеленый</span>, ‘<samp>G</samp>’ -- <span style="color: rgb(0, 127, 0);">темно зеленый</span>, ‘<samp>b</samp>’ -- <span style="color: rgb(0, 0, 255);">синий</span>, ‘<samp>B</samp>’ -- <span style="color: rgb(0, 0, 127);">темно синий</span>, ‘<samp>c</samp>’ -- <span style="color: rgb(0, 255, 255);">голубой</span>, ‘<samp>C</samp>’ -- <span style="color: rgb(0, 127, 127);">темно голубой</span>, ‘<samp>m</samp>’ -- <span style="color: rgb(255, 0, 255);">пурпурный</span>, ‘<samp>M</samp>’ -- <span style="color: rgb(127, 0, 127);">темно пурпурный</span>, ‘<samp>y</samp>’ -- <span style="color: rgb(255, 255, 0);">желтый</span>, ‘<samp>Y</samp>’ -- <span style="color: rgb(127, 127, 0);">темно желтый (золотой)</span>, ‘<samp>h</samp>’ -- <span style="color: rgb(127, 127, 127);">серый</span>, ‘<samp>H</samp>’ -- <span style="color: rgb(76, 76, 76);">темно серый</span>, ‘<samp>w</samp>’ -- белый, ‘<samp>W</samp>’ -- <span style="color: rgb(178, 178, 178);">светло серый</span>, ‘<samp>l</samp>’ -- <span style="color: rgb(0, 255, 127);">сине-зеленый</span>, ‘<samp>L</samp>’ -- <span style="color: rgb(0, 127, 63);">темно сине-зеленый</span>, ‘<samp>e</samp>’ -- <span style="color: rgb(127, 255, 0);">желто-зеленый</span>, ‘<samp>E</samp>’ -- <span style="color: rgb(63, 127, 0);">темно желто-зеленый</span>, ‘<samp>n</samp>’ -- <span style="color: rgb(0, 127, 255);">небесно-синий</span>, ‘<samp>N</samp>’ -- <span style="color: rgb(0, 63, 127);">темно небесно-синий</span>, ‘<samp>u</samp>’ -- <span style="color: rgb(127, 0, 255);">сине-фиолетовый</span>, ‘<samp>U</samp>’ -- <span style="color: rgb(63, 0, 127);">темно сине-фиолетовый</span>, ‘<samp>p</samp>’ -- <span style="color: rgb(255, 0, 127);">фиолетовый</span>, ‘<samp>P</samp>’ -- <span style="color: rgb(127, 0, 63);">темно фиолетовый</span>, ‘<samp>q</samp>’ -- <span style="color: rgb(255, 127, 0);">оранжевый</span>, ‘<samp>Q</samp>’ -- <span style="color: rgb(127, 63, 0);">темно оранжевый (коричневый)</span>.</p>
+@end html
+@end ifhtml
+@ifnothtml
+Символы цвета: @samp{k} -- черный, @samp{r} -- красный, @samp{R} -- темно красный, @samp{g} -- зеленый, @samp{G} -- темно зеленый, @samp{b} -- синий, @samp{B} -- темно синий, @samp{c} -- голубой, @samp{C} -- темно голубой, @samp{m} -- пурпурный, @samp{M} -- темно пурпурный, @samp{y} -- желтый, @samp{Y} -- темно желтый (золотой), @samp{h} -- серый, @samp{H} -- темно серый, @samp{w} -- белый, @samp{W} -- светло серый, @samp{l} -- сине-зеленый, @samp{L} -- темно сине-зеленый, @samp{e} -- желто-зеленый, @samp{E} -- темно желто-зеленый, @samp{n} -- небесно-синий, @samp{N} -- темно небесно-синий, @samp{u} -- сине-фиолетовый, @samp{U} -- темно сине-фиолетовый, @samp{p} -- фиолетовый, @samp{P} -- темно фиолетовый, @samp{q} -- оранжевый, @samp{Q} -- темно оранжевый (коричневый).
+@end ifnothtml
-Вид меток по осям определяется функцией @code{SetTicks()} (@pxref{Axis settings}). Она имеет 3 аргумента: первый @var{d} задает шаг меток (если положительны) или их число (если отрицательны) или логарифмические метки (если равны нулю); второ @var{ns} задает число "подметок"; последний определяет начальную точку для меток (по умолчанию это точка пересечения осей). Функция @var{SetTuneTicks} включает/выключает выделение общего множителя (большого или малого факторов в диапазоне) для меток осей координат. Наконец, если стандартный вид меток не устраивает пользователя, то их шаблон можно задать явно (можно использовать и ТеХ символы), воспользовавшись функциями @code{SetXTT(), SetYTT(). SetZTT(). SetCTT()}. Кроме того, в качестве меток можно вывести произвольный текст использовав функцию @code{SetTicksVal()}.
+В цветовой схеме можно использовать тональные (``подсвеченные'') цвета. Тональный цвет задается двумя символами в фигурных скобках @samp{@{cN@}: первый -- обычный цвет, второй -- его яркость цифрой. Цифра может быть в диапазоне @samp{1}...@samp{9}. При этом @samp{5} соответствует нормальному цвету, @samp{1} -- очень темная версия цвета (почти черный), @samp{9} -- очень светлая версия цвета (почти белый). Например, цвета могут быть @samp{@{b2@}} @samp{@{b7@}} @samp{@{r7@}} и т.д.
@c ------------------------------------------------------------------
-@node Line styles, Color scheme, Coordinate axes, General concepts
-@subsection Стиль линий
+@external
+@node Line styles, Color scheme, Color styles, General concepts
+@section Стиль линий
@cindex Стиль линий
@cindex Стиль маркеров
@html
По умолчанию палитры содержит следующие цвета: <span style="color: rgb(76, 76, 76);">темно серый</span> ‘<samp>H</samp>’, <span style="color: rgb(0, 0, 255);">синий</span> ‘<samp>b</samp>’, <span style="color: rgb(0, 255, 0);">зеленый</span> ‘<samp>g</samp>’, <span style="color: rgb(255, 0, 0);">красный</span> ‘<samp>r</samp>’, <span style="color: rgb(0, 255, 255);">голубой</span> ‘<samp>c</samp>’, <span style="color: rgb(255, 0, 255);">пурпурный</span> ‘<samp>m</samp>’, <span style="color: rgb(255, 255, 0);">yellow</span> ‘<samp>y</samp>’, <span style="color: rgb(127, 127, 127);">серый</span> ‘<samp>h</samp>’, <span style="color: rgb(0, 255, 127);">сине-зеленый</span> ‘<samp>l</samp>’, <span style="color: rgb(0, 127, 255);">небесно-синий</span> ‘<samp>n</samp>’, <span style="color: rgb(255, 127, 0);">оранжевый</span> ‘<samp>q</samp>’, <span style="color: rgb(127, 255, 0);">желто-зеленый</span> ‘<samp>e</samp>’, <span style="color: rgb(127, 0, 255);">сине-фиолетовый</span> ‘<samp>u</samp>’, <span style="color: rgb(255, 0, 127);">фиолетовый</span> ‘<samp>p</samp>’.
-<p>Символы цвета: ‘<samp>k</samp>’ -- черный, ‘<samp>r</samp>’ -- <span style="color: rgb(255, 0, 0);">красный</span>, ‘<samp>R</samp>’ -- <span style="color: rgb(127, 0, 0);">темно красный</span>, ‘<samp>g</samp>’ -- <span style="color: rgb(0, 255, 0);">зеленый</span>, ‘<samp>G</samp>’ -- <span style="color: rgb(0, 127, 0);">темно зеленый</span>, ‘<samp>b</samp>’ -- <span style="color: rgb(0, 0, 255);">синий</span>, ‘<samp>B</samp>’ -- <span style="color: rgb(0, 0, 127);">темно синий</span>, ‘<samp>c</samp>’ -- <span style="color: rgb(0, 255, 255);">голубой</span>, ‘<samp>C</samp>’ -- <span style="color: rgb(0, 127, 127);">темно голубой</span>, ‘<samp>m</samp>’ -- <span style="color: rgb(255, 0, 255);">пурпурный</span>, ‘<samp>M</samp>’ -- <span style="color: rgb(127, 0, 127);">темно пурпурный</span>, ‘<samp>y</samp>’ -- <span style="color: rgb(255, 255, 0);">желтый</span>, ‘<samp>Y</samp>’ -- <span style="color: rgb(127, 127, 0);">темно желтый (золотой)</span>, ‘<samp>h</samp>’ -- <span style="color: rgb(127, 127, 127);">серый</span>, ‘<samp>H</samp>’ -- <span style="color: rgb(76, 76, 76);">темно серый</span>, ‘<samp>w</samp>’ -- белый, ‘<samp>W</samp>’ -- <span style="color: rgb(178, 178, 178);">светло серый</span>, ‘<samp>l</samp>’ -- <span style="color: rgb(0, 255, 127);">сине-зеленый</span>, ‘<samp>L</samp>’ -- <span style="color: rgb(0, 127, 63);">темно сине-зеленый</span>, ‘<samp>e</samp>’ -- <span style="color: rgb(127, 255, 0);">желто-зеленый</span>, ‘<samp>E</samp>’ -- <span style="color: rgb(63, 127, 0);">темно желто-зеленый</span>, ‘<samp>n</samp>’ -- <span style="color: rgb(0, 127, 255);">небесно-синий</span>, ‘<samp>N</samp>’ -- <span style="color: rgb(0, 63, 127);">темно небесно-синий</span>, ‘<samp>u</samp>’ -- <span style="color: rgb(127, 0, 255);">сине-фиолетовый</span>, ‘<samp>U</samp>’ -- <span style="color: rgb(63, 0, 127);">темно сине-фиолетовый</span>, ‘<samp>p</samp>’ -- <span style="color: rgb(255, 0, 127);">фиолетовый</span>, ‘<samp>P</samp>’ -- <span style="color: rgb(127, 0, 63);">темно фиолетовый</span>, ‘<samp>q</samp>’ -- <span style="color: rgb(255, 127, 0);">оранжевый</span>, ‘<samp>Q</samp>’ -- <span style="color: rgb(127, 63, 0);">темно оранжевый (коричневый)</span>.</p>
-
-Тип пунктира: пробел -- нет линии (для рисования только маркеров), ‘<samp>-</samp>’ -- сплошная линия (■■■■■■■■■■■■■■■■), ‘<samp>|</samp>’ -- длинный пунктир (■■■■■■■■□□□□□□□□), ‘<samp>;</samp>’ -- пунктир (■■■■□□□□■■■■□□□□), ‘<samp>=</samp>’ -- короткий пунктир (■■□□■■□□■■□□■■□□), ‘<samp>:</samp>’ -- точки (■□□□■□□□■□□□■□□□), ‘<samp>j</samp>’ -- пунктир с точками (■■■■■■■□□□□■□□□□), ‘<samp>i</samp>’ -- мелкий пунктир с точками (■■■□□■□□■■■□□■□□).
+<p>Тип пунктира: пробел -- нет линии (для рисования только маркеров), ‘<samp>-</samp>’ -- сплошная линия (■■■■■■■■■■■■■■■■), ‘<samp>|</samp>’ -- длинный пунктир (■■■■■■■■□□□□□□□□), ‘<samp>;</samp>’ -- пунктир (■■■■□□□□■■■■□□□□), ‘<samp>=</samp>’ -- короткий пунктир (■■□□■■□□■■□□■■□□), ‘<samp>:</samp>’ -- точки (■□□□■□□□■□□□■□□□), ‘<samp>j</samp>’ -- пунктир с точками (■■■■■■■□□□□■□□□□), ‘<samp>i</samp>’ -- мелкий пунктир с точками (■■■□□■□□■■■□□■□□).</p>
@end html
@end ifhtml
@ifnothtml
-По умолчанию палитры содержит следующие цвета: темно серый @samp{H}, синий @samp{b}, зеленый @samp{g}, красный @samp{r}, голубой @samp{c}, пурпурный @samp{m}, yellow @samp{y}, серый @samp{h}, сине-зеленый @samp{l}, небесно-синий @samp{n}, оранжевый @samp{q}, желто-зеленый @samp{e}, сине-фиолетовый @samp{u}, фиолетовый @samp{p}.
-
-Символы цвета те же, что и в классе mglColor (@pxref{mglColor class}): @samp{k} -- черный, @samp{r} -- красный, @samp{R} -- темно красный, @samp{g} -- зеленый, @samp{G} -- темно зеленый, @samp{b} -- синий, @samp{B} -- темно синий, @samp{c} -- голубой, @samp{C} -- темно голубой, @samp{m} -- пурпурный, @samp{M} -- темно пурпурный, @samp{y} -- желтый, @samp{Y} -- темно желтый (золотой), @samp{h} -- серый, @samp{H} -- темно серый, @samp{w} -- белый, @samp{W} -- светло серый, @samp{l} -- сине-зеленый, @samp{L} -- темно сине-зеленый, @samp{e} -- желто-зеленый, @samp{E} -- темно желто-зеленый, @samp{n} -- небесно-синий, @samp{N} -- темно небесно-синий, @samp{u} -- сине-фиолетовый, @samp{U} -- темно сине-фиолетовый, @samp{p} -- фиолетовый, @samp{P} -- темно фиолетовый, @samp{q} -- оранжевый, @samp{Q} -- темно оранжевый (коричневый).
+По умолчанию палитра содержит следующие цвета: темно серый @samp{H}, синий @samp{b}, зеленый @samp{g}, красный @samp{r}, голубой @samp{c}, пурпурный @samp{m}, yellow @samp{y}, серый @samp{h}, сине-зеленый @samp{l}, небесно-синий @samp{n}, оранжевый @samp{q}, желто-зеленый @samp{e}, сине-фиолетовый @samp{u}, фиолетовый @samp{p}.
Тип пунктира: пробел -- нет линии (для рисования только маркеров), @samp{-} -- сплошная линия (################), @samp{|} -- длинный пунктир (########________), @samp{;} -- пунктир (####____####____), @samp{=} -- короткий пунктир (##__##__##__##__), @samp{:} -- точки (#___#___#___#___), @samp{j} -- пунктир с точками (#######____#____), @samp{i} -- мелкий пунктир с точками (###__#__###__#__).
@end ifnothtml
Типы маркеров: @samp{o} -- окружность, @samp{+} -- крест, @samp{x} -- косой крест, @samp{s} - квадрат, @samp{d} - ромб, @samp{.} -- точка, @samp{^} -- треугольник вверх, @samp{v} -- треугольник вниз, @samp{<} -- треугольник влево, @samp{>} -- треугольник вправо, @samp{#*} -- знак Y, @samp{#+} -- крест в квадрате, @samp{#x} -- косой крест в квадрате, @samp{#.} -- точка в окружности. Если в строке присутствует символ @samp{#}, то используются символы с заполнением.
-@float
-@image{../png/sample5, 7cm}
-@caption{Стили линий и маркеров.}
-@end float
-
На конце и в начале линии можно выводить специальный символ (стрелку), если в строке указать один из символов: @samp{A} -- стрелка наружу, @samp{V} -- стрелка внутрь, @samp{I} -- поперечная черта, @samp{K} -- стрелка с чертой, @samp{T} -- треугольник, @samp{S} -- квадрат, @samp{D} -- ромб, @samp{O} -- круг, @samp{_} -- нет стрелки (по умолчанию). При этом действует следующее правило: первый символ определяет стрелку на конце линии, второй символ -- стрелку в начале линии. Например, @samp{r-A} -- красная сплошная линия со стрелкой на конце, @samp{b|AI} -- синий пунктир со стрелкой на конце и чертой вначале, @samp{_O} -- линия с текущим стилем и кружком вначале. Эти стили действуют и при построении графиков (например, @ref{1D plotting}).
-@float
-@image{../png/sampled, 7cm}
-@caption{Стили стрелок.}
-@end float
+@pfig{style, Color and line styles.}
@c ------------------------------------------------------------------
+@external
@node Color scheme, Font styles, Line styles, General concepts
-@subsection Цветовая схема
+@section Цветовая схема
@cindex Цветовая схема
-Цветовая схема используется для определения цвета поверхностей, линий уровня и пр. Цветовая схема задается строкой @emph{s}, которая содержит символы цвета (@pxref{Line styles}) или символы @samp{d#:|}. Символ @samp{d} указывает на определение цвета в зависимости от положения точки в пространстве, а не по амплитуде данных. Символ @samp{#} переключает рисование поверхности на сетчатое (для трехмерных поверхностей) или включает рисование сетки на поверхности. Символ @samp{|} отключает интерполяцию цвета в цветовой схеме. Это может быть полезно для ``резких'' цветов, например, при рисовании матриц. Если в строке встречается символ @samp{:}, то он принудительно заканчивает разбор строки для стиля поверхности. После этого символа могут идти описание стиля текста или оси вращения кривой/линий уровня. Цветовая схема может содержать до 32 значений цвета.
-
-В цветовой схеме можно использовать тональные (``подсвеченные'') цвета (@emph{не в стиле линий!}). Тональный цвет задается двумя символами: первый -- обычный цвет, второй -- его яркость цифрой. Цифра может быть в диапазоне @samp{1}...@samp{9}. При этом @samp{5} соответствует нормальному цвету, @samp{1} -- очень темная версия цвета (почти черный), @samp{9} -- очень светлая версия цвета (почти белый). Например цветовая схема может быть @samp{b2b7wr7r2}.
+Цветовая схема используется для определения цвета поверхностей, линий уровня и пр. Цветовая схема задается строкой @emph{s}, которая содержит символы цвета (@pxref{Line styles}) или символы @samp{#:|}. Символ @samp{#} переключает рисование поверхности на сетчатое (для трехмерных поверхностей) или включает рисование сетки на поверхности. Символ @samp{|} отключает интерполяцию цвета в цветовой схеме. Это может быть полезно для ``резких'' цветов, например, при рисовании матриц. Если в строке встречается символ @samp{:}, то он принудительно заканчивает разбор строки для стиля поверхности. После этого символа могут идти описание стиля текста или оси вращения кривой/линий уровня. Цветовая схема может содержать до 32 значений цвета.
-@float
-@image{../png/colors, 7cm}
-@caption{Цвета и их идентификаторы.}
-@end float
-
-При определении цвета по @emph{амплитуде} (наиболее часто используется) окончательный цвет определяется путем линейной интерполяции массива цветов. Массив цветов формируется из цветов, указанных в строке спецификации. Аргумент -- амплитуда, нормированная между @var{Cmin} -- @var{Cmax} (@pxref{Axis settings}). Например, строка из 4 символов @samp{bcyr} соответствует изменению цвета от синего (минимальное значение) через голубой и желтый (промежуточные значения) к красному (максимальное значение). Строка @samp{kw} соответствует изменению цвета от черного (минимальное значение) к белому (максимальное значение). Строка из одного символа (например, @samp{g}) соответствует однотонному цвету (в данному случае зеленому).
+При определении цвета по @emph{амплитуде} (наиболее часто используется) окончательный цвет определяется путем линейной интерполяции массива цветов. Массив цветов формируется из цветов, указанных в строке спецификации. Аргумент -- амплитуда, нормированная между @var{Cmin} -- @var{Cmax} (см. @ref{Axis settings}). Например, строка из 4 символов @samp{bcyr} соответствует изменению цвета от синего (минимальное значение) через голубой и желтый (промежуточные значения) к красному (максимальное значение). Строка @samp{kw} соответствует изменению цвета от черного (минимальное значение) к белому (максимальное значение). Строка из одного символа (например, @samp{g}) соответствует однотонному цвету (в данному случае зеленому).
Есть несколько полезных цветовых схем. Строка @samp{kw} дает обычную серую (черно-белую) схему, когда большие значения светлее. Строка @samp{wk} представляет обратную серую схему, когда большие значения темнее. Строки @samp{kRryw}, @samp{kGgw}, @samp{kBbcw} представляют собой хорошо известные схемы @emph{hot}, @emph{summer} и @emph{winter}. Строки @samp{BbwrR} и @samp{bBkRr} позволяют рисовать двухцветные фигуры на белом или черном фоне, когда отрицательные значения показаны синим цветом, а положительные -- красным. Строка @samp{BbcyrR} дает цветовую схему, близкую к хорошо известной схеме @emph{jet}.
+@pfig{schemes, Most popular color schemes.}
-@float
-@image{../png/color_schemes, 7cm}
-@caption{Наиболее популярные цветовые схемы.}
-@end float
-
-При определении цвета по @emph{положению точки в пространстве} окончательный цвет определяется по формуле c=x*c[1] + y*c[2] + z*c[3]. Здесь c[1], c[2], c[3] -- первые три цвета в цветовом массиве; x, y, z -- координаты точки, нормированные на @var{Min}x@var{Max}. Такой тип определения цвета полезен, например, при построении поверхностей уровня, когда цвет дает представление о положении точки в пространстве.
+При определении цвета по @emph{положению точки в пространстве} (используется в @ref{map}) окончательный цвет определяется по формуле c=x*c[1] + y*c[2]. Здесь c[1], c[2] -- первые три цвета в цветовом массиве; x, y -- координаты точки, нормированные на @var{Min}x@var{Max}.
+@c Такой тип определения цвета полезен, например, при построении поверхностей уровня, когда цвет дает представление о положении точки в пространстве.
@c ------------------------------------------------------------------
+@external
@node Font styles, Textual formulas, Color scheme, General concepts
-@subsection Стиль текста
+@section Стиль текста
@cindex Стиль текста
-Стиль текста задается строкой, которая может содержать несколько символов: тип шрифта (@samp{ribwou}) и/или выравнивания (@samp{LRC}), а также цвет текста @samp{wkrgbcymhRGBCYMHW} (@pxref{Line styles}) после символа @samp{:}. Например, @samp{r:iCb} соответствует жирному курсиву с выравниванием по центру красного цвета.
+Стиль текста задается строкой, которая может содержать цвет текста @samp{wkrgbcymhRGBCYMHW} (см. @ref{Color styles}), а также тип шрифта (@samp{ribwou}) и/или выравнивания (@samp{LRC}) после символа @samp{:}. Например, @samp{r:iCb} соответствует жирному (@samp{b}) курсиву (@samp{i}) с выравниванием по центру (@samp{C} красного цвета (@samp{r}).
-Начертания шрифта: @samp{r} -- прямой шрифт, @samp{i} -- курсив, @samp{b} -- жирный. По умолчанию используется прямой шрифт. Типы выравнивания текста: @samp{L} -- по левому краю (по умолчанию), @samp{C} -- по центру, @samp{R} -- по правому краю. Дополнительные эффекты шрифта: @samp{w} -- контурный, @samp{o} -- надчеркнутый, @samp{u} -- подчеркнутый.
-@c Синтаксический разбор LaTeX-их команд по умолчанию включен (подробнее см. @pxref{mglFont class} и @ref{Font settings}).
+Начертания шрифта: @samp{r} -- прямой шрифт, @samp{i} -- курсив, @samp{b} -- жирный. По умолчанию используется прямой шрифт. Типы выравнивания текста: @samp{L} -- по левому краю (по умолчанию), @samp{C} -- по центру, @samp{R} -- по правому краю. Дополнительные эффекты шрифта: @samp{w} -- контурный, @samp{o} -- надчеркнутый, @samp{u} -- подчеркнутый.
Синтаксический разбор LaTeX-их команд по умолчанию включен. Это команды смены стиля текста (например, \b для жирного текста): \a или \overline -- надчеркивание, \b или \textbf -- жирный, \i или \textit -- курсив, \r или \textrm -- прямой (отменяет стили жирного и курсива), \u или \underline -- подчеркнутый, \w или \wire -- контурный, \big -- большего размера, @@ -- меньшего размера. Нижний и верхний индексы задаются символами @samp{_} и @samp{^}. При этом изменение стиля применяется только к следующему символу или к символам в фигурных скобках @{@}, которые понимаются как единый блок. Например, сравните строки @samp{sin (x^@{2^3@})} и @samp{sin (x^2^3)}. Можно также менять цвет текста внутри строки с помощью команд #? или \color?, где @samp{?} -- символ цвета (@pxref{Line styles}). Например, слова @samp{Blue} и @samp{red} будут окрашены в соответствующий цвет в строке @samp{#b@{Blue@} and \colorr@{red@} text}. Большинство функций понимает символ новой строки @samp{\n} и позволяет выводить много строчный текст. Наконец, можно использовать символы с произвольным UTF кодом с помощью команды @code{\utf0x????}. Например, @code{\utf0x3b1} даст символ
@ifhtml
В частности, распознаются греческие буквы: α – \alpha, β – \beta, γ – \gamma, δ – \delta, ε – \epsilon, η – \eta, ι – \iota, χ – \chi, κ – \kappa, λ – \lambda, μ – \mu, ν – \nu, o – \o, ω – \omega, ϕ – \phi, π – \pi, ψ – \psi, ρ – \rho, σ – \sigma, θ – \theta, τ – \tau, υ – \upsilon, ξ – \xi, ζ – \zeta, ς – \varsigma, ɛ – \varepsilon, ϑ – \vartheta, φ – \varphi, ϰ – \varkappa; A – \Alpha, B – \Beta, Γ – \Gamma, Δ – \Delta, E – \Epsilon, H – \Eta, I – \Iota, C – \Chi, K – \Kappa, Λ – \Lambda, M – \Mu, N – \Nu, O – \O, Ω – \Omega, Φ – \Phi, Π – \Pi, Ψ – \Psi, R – \Rho, Σ – \Sigma, Θ – \Theta, T – \Tau, Υ – \Upsilon, Ξ – \Xi, Z – \Zeta.
<p>Еще примеры наиболее общеупотребительных TeX-их символов: ∠ – \angle, ⋅ – \cdot, ♣ – \clubsuit, ✓ – \checkmark, ∪ – \cup, ∩ – \cap, ♢ – \diamondsuit, ◇ – \diamond, ÷
- – \div,
+ – \div,
↓ – \downarrow, † – \dag, ‡ – \ddag, ≡ – \equiv, ∃ – \exists, ⌢ – \frown, ♭ – \flat, ≥ – \ge, ≥ – \geq, ≧ – \geqq, ← – \gets, ♡ – \heartsuit, ∞ – \infty, ∫ – \int, \Int, ℑ – \Im, ♢ – \lozenge, ⟨ – \langle, ≤ – \le, ≤ – \leq, ≦ – \leqq, ← – \leftarrow, ∓ – \mp, ∇ – \nabla, ≠ – \ne, ≠ – \neq, ♮ – \natural, ∮ – \oint, ⊙ – \odot, ⊕ – \oplus, ∂ – \partial, ∥ – \parallel, ⊥ –\perp, ± – \pm, ∝ – \propto, ∏ – \prod, ℜ – \Re, → – \rightarrow, ⟩ – \rangle, ♠ – \spadesuit, ~ – \sim, ⌣ – \smile, ⊂ – \subset, ⊃ – \supset, √ – \sqrt or \surd, § – \S, ♯ – \sharp, ∑ – \sum, × – \times, → – \to, ∴ – \therefore, ↑ – \uparrow, ℘ – \wp. </p>
@end html
@end ifhtml
Размер текста может быть задан явно (если @var{size}>0) или относительно базового размера шрифта для рисунка |@var{size}|*@var{FontSize} при @var{size}<0. Значение @var{size}=0 указывает, что соответствующая строка выводиться не будет. Базовый размер шрифта измеряется во внутренних единицах. Специальные функции @code{SetFontSizePT(), SetFontSizeCM(), SetFontSizeIN()} позволяют задавать его в более ``привычных'' единицах.
@c ------------------------------------------------------------------
+@external
@node Textual formulas, Command options, Font styles, General concepts
-@subsection Текстовые формулы
+@section Текстовые формулы
@cindex Текстовые формулы
MathGL имеет быстрый парсер текстовых формул
@ifclear UDAV
- (@pxref{mglFormula class})
+(@pxref{Evaluate expression})
@end ifclear
, понимающий большое число функций и операций. Базовые операции: @samp{+} -- сложение, @samp{-} -- вычитание, @samp{*} -- умножение, @samp{/} -- деление, @samp{^} -- возведение в целосичленную степень. Также есть логические операции: @samp{<} -- истина если if x<y, @samp{>} -- истина если x>y, @samp{=} -- истина если x=y, @samp{&} -- истина если x и y оба не равны нулю, @samp{|} -- истина если x или y не нуль. Логические операции имеют наинизший приоритет и возвращают 1 если истина или 0 если ложно.
Функции Якоби: @samp{sn(u,m)}, @samp{cn(u,m)}, @samp{dn(u,m)}, @samp{sc(u,m)}, @samp{sd(u,m)}, @samp{ns(u,m)}, @samp{cs(u,m)}, @samp{cd(u,m)}, @samp{nc(u,m)}, @samp{ds(u,m)}, @samp{dc(u,m)}, @samp{nd(u,m)}.
-Некоторые из функций могут быть недоступны если флаг NO_GSL был определен при компиляции библиотеки MathGL.
+Некоторые из функций могут быть недоступны если не была включена поддержка GSL при компиляции библиотеки MathGL.
При разборе формул нет различия между верхним и нижним регистром. Если аргумент лежит вне области определения функции, то возвращается NaN.
@c ------------------------------------------------------------------
-@node Command options, , Textual formulas, General concepts
-@section Command options
-
+@external
+@node Command options, Interfaces, Textual formulas, General concepts
@section Опции команд
Опции команд позволяют легко настроить вид отдельного графика не меняя глобальных настроек для все рисунка. Каждая опция отделяется от предыдущей символом @samp{;}. Опции работают так, что запоминают текущие настройки рисунка, применяют собственные настройки, выполняют команду и возвращают глобальные настройки обратно. Поэтому использование опций для команд обработки данных или настройки графика бесполезно.
@cindex alpha
@cindex alphadef
@deffn {Опция MGL} alpha @code{val}
-@deffnx {Опция MGL} alphadef @code{val}
Задает величину прозрачности поверхности. Значение должно быть в диапазоне [0, 1]. См. также @ref{alphadef}
@end deffn
@cindex ambient
@deffn {Опция MGL} ambient @code{val}
Задает яркость фонового освещения. Значение должно быть в диапазоне [0, 1]. См. также @ref{ambient}
@end deffn
-@cindex crange
-@deffn {Опция MGL} crange @code{val1 val2}
-Задает границы цветовой шкалы. См. также @ref{crange}
+@cindex diffuse
+@deffn {Опция MGL} diffuse @code{val}
+Задает яркость диффузного освещения для поверхности. Значение должно быть в диапазоне [0, 1]. См. также @ref{diffuse}.
@end deffn
+
@cindex xrange
@deffn {Опция MGL} xrange @code{val1 val2}
Задает границы изменения координаты x. См. также @ref{xrange}
@deffn {Опция MGL} zrange @code{val1 val2}
Задает границы изменения координаты z. См. также @ref{zrange}
@end deffn
+
@cindex cut
@deffn {Опция MGL} cut @code{val}
-Задает обрезание точек за пределами осей координат. См. также @ref{cut}
+Задает обрезание точек за пределами осей координат. См. также @ref{cut}.
@end deffn
@cindex fontsize
-@deffn {Опция MGL} fontsize @code{val}
-Задает размер текста. См. также @ref{font}
-@end deffn
-@cindex marksize
-@deffn {Опция MGL} marksize @code{val}
-Задает размер маркеров. См. также @ref{marksize}
+@deffn {Опция MGL} size @code{val}
+Задает размер текста, маркеров и стрелок. См. также @ref{font}, @ref{marksize}, @ref{arrowsize}.
@end deffn
@cindex meshnum
@deffn {Опция MGL} meshnum @code{val}
Задает ориентировочное число линий, стрелок, ячеек и пр. См. также @ref{meshnum}
@end deffn
+
@cindex legend
@deffn {Опция MGL} legend 'txt'
Добавляет строку 'txt' во внутренний массив записей легенды. Стиль линии и маркера аргумента последней вызванной команды построения @ref{1D plotting}. См. также @ref{legend}
@deffn {MGL option} value @code{val}
Задает значение, которое будет использовано как дополнительный числовой параметр при построении графика.
@end deffn
+
+
+
+@c ------------------------------------------------------------------
+@external
+@node Interfaces, , Command options, General concepts
+@section Интерфейсы
+
+@c TODO Translate it!!!
+
+@ifset UDAV
+You can use @code{mglParse} class for executing MGL scripts from different languages.
+@end ifset
+
+@ifclear UDAV
+
+The MathGL library has interfaces for a set of languages. Most of them are based on the C interface via SWIG tool. There are Python, Java, Octave, Lisp, C#, Guile, Lua, Modula 3, Ocaml, Perl, PHP, Pike, R, Ruby, and Tcl interfaces. Also there is a Fortran interface which has a similar set of functions, but slightly different types of arguments (integers instead of pointers). These functions are marked as [C function].
+
+Some of the languages listed above support classes (like C++ or Python). The name of functions for them is the same as in C++ (see @ref{MathGL core} and @ref{Data processing}) and marked like [Method on mglGraph].
+
+Finally, a special command language MGL (see @ref{MGL scripts}) was written for a faster access to plotting functions. Corresponding scripts can be executed separately (by UDAV, mglconv, mglview and so on) or from the C/C++/Python/... code (@pxref{mglParse class}).
+
+@menu
+* C interface::
+* C++ interface::
+@end menu
+
+@external
+@node C interface, C++ interface, , Interfaces
+@subsection C/Fortran interface
+
+The C interface is a base for many other interfaces. It contains the pure C functions for most of the methods of MathGL classes. In distinction to C++ classes, C functions must have an argument HMGL (for graphics) and/or HMDT (for data arrays), which specifies the object for drawing or manipulating (changing). So, firstly, the user has to create this object by the function @code{mgl_create_*()} and has to delete it after the use by function @code{mgl_delete_*()}.
+
+All C functions are described in the header file @code{#include <mgl2/mgl_cf.h>} and use variables of the following types:
+@itemize
+@item
+@code{HMGL} --- Pointer to class @code{mglGraph} (@pxref{MathGL core}).
+@item
+@code{HMDT} --- Pointer to class @code{mglData} (@pxref{Data processing}).
+@item
+@code{HMPR} --- Pointer to class @code{mglParse} (@pxref{mglParse class}).
+@end itemize
+These variables contain identifiers for graphics drawing objects and for the data objects.
+
+Fortran functions/subroutines have the same names as C functions. However, there is a difference. Variable of type @code{HMGL, HMDT} must be an integer with sufficient size (@code{integer*4} in the 32-bit operating system or @code{integer*8} in the 64-bit operating system). All C functions are subroutines in Fortran, which are called by operator @code{call}. The exceptions are functions, which return variables of types @code{HMGL} or @code{HMDT}. These functions should be declared as integer in Fortran code. Also, one should keep in mind that strings in Fortran are denoted by @code{'} symbol, not the @code{"} symbol.
+
+@external
+@node C++ interface, , C interface, Interfaces
+@subsection C++/Python interface
+
+MathGL provides the interface to a set of languages via SWIG library. Some of these languages support classes. The typical example is Python -- which is named in this chapter's title. Exactly the same classes are used for high-level C++ API. Its feature is using only inline member-functions what make high-level API to be independent on compiler even for binary build.
+
+There are 3 classes in:
+@itemize
+@item @code{mglGraph}
+-- provide most plotting functions (see @ref{MathGL core}).
+@item @code{mglData}
+-- provide base data processing (see @ref{Data processing}). It have an additional feature to access data values. You can use a construct like this: @code{dat[i]=sth;} or @code{sth=dat[i]} where flat representation of data is used (i.e., @var{i} can be in range 0...nx*nx*nz-1). You can also import NumPy arrays as input arguments in Python: @code{mgl_dat = mglData(numpy_dat);}.
+@item @code{mglParse}
+-- provide functions for parsing MGL scripts (see @ref{MGL scripts}).
+@end itemize
+
+
+To use Python classes just execute @samp{import mathgl}. The simplest example will be:
+@verbatim
+import mathgl
+a=mathgl.mglGraph()
+a.Box()
+a.WritePNG("test.png")
+@end verbatim
+Alternatively you can import all classes from @code{mathgl} module and easily access MathGL classes like this:
+@verbatim
+from mathgl import *
+a=mglGraph()
+a.Box()
+a.WritePNG("test.png")
+@end verbatim
+This becomes useful if you create many @code{mglData} objects, for example.
+
+@end ifclear
+
+@external
+
* Other plotting::
* Nonlinear fitting::
* Data manipulation::
-* IDTF functions::
+@c * IDTF functions::
@end menu
@c ##################################################################
+@external
@node Constructor, Graphics setup, , MathGL core
@section Create and delete objects
@end ifset
@c ##################################################################
+@external
@node Graphics setup, Axis settings, Constructor, MathGL core
@section Graphics setup
@cindex MathGL setup
@end menu
@c ==================================================================
+@external
@node Transparency, Lighting, , Graphics setup
@subsection Transparency
@cindex Alpha
@anchor{alphadef}
@deftypefn {MGL command} {} alphadef @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetAlphaDef (@code{float} val)
-@deftypefnx {C function} @code{void} mgl_set_alpha_default (@code{HMGL} gr, @code{float} alpha)
+@deftypefnx {Method on @code{mglGraph}} @code{void} SetAlphaDef (@code{mreal} val)
+@deftypefnx {C function} @code{void} mgl_set_alpha_default (@code{HMGL} gr, @code{mreal} alpha)
@end ifclear
Sets default value of alpha channel (transparency) for all plotting functions. Initial value is 0.5.
@end deftypefn
@end deftypefn
@c ==================================================================
+@external
@node Lighting, Fog, Transparency, Graphics setup
@subsection Lighting
@ifclear UDAV
@cindex Light
@cindex Ambient
-There are several functions for setup lighting. The general function is @code{Light(bool)} which switch on/off the lighting for overall plot. It influence only for graphics which created after @ref{light} call (with one exception, OpenGL). Generally MathGL support up to 10 independent light sources. But in OpenGL mode only 8 of light sources is used due to OpenGL limitations. The position, color, brightness of each light source can be set separately. By default only one light source is active. It is source number @code{0} with white color, located at top of the plot.
+There are several functions for setup lighting. The general function is @ref{light} which switch on/off the lighting for overall plot. It influence only for graphics which created after @ref{light} call (with one exception, OpenGL). Generally MathGL support up to 10 independent light sources. But in OpenGL mode only 8 of light sources is used due to OpenGL limitations. The position, color, brightness of each light source can be set separately. By default only one light source is active. It is source number @code{0} with white color, located at top of the plot.
@anchor{light}
@deftypefn {MGL command} {} light @code{[val=on]}
@deftypefn {MGL command} {} light @code{num xdir ydir zdir} ['col'='w' @code{br=0.5}]
@deftypefnx {MGL command} {} light @code{num xdir ydir zdir xpos ypos zpos} ['col'='w' @code{br=0.5}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} AddLight (@code{int} n, @code{mglPoint} d, @code{char} c=@code{'w'}, @code{float} bright=@code{0.5}, @code{float} ap=@code{0})
-@deftypefnx {Method on @code{mglGraph}} @code{void} AddLight (@code{int} n, @code{mglPoint} r, @code{mglPoint} d, @code{char} c=@code{'w'}, @code{float} bright=@code{0.5}, @code{float} ap=@code{0})
-@deftypefnx {C function} @code{void} mgl_add_light (@code{HMGL} gr, @code{int} n, @code{float} dx, @code{float} dy, @code{float} dz)
-@deftypefnx {C function} @code{void} mgl_add_light_ext (@code{HMGL} gr, @code{int} n, @code{float} dx, @code{float} dy, @code{float} dz, @code{char} c, @code{float} bright, @code{float} ap)
-@deftypefnx {C function} @code{void} mgl_add_light_loc (@code{HMGL} gr, @code{int} n, @code{float} rx, @code{float} ry, @code{float} rz, @code{float} dx, @code{float} dy, @code{float} dz, @code{char} c, @code{float} bright, @code{float} ap)
+@deftypefnx {Method on @code{mglGraph}} @code{void} AddLight (@code{int} n, @code{mglPoint} d, @code{char} c=@code{'w'}, @code{mreal} bright=@code{0.5}, @code{mreal} ap=@code{0})
+@deftypefnx {Method on @code{mglGraph}} @code{void} AddLight (@code{int} n, @code{mglPoint} r, @code{mglPoint} d, @code{char} c=@code{'w'}, @code{mreal} bright=@code{0.5}, @code{mreal} ap=@code{0})
+@deftypefnx {C function} @code{void} mgl_add_light (@code{HMGL} gr, @code{int} n, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz)
+@deftypefnx {C function} @code{void} mgl_add_light_ext (@code{HMGL} gr, @code{int} n, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{char} c, @code{mreal} bright, @code{mreal} ap)
+@deftypefnx {C function} @code{void} mgl_add_light_loc (@code{HMGL} gr, @code{int} n, @code{mreal} rx, @code{mreal} ry, @code{mreal} rz, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{char} c, @code{mreal} bright, @code{mreal} ap)
@end ifclear
The function adds a light source with identification @var{n} in direction @var{d} with color @var{c} and with brightness @var{bright} (which must be in range [0,1]). If position @var{r} is specified and isn't NAN then light source is supposed to be local otherwise light source is supposed to be placed at infinity.
@end deftypefn
@anchor{ambient}
@deftypefn {MGL command} {} ambient @code{val}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetAmbient (@code{float} bright=@code{0.5})
-@deftypefnx {Функция С} @code{void} mgl_set_ambbr (@code{HMGL} gr, @code{float} bright)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetAmbient (@code{mreal} bright=@code{0.5})
+@deftypefnx {Функция С} @code{void} mgl_set_ambbr (@code{HMGL} gr, @code{mreal} bright)
@end ifclear
Sets the brightness of ambient light. The value should be in range [0,1].
@end deftypefn
@c ==================================================================
+@external
@node Fog, Default sizes, Lighting, Graphics setup
@subsection Fog
@cindex Fog
@anchor{fog}
@deftypefn {MGL command} {} fog @code{val [dz=0.25]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Fog (@code{float} d, @code{float} dz=@code{0.25})
-@deftypefnx {C function} @code{void} mgl_set_fog (@code{HMGL} gr, @code{float} d, @code{float} dz)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Fog (@code{mreal} d, @code{mreal} dz=@code{0.25})
+@deftypefnx {C function} @code{void} mgl_set_fog (@code{HMGL} gr, @code{mreal} d, @code{mreal} dz)
@end ifclear
Function imitate a fog in the plot. Fog start from relative distance @var{dz} from view point and its density growths exponentially in depth. So that the fog influence is determined by law ~ 1-exp(-@emph{d*z}). Here @emph{z} is normalized to 1 depth of the plot. If value @var{d}=@code{0} then the fog is absent. Note, that fog was applied at stage of image creation, not at stage of drawing. @sref{Adding fog}
@end deftypefn
@c ==================================================================
+@external
@node Default sizes, Cutting, Fog, Graphics setup
@subsection Default sizes
@ifclear UDAV
@anchor{barwidth}
@deftypefn {MGL command} {} barwidth @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetBarWidth ( @code{float} val)
-@deftypefnx {C function} @code{void} mgl_set_bar_width (@code{HMGL} gr, @code{float} val)
+@deftypefnx {Method on @code{mglGraph}} @code{void} SetBarWidth ( @code{mreal} val)
+@deftypefnx {C function} @code{void} mgl_set_bar_width (@code{HMGL} gr, @code{mreal} val)
@end ifclear
Sets relative width of rectangles in @ref{bars}, @ref{barh}, @ref{boxplot}, @ref{candle}. Default value is @code{0.7}.
@end deftypefn
@anchor{marksize}
@deftypefn {MGL command} {} marksize @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetMarkSize (@code{float} val)
-@deftypefnx {C function} @code{void} mgl_set_mark_size (@code{HMGL} gr, @code{float} val)
+@deftypefnx {Method on @code{mglGraph}} @code{void} SetMarkSize (@code{mreal} val)
+@deftypefnx {C function} @code{void} mgl_set_mark_size (@code{HMGL} gr, @code{mreal} val)
@end ifclear
-Sets size of marks for @ref{1D plotting}. Default value is @code{0.02}.
+Sets size of marks for @ref{1D plotting}. Default value is @code{1}.
@end deftypefn
@anchor{arrowsize}
@deftypefn {MGL command} {} arrowsize @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetArrowSize (@code{float} val)
-@deftypefnx {C function} @code{void} mgl_set_arrow_size (@code{HMGL} gr, @code{float} val)
+@deftypefnx {Method on @code{mglGraph}} @code{void} SetArrowSize (@code{mreal} val)
+@deftypefnx {C function} @code{void} mgl_set_arrow_size (@code{HMGL} gr, @code{mreal} val)
@end ifclear
-Sets size of arrows for @ref{1D plotting}, lines and curves (see @ref{Primitives}). Default value is @code{0.03}.
+Sets size of arrows for @ref{1D plotting}, lines and curves (see @ref{Primitives}). Default value is @code{1}.
@end deftypefn
@anchor{meshnum}
@end deftypefn
@c ==================================================================
+@external
@node Cutting, Font settings, Default sizes, Graphics setup
@subsection Cutting
@ifclear UDAV
@deftypefn {MGL command} {} cut @code{x1 y1 z1 x2 y2 z2}
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} SetCutBox (@code{mglPoint} p1, @code{mglPoint} p1)
-@deftypefnx {C function} @code{void} mgl_set_cut_box (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2)
+@deftypefnx {C function} @code{void} mgl_set_cut_box (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2)
@end ifclear
Lower and upper edge of the box in which never points are drawn. If both edges are the same (the variables are equal) then the cutting box is empty.
@end deftypefn
@end deftypefn
@c ==================================================================
+@external
@node Font settings, Palette and colors, Cutting, Graphics setup
@subsection Font settings
@ifclear UDAV
@anchor{rotatetext}
@deftypefn {MGL command} {} rotatetext @code{val}
+@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} SetRotatedText (@code{bool} val)
@deftypefnx {C function} @code{void} mgl_set_rotated_text (@code{HMGL} gr, @code{int} val)
+@end ifclear
Sets to use or not text rotation.
@end deftypefn
Sets the font specification (see @ref{Text printing}). Default is @samp{rC} -- Roman font centering.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} SetFontSize (@code{float} val)
-@deftypefnx {C function} @code{void} mgl_set_font_size (@code{HMGL} gr, @code{float} val)
+@deftypefn {Method on @code{mglGraph}} @code{void} SetFontSize (@code{mreal} val)
+@deftypefnx {C function} @code{void} mgl_set_font_size (@code{HMGL} gr, @code{mreal} val)
Sets the size of font for tick and axis labels. Default font size of axis labels is 1.4 times large than for tick labels.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} SetFontSizePT (@code{float} cm, @code{int} dpi=@code{72})
+@deftypefn {Method on @code{mglGraph}} @code{void} SetFontSizePT (@code{mreal} cm, @code{int} dpi=@code{72})
Set FontSize by size in pt and picture DPI (default is 16 pt for dpi=72).
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{inline void} SetFontSizeCM (@code{float} cm, @code{int} dpi=@code{72})
+@deftypefn {Method on @code{mglGraph}} @code{inline void} SetFontSizeCM (@code{mreal} cm, @code{int} dpi=@code{72})
Set FontSize by size in centimeters and picture DPI (default is 0.56 cm = 16 pt).
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{inline void} SetFontSizeIN (@code{float} cm, @code{int} dpi=@code{72})
+@deftypefn {Method on @code{mglGraph}} @code{inline void} SetFontSizeIN (@code{mreal} cm, @code{int} dpi=@code{72})
Set FontSize by size in inch and picture DPI (default is 0.22 in = 16 pt).
@end deftypefn
@deftypefnx {C function} @code{void} mgl_restore_font (@code{HMGL} gr)
Restore font data to default typeface.
@end deftypefn
+
@end ifclear
@c ==================================================================
+@external
@node Palette and colors, Error handling, Font settings, Graphics setup
@subsection Palette and colors
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} SetPalette (@code{const char *}colors)
@deftypefnx {C function} @code{void} mgl_set_palette (@code{HMGL} gr, @code{const char *}colors)
@end ifclear
-Sets the palette as selected colors. Default value is @code{"Hbgrcmyhlnqeup"} that corresponds to colors: dark gray @samp{H}, blue @samp{b}, green @samp{g}, red @samp{r}, cyan @samp{c}, magenta @samp{m}, yellow @samp{y}, gray @samp{h}, blue-green @samp{l}, sky-blue @samp{n}, orange @samp{q}, yellow-green @samp{e}, blue-violet @samp{u}, purple @samp{p}. The palette is used mostly in 1D plots (see @ref{1D plotting}) for curves which styles are not specified. Internal color counter will be nullified by any change of palette. This includes even hidden change (for example, by @code{Box()} or @code{Axis()} functions).
+Sets the palette as selected colors. Default value is @code{"Hbgrcmyhlnqeup"} that corresponds to colors: dark gray @samp{H}, blue @samp{b}, green @samp{g}, red @samp{r}, cyan @samp{c}, magenta @samp{m}, yellow @samp{y}, gray @samp{h}, blue-green @samp{l}, sky-blue @samp{n}, orange @samp{q}, yellow-green @samp{e}, blue-violet @samp{u}, purple @samp{p}. The palette is used mostly in 1D plots (see @ref{1D plotting}) for curves which styles are not specified. Internal color counter will be nullified by any change of palette. This includes even hidden change (for example, by @ref{box} or @ref{axis} functions).
@end deftypefn
@ifclear UDAV
Sets the @var{sch} as default color scheme. Default value is @code{"BbcyrR"}.
@end deftypefn
-@deftypefn {C function} @code{void} mgl_set_color (@code{char} id, @code{float} r, @code{float} g, @code{float} b)
+@deftypefn {C function} @code{void} mgl_set_color (@code{char} id, @code{mreal} r, @code{mreal} g, @code{mreal} b)
Sets RGB values for color with given @var{id}.
@end deftypefn
@end ifclear
@c ==================================================================
+@external
@node Error handling, , Palette and colors, Graphics setup
@subsection Error handling
@ifclear UDAV
@c ==================================================================
+@external
@node Axis settings, Subplots and rotation, Graphics setup, MathGL core
@section Axis settings
@end menu
@c ------------------------------------------------------------------
+@external
@node Ranges (bounding box), Curved coordinates, , Axis settings
@subsection Ranges (bounding box)
@cindex CRange
@deftypefnx {MGL command} {} zrange @code{v1 v2}
@deftypefnx {MGL command} {} crange @code{v1 v2}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetRange (@code{char} dir, @code{float} v1, @code{float} v2)
-@deftypefnx {C function} @code{void} mgl_set_range_val (@code{HMGL} gr, @code{char} dir, @code{float} v1, @code{float} v2)
+@deftypefnx {Method on @code{mglGraph}} @code{void} SetRange (@code{char} dir, @code{mreal} v1, @code{mreal} v2)
+@deftypefnx {C function} @code{void} mgl_set_range_val (@code{HMGL} gr, @code{char} dir, @code{mreal} v1, @code{mreal} v2)
@end ifclear
Sets the range for @samp{x}-,@samp{y}-,@samp{z}- coordinate or coloring (@samp{c}). See also @ref{ranges}.
@end deftypefn
@deftypefn {MGL command} {} ranges @code{x1 x2 y1 y2 [z1=0 z2=0]}
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} SetRanges (@code{mglPoint} p1, @code{mglPoint} p2)
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetRanges (@code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{float} z1=@code{0}, @code{float} z2=@code{0})
-@deftypefnx {C function} @code{void} mgl_set_ranges (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{float} z1, @code{float} z2)
+@deftypefnx {Method on @code{mglGraph}} @code{void} SetRanges (@code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2, @code{mreal} z1=@code{0}, @code{mreal} z2=@code{0})
+@deftypefnx {C function} @code{void} mgl_set_ranges (@code{HMGL} gr, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2, @code{mreal} z1, @code{mreal} z2)
@end ifclear
Sets the ranges of coordinates. If minimal and maximal values of the coordinate are the same then they are ignored. Also it sets the range for coloring (analogous to @code{crange z1 z2}). This is default color range for 2d plots. Initial ranges are [-1, 1].
@end deftypefn
@deftypefn {Method on @code{mglGraph}} @code{void} SetRanges (@code{const mglData &}xx, @code{const mglData &}yy)
@deftypefnx {Method on @code{mglGraph}} @code{void} SetRanges (@code{const mglData &}xx, @code{const mglData &}yy, @code{const mglData &}zz)
@deftypefnx {Method on @code{mglGraph}} @code{void} SetRanges (@code{const mglData &}xx, @code{const mglData &}yy, @code{const mglData &}zz, @code{const mglData &}cc)
-Sets the ranges of x-,y-,z-coordinates and coloring as minimal and maximal values of data @var{xx}, @var{yy}, @var{zz}, @var{cc} correspondingly.
+Sets the ranges of @samp{x}-,@samp{y}-,@samp{z}-coordinates and coloring as minimal and maximal values of data @var{xx}, @var{yy}, @var{zz}, @var{cc} correspondingly.
@end deftypefn
@end ifclear
@deftypefn {MGL command} {} origin @code{x0 y0 [z0=nan]}
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} SetOrigin (@code{mglPoint} p0)
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetOrigin (@code{float} x0, @code{float} y0, @code{float} z0=@code{NAN})
-@deftypefnx {C function} @code{void} mgl_set_origin (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0)
+@deftypefnx {Method on @code{mglGraph}} @code{void} SetOrigin (@code{mreal} x0, @code{mreal} y0, @code{mreal} z0=@code{NAN})
+@deftypefnx {C function} @code{void} mgl_set_origin (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0)
@end ifclear
Sets center of axis cross section. If one of values is NAN then MathGL try to select optimal axis position.
@end deftypefn
-
@c ------------------------------------------------------------------
+@external
@node Curved coordinates, Ticks, Ranges (bounding box), Axis settings
@subsection Curved coordinates
@cindex Axis
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Ticks, , Curved coordinates, Axis settings
@subsection Ticks
@cindex AxisStl
@deftypefnx {MGL command} {} ztick @code{val [sub=0 org=nan]}
@deftypefnx {MGL command} {} ctick @code{val [sub=0 org=nan]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTicks (@code{char} dir, @code{float} d=@code{0}, @code{int} ns=@code{0}, @code{float} org=@code{NAN})
-@deftypefnx {C function} @code{void} mgl_set_ticks_dir (@code{HMGL} gr, @code{char} dir, @code{float} d, @code{int} ns, @code{float} org)
+@deftypefnx {Method on @code{mglGraph}} @code{void} SetTicks (@code{char} dir, @code{mreal} d=@code{0}, @code{int} ns=@code{0}, @code{mreal} org=@code{NAN})
+@deftypefnx {C function} @code{void} mgl_set_ticks_dir (@code{HMGL} gr, @code{char} dir, @code{mreal} d, @code{int} ns, @code{mreal} org)
@deftypefnx {C function} @code{void} mgl_set_ticks (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} nz)
@end ifclear
-Set the ticks step @var{d}, number of sub-ticks @var{ns} and initial ticks position @var{org} for the axis along direction @var{dir} (use 'c' for colorbar ticks). Variable @var{d} set step for axis ticks (if positive) or it's number on the axis range (if negative). Zero value set automatic ticks. If @var{org} value is NAN then axis origin is used.
+Set the ticks step @var{d}, number of sub-ticks @var{ns} (used for positive @var{d}) and initial ticks position @var{org} for the axis along direction @var{dir} (use 'c' for colorbar ticks). Variable @var{d} set step for axis ticks (if positive) or it's number on the axis range (if negative). Zero value set automatic ticks. If @var{org} value is NAN then axis origin is used.
@end deftypefn
@deftypefn {MGL command} {} xtick @code{val1} 'lbl1' [@code{val2} 'lbl2' ...]
@deftypefn {MGL command} {} ticktime 'dir' [@code{dv} 'tmpl']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTicksTime (@code{char} dir, @code{float} val, @code{const char *}templ)
-@deftypefnx {C function} @code{void} mgl_set_ticks_time (@code{HMGL} gr, @code{float} val, @code{const char *}templ)
+@deftypefnx {Method on @code{mglGraph}} @code{void} SetTicksTime (@code{char} dir, @code{mreal} val, @code{const char *}templ)
+@deftypefnx {C function} @code{void} mgl_set_ticks_time (@code{HMGL} gr, @code{mreal} val, @code{const char *}templ)
@end ifclear
Set time labels with step @var{val} and template @var{templ} for x-,y-,z-axis ticks or colorbar ticks. It may contain TeX symbols also. The format of template @var{templ} is the same as described in @url{http://www.manpagez.com/man/3/strftime/}. Most common variants are @samp{%X} for national representation of time, @samp{%x} for national representation of date, @samp{%Y} for year with century. If @var{val}=0 and/or @var{templ}="" then automatic tick step and/or template will be selected.
@end deftypefn
@deftypefn {MGL command} {} tuneticks @code{val} [@code{pos=1.15}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTuneTicks (@code{int} tune, @code{float} pos=@code{1.15})
-@deftypefnx {C function} @code{void} mgl_tune_ticks (@code{HMGL} gr, @code{int} tune, @code{float} pos)
+@deftypefnx {Method on @code{mglGraph}} @code{void} SetTuneTicks (@code{int} tune, @code{mreal} pos=@code{1.15})
+@deftypefnx {C function} @code{void} mgl_tune_ticks (@code{HMGL} gr, @code{int} tune, @code{mreal} pos)
@end ifclear
Switch on/off ticks enhancing by factoring common multiplier (for small, like from 0.001 to 0.002, or large, like from 1000 to 2000, coordinate values -- enabled if @var{tune}&1 is nonzero) or common component (for narrow range, like from 0.999 to 1.000 -- enabled if @var{tune}&2 is nonzero). Also set the position @var{pos} of common multiplier/component on the axis: =0 at minimal axis value, =1 at maximal axis value. Default value is 1.15.
@end deftypefn
@ifclear UDAV
+
+@deftypefn {Method on @code{mglGraph}} @code{void} SetTickShift (@code{mglPoint} d)
+@deftypefnx {C function} @code{void} mgl_set_tick_shift (@code{HMGL} gr, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{mreal} dc)
+Set value of additional shift for ticks labels.
+@end deftypefn
+
@deftypefn {Method on @code{mglGraph}} @code{void} SetTickRotate (@code{bool} val)
@deftypefnx {C function} @code{void} mgl_set_tick_rotate (@code{HMGL} gr, @code{bool} val)
Enable/disable ticks rotation if there are too many ticks or ticks labels are too long.
@deftypefnx {C function} @code{void} mgl_set_tick_skip (@code{HMGL} gr, @code{bool} val)
Enable/disable ticks skipping if there are too many ticks or ticks labels are too long.
@end deftypefn
+
+@deftypefn {Method on @code{mglGraph}} @code{void} SetTimeUTC (@code{bool} val)
+@c @deftypefnx {C function} @code{void} mgl_set_tick_skip (@code{HMGL} gr, @code{bool} val)
+Enable/disable using UTC time for ticks labels. In C/Fortran you can use @code{mgl_set_flag(gr,val, MGL_USE_GMTIME);}.
+@end deftypefn
+
@end ifclear
@anchor{ticklen}
@deftypefn {MGL command} {} ticklen @code{val} [@code{stt=1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SetTickLen (@code{float} val, @code{float} stt=@code{1})
-@deftypefnx {C function} @code{void} mgl_set_tick_len (@code{HMGL} gr, @code{float} val, @code{float} stt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} SetTickLen (@code{mreal} val, @code{mreal} stt=@code{1})
+@deftypefnx {C function} @code{void} mgl_set_tick_len (@code{HMGL} gr, @code{mreal} val, @code{mreal} stt)
@end ifclear
The relative length of axis ticks. Default value is @code{0.1}. Parameter @var{stt}>0 set relative length of subticks which is in @code{sqrt(1+stt)} times smaller.
@end deftypefn
@deftypefnx {Method on @code{mglGraph}} @code{void} SetAxisStl (@code{const char *}stl=@code{"k"}, @code{const char *}tck=@code{0}, @code{const char *}sub=@code{0})
@deftypefnx {C function} @code{void} mgl_set_axis_stl (@code{HMGL} gr, @code{const char *}stl, @code{const char *}tck, @code{const char *}sub)
@end ifclear
-The line style of axis, (@var{stl}) ticks (@var{tck}) and subticks (@var{sub}). If @var{stl} is empty then default style is used (@samp{k} or @samp{w} depending on transparency type). If @var{sub} or @var{sub} is empty then axis style is used (i.e. @var{stl}).
+The line style of axis (@var{stl}), ticks (@var{tck}) and subticks (@var{sub}). If @var{stl} is empty then default style is used (@samp{k} or @samp{w} depending on transparency type). If @var{tck} or @var{sub} is empty then axis style is used (i.e. @var{stl}).
@end deftypefn
@c ##################################################################
+@external
@node Subplots and rotation, Export picture, Axis settings, MathGL core
@section Subplots and rotation
@cindex Aspect
@anchor{subplot}
@deftypefn {MGL command} {} subplot @code{nx ny m ['stl'='<>_^' dx=0 dy=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} SubPlot (@code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl=@code{"<>_^"}, @code{float} dx=@code{0}, @code{float} dy=@code{0})
+@deftypefnx {Method on @code{mglGraph}} @code{void} SubPlot (@code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl=@code{"<>_^"}, @code{mreal} dx=@code{0}, @code{mreal} dy=@code{0})
@deftypefnx {C function} @code{void} mgl_subplot (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl)
-@deftypefnx {C function} @code{void} mgl_subplot_d (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl, @code{float} dx, @code{float} dy)
+@deftypefnx {C function} @code{void} mgl_subplot_d (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl, @code{mreal} dx, @code{mreal} dy)
@end ifclear
Puts further plotting in a @var{m}-th cell of @var{nx}*@var{ny} grid of the whole frame area. This function set off any aspects or rotations. So it should be used first for creating the subplot. Extra space will be reserved for axis/colorbar if @var{stl} contain:
@itemize @bullet
@anchor{inplot}
@deftypefn {MGL command} {} inplot @code{x1 x2 y1 y2 [rel=off]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} InPlot (@code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{bool} rel=@code{false})
-@deftypefnx {C function} @code{void} mgl_inplot (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2)
-@deftypefnx {C function} @code{void} mgl_relplot (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2)
+@deftypefnx {Method on @code{mglGraph}} @code{void} InPlot (@code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2, @code{bool} rel=@code{false})
+@deftypefnx {C function} @code{void} mgl_inplot (@code{HMGL} gr, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2)
+@deftypefnx {C function} @code{void} mgl_relplot (@code{HMGL} gr, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2)
@end ifclear
Puts further plotting in some region of the whole frame surface. This function allows one to create a plot in arbitrary place of the screen. The position is defined by rectangular coordinates [@var{x1}, @var{x2}]*[@var{y1}, @var{y2}]. The coordinates @var{x1}, @var{x2}, @var{y1}, @var{y2} are normalized to interval [0, 1]. If parameter @var{rel}=@code{true} then the relative position to current @ref{subplot} (or @ref{inplot} with @var{rel}=@code{false}) is used. This function set off any aspects or rotations. So it should be used first for creating subplot.
@end deftypefn
@anchor{columnplot}
@deftypefn {MGL command} {} columnplot @code{num ind [d=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} ColumnPlot (@code{int} num, @code{int} ind, @code{float} d=@code{0})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ColumnPlot (@code{int} num, @code{int} ind, @code{mreal} d=@code{0})
@deftypefnx {C function} @code{void} mgl_columnplot (@code{HMGL} gr, @code{int} num, @code{int} ind)
-@deftypefnx {C function} @code{void} mgl_columnplot_d (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{float} d)
+@deftypefnx {C function} @code{void} mgl_columnplot_d (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{mreal} d)
@end ifclear
Puts further plotting in @var{ind}-th cell of column with @var{num} cells. The position is relative to previous @ref{subplot} (or @ref{inplot} with @var{rel}=@code{false}). Parameter @var{d} set extra gap between cells.
@end deftypefn
@anchor{gridplot}
@deftypefn {MGL command} {} gridplot @code{nx ny ind [d=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} GridPlot (@code{int} nx, @code{int} ny, @code{int} ind, @code{float} d=@code{0})
+@deftypefnx {Method on @code{mglGraph}} @code{void} GridPlot (@code{int} nx, @code{int} ny, @code{int} ind, @code{mreal} d=@code{0})
@deftypefnx {C function} @code{void} mgl_gridplot (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} ind)
-@deftypefnx {C function} @code{void} mgl_gridplot_d (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} ind, @code{float} d)
+@deftypefnx {C function} @code{void} mgl_gridplot_d (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} ind, @code{mreal} d)
@end ifclear
Puts further plotting in @var{ind}-th cell of @var{nx}*@var{ny} grid. The position is relative to previous @ref{subplot} (or @ref{inplot} with @var{rel}=@code{false}). Parameter @var{d} set extra gap between cells.
@end deftypefn
@anchor{stickplot}
@deftypefn {MGL command} {} stickplot @code{num ind tet phi}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} StickPlot (@code{int} num, @code{int} ind, @code{float} tet, @code{float} phi)
-@deftypefnx {C function} @code{void} mgl_stickplot (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{float} tet, @code{float} phi)
+@deftypefnx {Method on @code{mglGraph}} @code{void} StickPlot (@code{int} num, @code{int} ind, @code{mreal} tet, @code{mreal} phi)
+@deftypefnx {C function} @code{void} mgl_stickplot (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{mreal} tet, @code{mreal} phi)
@end ifclear
Puts further plotting in @var{ind}-th cell of stick with @var{num} cells. At this, stick is rotated on angles @var{tet}, @var{phi}. The position is relative to previous @ref{subplot} (or @ref{inplot} with @var{rel}=@code{false}).
@end deftypefn
@anchor{title}
@deftypefn {MGL command} {} title 'title' ['stl'='' @code{size=-2}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Title (@code{const char *}txt, @code{const char *}stl=@code{""}, @code{float} size=@code{-2})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Title (@code{const wchar_t *}txt, @code{const char *}stl=@code{""}, @code{float} size=@code{-2})
-@deftypefnx {C function} @code{void} mgl_title (@code{HMGL} gr, @code{const char *}txt, @code{const char *}stl, @code{float} size)
-@deftypefnx {C function} @code{void} mgl_titlew (@code{HMGL} gr, @code{const wchar_t *}txt, @code{const char *}stl, @code{float} size)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Title (@code{const char *}txt, @code{const char *}stl=@code{""}, @code{mreal} size=@code{-2})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Title (@code{const wchar_t *}txt, @code{const char *}stl=@code{""}, @code{mreal} size=@code{-2})
+@deftypefnx {C function} @code{void} mgl_title (@code{HMGL} gr, @code{const char *}txt, @code{const char *}stl, @code{mreal} size)
+@deftypefnx {C function} @code{void} mgl_titlew (@code{HMGL} gr, @code{const wchar_t *}txt, @code{const char *}stl, @code{mreal} size)
@end ifclear
Add text @var{title} for current subplot/inplot. Paramater @var{stl} can contain:
@itemize @bullet
@anchor{rotate}
@deftypefn {MGL command} {} rotate @code{tetz tetx [tety=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Rotate (@code{float} TetX, @code{float} TetZ, @code{float} TetY=@code{0})
-@deftypefnx {C function} @code{void} mgl_rotate (@code{HMGL} gr, @code{float} TetX, @code{float} TetZ, @code{float} TetY)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Rotate (@code{mreal} TetX, @code{mreal} TetZ, @code{mreal} TetY=@code{0})
+@deftypefnx {C function} @code{void} mgl_rotate (@code{HMGL} gr, @code{mreal} TetX, @code{mreal} TetZ, @code{mreal} TetY)
@end ifclear
Rotates a further plotting relative to each axis @{x, z, y@} consecutively on angles @var{TetX}, @var{TetZ}, @var{TetY}.
@end deftypefn
@deftypefn {MGL command} {} rotate @code{tet x y z}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} RotateN (@code{float} Tet, @code{float} x, @code{float} y, @code{float} z)
-@deftypefnx {C function} @code{void} mgl_rotate_vector (@code{HMGL} gr, @code{float Tet}, @code{float x}, @code{float y}, @code{float z})
+@deftypefnx {Method on @code{mglGraph}} @code{void} RotateN (@code{mreal} Tet, @code{mreal} x, @code{mreal} y, @code{mreal} z)
+@deftypefnx {C function} @code{void} mgl_rotate_vector (@code{HMGL} gr, @code{mreal Tet}, @code{mreal x}, @code{mreal y}, @code{mreal z})
@end ifclear
Rotates a further plotting around vector @{@var{x}, @var{y}, @var{z}@} on angle @var{Tet}.
@end deftypefn
@anchor{aspect}
@deftypefn {MGL command} {} aspect @code{ax ay [az=1]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Aspect (@code{float} Ax, @code{float} Ay, @code{float} Az=@code{1})
-@deftypefnx {C function} @code{void} mgl_aspect (@code{HMGL} gr, @code{float} Ax, @code{float} Ay, @code{float} Az)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Aspect (@code{mreal} Ax, @code{mreal} Ay, @code{mreal} Az=@code{1})
+@deftypefnx {C function} @code{void} mgl_aspect (@code{HMGL} gr, @code{mreal} Ax, @code{mreal} Ay, @code{mreal} Az)
@end ifclear
Defines aspect ratio for the plot. The viewable axes will be related one to another as the ratio @var{Ax:Ay:Az}. For the best effect it should be used after @ref{rotate} function.
@end deftypefn
@anchor{perspective}
@deftypefn {MGL command} {} perspective @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Perspective (@code{float} a)
-@deftypefnx {C function} @code{void} mgl_perspective (@code{HMGL} gr, @code{float} a)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Perspective (@code{mreal} a)
+@deftypefnx {C function} @code{void} mgl_perspective (@code{HMGL} gr, @code{mreal} a)
@end ifclear
Add (switch on) the perspective to plot. The parameter @math{a ~ 1/z_@{eff@} \in [0,1)}. By default (@code{a=0}) the perspective is off.
@end deftypefn
@deftypefn {Method on @code{mglGraph}} @code{void} Push ()
@deftypefnx {C function} @code{void} mgl_mat_push (@code{HMGL} gr)
-Push transformation matrix into stack. Later you can restore its current state by Pop() function. Stack can keep up to 10 matrices.
+Push transformation matrix into stack. Later you can restore its current state by Pop() function.
@end deftypefn
@deftypefn {Method on @code{mglGraph}} @code{void} Pop ()
Pop (restore last 'pushed') transformation matrix into stack.
@end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} SetPlotFactor (@code{float} val)
-@deftypefnx {C function} @code{void} mgl_set_plotfactor (@code{HMGL} gr, @code{float} val)
+@deftypefn {Method on @code{mglGraph}} @code{void} SetPlotFactor (@code{mreal} val)
+@deftypefnx {C function} @code{void} mgl_set_plotfactor (@code{HMGL} gr, @code{mreal} val)
Sets the factor of plot size. It is not recommended to set it lower then 1.5. This is some analogue of function Zoom() but applied not to overall image but for each InPlot. Use negative value or zero to enable automatic selection.
@end deftypefn
There are 2 functions @code{View()} and @code{Zoom()} which transform whole image. I.e. they act as secondary transformation matrix. They were introduced for rotating/zooming the whole plot by mouse.
-@deftypefn {Method on @code{mglGraph}} @code{void} View (@code{float} TetX, @code{float} TetZ, @code{float} TetY=@code{0})
-@deftypefnx {C function} @code{void} mgl_view (@code{HMGL} gr, @code{float} TetX, @code{float} TetZ, @code{float} TetY)
+@deftypefn {Method on @code{mglGraph}} @code{void} View (@code{mreal} TetX, @code{mreal} TetZ, @code{mreal} TetY=@code{0})
+@deftypefnx {C function} @code{void} mgl_view (@code{HMGL} gr, @code{mreal} TetX, @code{mreal} TetZ, @code{mreal} TetY)
Rotates a further plotting relative to each axis @{x, z, y@} consecutively on angles @var{TetX}, @var{TetZ}, @var{TetY}. Rotation is done independently on @ref{rotate}. Use @code{Zoom(0,0,1,1)} to return default view.
@end deftypefn
-@deftypefn {Method on @code{mglGraph} (C++, Python)} @code{void} Zoom (@code{float} x1, @code{float} y1, @code{float} x2, @code{float} y2)
-@deftypefnx {C function} @code{void} mgl_set_zoom (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} x2, @code{float} y2)
+@deftypefn {Method on @code{mglGraph} (C++, Python)} @code{void} Zoom (@code{mreal} x1, @code{mreal} y1, @code{mreal} x2, @code{mreal} y2)
+@deftypefnx {C function} @code{void} mgl_set_zoom (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} x2, @code{mreal} y2)
The function changes the scale of graphics that correspond to zoom in/out of the picture. After function call the current plot will be cleared and further the picture will contain plotting from its part [x1,x2]*[y1,y2]. Here picture coordinates @var{x1}, @var{x2}, @var{y1}, @var{y2} changes from 0 to 1. Attention! this settings can not be overwritten by any other functions. Use @code{Zoom(0,0,1,1)} to return default view.
@end deftypefn
@end ifclear
@c ##################################################################
+@external
@node Export picture, Primitives, Subplots and rotation, MathGL core
@section Export picture
@cindex SetSize
@end deftypefn
@end ifclear
-
@menu
* Export to file::
* Frames/Animation::
@end menu
@c ==================================================================
+@external
@node Export to file, Frames/Animation, , Export picture
@subsection Export to file
@cindex Write
@deftypefn {Method on @code{mglGraph}} @code{void} WritePNG (@code{const char *}fname, @code{const char *}descr=@code{""}, @code{int} compr=@code{""}, @code{bool} alpha=@code{true})
@deftypefnx {C function} @code{void} mgl_write_png (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
@deftypefnx {C function} @code{void} mgl_write_png_solid (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
-Exports current frame to PNG file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file, @var{alpha} gives the transparency type. By default there are no description added and semitransparent image used. This function does nothing if NO_PNG is defined during compilation of MathGL library.
+Exports current frame to PNG file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file, @var{alpha} gives the transparency type. By default there are no description added and semitransparent image used. This function does nothing if HAVE_PNG isn't defined during compilation of MathGL library.
@end deftypefn
@deftypefn {Method on @code{mglGraph}} @code{void} WriteJPEG (@code{const char *}fname, @code{const char *}descr=@code{""})
@deftypefnx {C function} @code{void} mgl_write_jpg (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
-Exports current frame to JPEG file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file. By default there is no description added. This function does nothing if NO_JPEG is defined during compilation of MathGL library.
+Exports current frame to JPEG file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file. By default there is no description added. This function does nothing if HAVE_JPEG isn't defined during compilation of MathGL library.
@end deftypefn
@deftypefn {Method on @code{mglGraph}} @code{void} WriteGIF (@code{const char *}fname, @code{const char *}descr=@code{""})
@deftypefnx {C function} @code{void} mgl_write_gif (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
-Exports current frame to GIF file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file. By default there is no description added.
+Exports current frame to GIF file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file. By default there is no description added. This function does nothing if HAVE_GIF isn't defined during compilation of MathGL library.
@end deftypefn
@deftypefn {Method on @code{mglGraph}} @code{void} WriteBMP (@code{const char *}fname, @code{const char *}descr=@code{""})
@c @end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} WriteIDTF (@code{const char *}fname, @code{const char *}descr=@code{""})
-@deftypefnx {C function} @code{void} mgl_write_idtf (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
-Exports current frame to IDTF file. Later this file can be converted to U3D format. The vector representation is used. So, the output file may be too large for graphic of large data array (especially for surfaces). However, program has no internal limitations for size of output file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file (default is file name).
-@end deftypefn
+@c @deftypefn {Method on @code{mglGraph}} @code{void} WriteIDTF (@code{const char *}fname, @code{const char *}descr=@code{""})
+@c @deftypefnx {C function} @code{void} mgl_write_idtf (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
+@c Exports current frame to IDTF file. Later this file can be converted to U3D format. The vector representation is used. So, the output file may be too large for graphic of large data array (especially for surfaces). However, program has no internal limitations for size of output file. Parameter @var{fname} specifies the file name, @var{descr} adds description to file (default is file name).
+@c @end deftypefn
@deftypefn {Method on @code{mglGraph}} @code{void} ShowImage (@code{const char *}viewer, @code{bool} nowait=@code{false})
@deftypefnx {C function} @code{void} mgl_show_image (@code{const char *}viewer, @code{int} nowait)
@c ##################################################################
+@external
@node Frames/Animation, Bitmap in memory, Export to file, Export picture
@subsection Frames/Animation
@end ifclear
@c ------------------------------------------------------------------
+@external
@node Bitmap in memory, Parallelization, Frames/Animation, Export picture
@subsection Bitmap in memory
@deftypefn {Method on @code{mglGraph}} @code{mglPoint} CalcXYZ (@code{int} xs, @code{int} ys)
-@deftypefnx {C function} @code{void} mgl_calc_xyz (@code{HMGL} gr, @code{int} xs, @code{int} ys, @code{float *}x, @code{float *}y, @code{float *}z)
+@deftypefnx {C function} @code{void} mgl_calc_xyz (@code{HMGL} gr, @code{int} xs, @code{int} ys, @code{mreal *}x, @code{mreal *}y, @code{mreal *}z)
Calculate 3D coordinate @{x,y,z@} for screen point @{xs,ys@}. At this moment it ignore perspective and transformation formulas (curvilinear coordinates). The calculation are done for the last used InPlot (see @ref{Subplots and rotation}).
@end deftypefn
@deftypefn {Method on @code{mglGraph}} @code{mglPoint} CalcScr (@code{mglPoint} p)
-@deftypefnx {C function} @code{void} mgl_calc_scr (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{int *}xs, @code{int *}ys)
+@deftypefnx {C function} @code{void} mgl_calc_scr (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{int *}xs, @code{int *}ys)
Calculate screen point @{xs,ys@} for 3D coordinate @{x,y,z@}. The calculation are done for the last used InPlot (see @ref{Subplots and rotation}).
@end deftypefn
@end ifclear
-
@c ------------------------------------------------------------------
+@external
@node Parallelization, , Bitmap in memory, Export picture
@subsection Parallelization
Set the number of threads to be used by MathGL. If @var{n}<1 then the number of threads is set as maximal number of processors (cores). If @var{n}=1 then single thread will be used (this is default if pthread was disabled).
@end deftypefn
-Another option is combining bitmap image (taking into account Z-ordering) from different instances. This method is most appropriate for computer clusters when the data size is so large that it exceed the memory of single computer node.
+Another option is combining bitmap image (taking into account Z-ordering) from different instances of @code{mglGraph}. This method is most appropriate for computer clusters when the data size is so large that it exceed the memory of single computer node.
@deftypefn {Method on @code{mglGraph}} @code{int} Combine (@code{const mglGraph *}g)
@deftypefnx {C function} @code{int} mgl_combine_gr (@code{HMGL} gr, @code{HMGL} g)
@end ifclear
-
@c ##################################################################
+@external
@node Primitives, Text printing, Export picture, MathGL core
@section Primitives
@cindex Ball
@cindex Error
@end ifclear
-
These functions draw some simple objects like line, point, sphere, drop, cone and so on. @sref{Using primitives}
@anchor{clf}
@deftypefn {MGL command} {} clf
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} Clf ()
-@deftypefnx {Method on @code{mglGraph}} @code{void} Clf (@code{float} r, @code{float} g, @code{float} b)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Clf (@code{mreal} r, @code{mreal} g, @code{mreal} b)
@deftypefnx {C function} @code{void} mgl_clf (@code{HMGL} gr)
-@deftypefnx {C function} @code{void} mgl_clf_rgb (@code{HMGL} gr, @code{float} r, @code{float} g, @code{float} b)
+@deftypefnx {C function} @code{void} mgl_clf_rgb (@code{HMGL} gr, @code{mreal} r, @code{mreal} g, @code{mreal} b)
@end ifclear
Clear the picture and fill it by color specified color.
@end deftypefn
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} Ball (@code{mglPoint} p, @code{char} col=@code{'r'})
@deftypefnx {Method on @code{mglGraph}} @code{void} Mark (@code{mglPoint} p, @code{const char *}mark)
-@deftypefnx {C function} @code{void} mgl_mark (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const char *}mark)
+@deftypefnx {C function} @code{void} mgl_mark (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{const char *}mark)
@end ifclear
Draws a mark (point @samp{.} by default) at position @var{p}=@{@var{x}, @var{y}, @var{z}@} with color @var{col}.
@end deftypefn
@ifclear UDAV
@deftypefn {Method on @code{mglGraph}} @code{void} Error (@code{mglPoint} p, @code{mglPoint} e, @code{char} *stl=@code{""})
-@deftypefnx {C function} @code{void} mgl_error_box (@code{HMGL} gr, @code{float} px, @code{float} py, @code{float} pz, @code{float} ex, @code{float} ey, @code{float} ez, @code{char *}stl)
+@deftypefnx {C function} @code{void} mgl_error_box (@code{HMGL} gr, @code{mreal} px, @code{mreal} py, @code{mreal} pz, @code{mreal} ex, @code{mreal} ey, @code{mreal} ez, @code{char *}stl)
Draws a 3d error box at position @var{p} with sizes @var{e} and style @var{stl}. Use NAN for component of @var{e} to reduce number of drawn elements.
@end deftypefn
@end ifclear
@deftypefnx {MGL command} {} line @code{x1 y1 z1 x2 y2 z2} ['stl'='']
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} Line (@code{mglPoint} p1, @code{mglPoint} p2, @code{char *}stl=@code{"B"}, @code{int} num=@code{2})
-@deftypefnx {C function} @code{void} mgl_line (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{char *}stl, @code{int} num)
+@deftypefnx {C function} @code{void} mgl_line (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{char *}stl, @code{int} num)
@end ifclear
Draws a geodesic line (straight line in Cartesian coordinates) from point @var{p1} to @var{p2} using line style @var{stl}. Parameter @var{num} define the ``quality'' of the line. If @var{num}=@code{2} then the stright line will be drawn in all coordinate system (independently on transformation formulas (see @ref{Curved coordinates}). Contrary, for large values (for example, =@code{100}) the geodesic line will be drawn in corresponding coordinate system (straight line in Cartesian coordinates, circle in polar coordinates and so on). Line will be drawn even if it lies out of bounding box.
@end deftypefn
@deftypefnx {MGL command} {} curve @code{x1 y1 z1 dx1 dy1 dz1 x2 y2 z2 dx2 dy2 dz2} ['stl'='']
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} Curve (@code{mglPoint} p1, @code{mglPoint} d1, @code{mglPoint} p2, @code{mglPoint} d2, @code{const char *}stl=@code{"B"}, @code{int} num=@code{100})
-@deftypefnx {C function} @code{void} mgl_curve (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} dx1, @code{float} dy1, @code{float} dz1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} dx2, @code{float} dy2, @code{float} dz2, @code{const char *}stl, @code{int} num)
+@deftypefnx {C function} @code{void} mgl_curve (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} dx1, @code{mreal} dy1, @code{mreal} dz1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{mreal} dx2, @code{mreal} dy2, @code{mreal} dz2, @code{const char *}stl, @code{int} num)
@end ifclear
Draws Bezier-like curve from point @var{p1} to @var{p2} using line style @var{stl}. At this tangent is codirected with @var{d1}, @var{d2} and proportional to its amplitude. Parameter @var{num} define the ``quality'' of the curve. If @var{num}=@code{2} then the straight line will be drawn in all coordinate system (independently on transformation formulas, see @ref{Curved coordinates}). Contrary, for large values (for example, =@code{100}) the spline like Bezier curve will be drawn in corresponding coordinate system. Curve will be drawn even if it lies out of bounding box.
@end deftypefn
@ifclear UDAV
@deftypefn {Method on @code{mglGraph}} @code{void} Face (@code{mglPoint} p1, @code{mglPoint} p2, @code{mglPoint} p3, @code{mglPoint} p4, @code{const char *}stl=@code{"w"})
-@deftypefnx {C function} @code{void} mgl_face (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} x3, @code{float} y3, @code{float} z3, @code{float} x4, @code{float} y4, @code{float} z4, @code{const char *}stl)
+@deftypefnx {C function} @code{void} mgl_face (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{mreal} x3, @code{mreal} y3, @code{mreal} z3, @code{mreal} x4, @code{mreal} y4, @code{mreal} z4, @code{const char *}stl)
Draws the solid quadrangle (face) with vertexes @var{p1}, @var{p2}, @var{p3}, @var{p4} and with color(s) @var{stl}. At this colors can be the same for all vertexes or different if all 4 colors are specified for each vertex. Face will be drawn even if it lies out of bounding box.
@end deftypefn
@end ifclear
@deftypefn {MGL command} {} facex @code{x0 y0 z0 wy wz} ['stl'='' @code{d1=0 d2=0}]
@deftypefnx {MGL command} {} facey @code{x0 y0 z0 wx wz} ['stl'='' @code{d1=0 d2=0}]
@deftypefnx {MGL command} {} facez @code{x0 y0 z0 wx wy} ['stl'='' @code{d1=0 d2=0}]
-@deftypefnx {Method on @code{mglGraph}} @code{void} FaceX (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wy, @code{float} wz, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
-@deftypefnx {Method on @code{mglGraph}} @code{void} FaceY (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wz, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
-@deftypefnx {Method on @code{mglGraph}} @code{void} FaceZ (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wy, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
-@deftypefnx {C function} @code{void} mgl_facex (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wy, @code{float} wz, @code{const char *}stl, @code{float} d1, @code{float} d2)
-@deftypefnx {C function} @code{void} mgl_facey (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wz, @code{const char *}stl, @code{float} d1, @code{float} d2)
-@deftypefnx {C function} @code{void} mgl_facez (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wy, @code{const char *}stl, @code{float} d1, @code{float} d2)
-Draws the solid rectangle (face) perpendicular to [x,y,z]-axis correspondingly at position @{@var{x0}, @var{y0}, @var{z0}@} with color @var{stl} and with widths @var{wx}, @var{wy}, @var{wz} along corresponding directions. At this colors can be the same for all vertexes or separately if all 4 colors are specified for each vertex. Parameters @var{d1}!=0, @var{d2}!=0 set additional shift of the last vertex (i.e. to draw quadrangle).
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} FaceX (@code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wy, @code{mreal} wz, @code{const char *}stl=@code{"w"}, @code{mreal} d1=@code{0}, @code{mreal} d2=@code{0})
+@deftypefnx {Method on @code{mglGraph}} @code{void} FaceY (@code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wx, @code{mreal} wz, @code{const char *}stl=@code{"w"}, @code{mreal} d1=@code{0}, @code{mreal} d2=@code{0})
+@deftypefnx {Method on @code{mglGraph}} @code{void} FaceZ (@code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wx, @code{mreal} wy, @code{const char *}stl=@code{"w"}, @code{mreal} d1=@code{0}, @code{mreal} d2=@code{0})
+@deftypefnx {C function} @code{void} mgl_facex (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wy, @code{mreal} wz, @code{const char *}stl, @code{mreal} d1, @code{mreal} d2)
+@deftypefnx {C function} @code{void} mgl_facey (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wx, @code{mreal} wz, @code{const char *}stl, @code{mreal} d1, @code{mreal} d2)
+@deftypefnx {C function} @code{void} mgl_facez (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wx, @code{mreal} wy, @code{const char *}stl, @code{mreal} d1, @code{mreal} d2)
+@end ifclear
+Draws the solid rectangle (face) perpendicular to [x,y,z]-axis correspondingly at position @{@var{x0}, @var{y0}, @var{z0}@} with color @var{stl} and with widths @var{wx}, @var{wy}, @var{wz} along corresponding directions. At this colors can be the same for all vertexes or separately if all 4 colors are specified for each vertex. Parameters @var{d1}!=0, @var{d2}!=0 set additional shift of the last vertex (i.e. to draw quadrangle). Face will be drawn even if it lies out of bounding box.
@end deftypefn
@anchor{sphere}
@deftypefn {MGL command} {} sphere @code{x0 y0 r} ['col'='r']
@deftypefnx {MGL command} {} sphere @code{x0 y0 z0 r} ['col'='r']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Sphere (@code{mglPoint} p, @code{float} r, @code{const char *}stl=@code{"r"})
-@deftypefnx {C function} @code{void} mgl_sphere (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} r, @code{const char *}stl)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Sphere (@code{mglPoint} p, @code{mreal} r, @code{const char *}stl=@code{"r"})
+@deftypefnx {C function} @code{void} mgl_sphere (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} r, @code{const char *}stl)
@end ifclear
Draw the sphere with radius @var{r} and center at point @var{p}=@{@var{x0}, @var{y0}, @var{z0}@} and color @var{stl}.
@end deftypefn
@deftypefn {MGL command} {} drop @code{x0 y0 dx dy r} ['col'='r' @code{sh=1 asp=1}]
@deftypefnx {MGL command} {} drop @code{x0 y0 z0 dx dy dz r} ['col'='r' @code{sh=1 asp=1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Drop (@code{mglPoint} p, @code{mglPoint} d, @code{float} r, @code{const char *}col=@code{"r"}, @code{float} shift=@code{1}, @code{float} ap=@code{1})
-@deftypefnx {C function} @code{void} mgl_drop (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} dx, @code{float} dy, @code{float} dz, @code{float} r, @code{const char *}col, @code{float} shift, @code{float} ap)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Drop (@code{mglPoint} p, @code{mglPoint} d, @code{mreal} r, @code{const char *}col=@code{"r"}, @code{mreal} shift=@code{1}, @code{mreal} ap=@code{1})
+@deftypefnx {C function} @code{void} mgl_drop (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{mreal} r, @code{const char *}col, @code{mreal} shift, @code{mreal} ap)
@end ifclear
Draw the drop with radius @var{r} at point @var{p} elongated in direction @var{d} and with color @var{col}. Parameter @var{shift} set the degree of drop oblongness: @samp{0} is sphere, @samp{1} is maximally oblongness drop. Parameter @var{ap} set relative width of the drop (this is analogue of ``ellipticity'' for the sphere).
@end deftypefn
@anchor{cone}
@deftypefn {MGL command} {} cone @code{x1 y1 z1 x2 y2 z2 r1} [@code{r2=-1} 'stl'='' @code{edge=off}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Cone (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r1, @code{float} r2=@code{-1}, @code{const char *}stl=@code{"B"}, @code{bool} edge=@code{false})
-@deftypefnx {C function} @code{void} mgl_cone (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r1, @code{float} r2, @code{const char *}stl, @code{int} draw_edge)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cone (@code{mglPoint} p1, @code{mglPoint} p2, @code{mreal} r1, @code{mreal} r2=@code{-1}, @code{const char *}stl=@code{"B"}, @code{bool} edge=@code{false})
+@deftypefnx {C function} @code{void} mgl_cone (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{mreal} r1, @code{mreal} r2, @code{const char *}stl, @code{int} draw_edge)
@end ifclear
Draw tube (or truncated cone if @var{edge}=@code{false}) between points @var{p1}, @var{p2} with radius at the edges @var{r1}, @var{r2}. If @var{r2}<0 then it is supposed that @var{r2}=@var{r1}. The cone color is defined by string @var{stl}.
@end deftypefn
@deftypefn {MGL command} {} circle @code{x0 y0 r} ['col'='r']
@deftypefnx {MGL command} {} circle @code{x0 y0 z0 r} ['col'='r']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Circle (@code{mglPoint} p, @code{float} r, @code{const char *}stl=@code{"r"})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Circle (@code{mglPoint} p, @code{mreal} r, @code{const char *}stl=@code{"r"})
@end ifclear
Draw the circle with radius @var{r} and center at point @var{p}=@{@var{x0}, @var{y0}, @var{z0}@}. Parameter @var{col} may contain
@itemize @bullet
@deftypefn {MGL command} {} ellipse @code{x1 y1 x2 y2 r} ['col'='r' @code{sh=1 asp=1}]
@deftypefnx {MGL command} {} ellipse @code{x1 y1 z1 x2 y2 z2 r} ['col'='r' @code{sh=1 asp=1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Ellipse (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r, @code{const char *}col=@code{"r"})
-@deftypefnx {C function} @code{void} mgl_ellipse (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r, @code{const char *}col)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Ellipse (@code{mglPoint} p1, @code{mglPoint} p2, @code{mreal} r, @code{const char *}col=@code{"r"})
+@deftypefnx {C function} @code{void} mgl_ellipse (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{mreal} r, @code{const char *}col)
@end ifclear
Draw the ellipse with radius @var{r} and focal points @var{p1}, @var{p2}. Parameter @var{col} may contain
@itemize @bullet
@deftypefn {MGL command} {} rhomb @code{x1 y1 x2 y2 r} ['col'='r' @code{sh=1 asp=1}]
@deftypefnx {MGL command} {} rhomb @code{x1 y1 z1 x2 y2 z2 r} ['col'='r' @code{sh=1 asp=1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Rhomb (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r, @code{const char *}col=@code{"r"})
-@deftypefnx {C function} @code{void} mgl_rhomb (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r, @code{const char *}col)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Rhomb (@code{mglPoint} p1, @code{mglPoint} p2, @code{mreal} r, @code{const char *}col=@code{"r"})
+@deftypefnx {C function} @code{void} mgl_rhomb (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{mreal} r, @code{const char *}col)
@end ifclear
Draw the rhombus with width @var{r} and edge points @var{p1}, @var{p2}. Parameter @var{col} may contain
@itemize @bullet
@end deftypefn
@c ##################################################################
+@external
@node Text printing, Axis and Colorbar, Primitives, MathGL core
@section Text printing
@ifclear UDAV
@cindex Label
@cindex fgets
-These functions draw the text. There are functions for drawing text in arbitrary place, in arbitrary direction and along arbitrary curve. MathGL can use arbitrary font-faces and parse many TeX commands (for more details see @ref{Font styles}). All these functions have 2 variant: for printing 8-bit text (@code{char *}) and for printing Unicode text (@code{wchar_t *}). In first case the conversion into the current locale is used. So sometimes you need to specify it by @code{setlocale()} function. The size argument control the size of text: if positive it give the value, if negative it give the value relative to @code{SetFontSize()}. The font type (STIX, arial, courier, times and so on) can be selected by function LoadFont(). @xref{Font settings}.
+These functions draw the text. There are functions for drawing text in arbitrary place, in arbitrary direction and along arbitrary curve. MathGL can use arbitrary font-faces and parse many TeX commands (for more details see @ref{Font styles}). All these functions have 2 variant: for printing 8-bit text (@code{char *}) and for printing Unicode text (@code{wchar_t *}). In first case the conversion into the current locale is used. So sometimes you need to specify it by @code{setlocale()} function. The @var{size} argument control the size of text: if positive it give the value, if negative it give the value relative to @code{SetFontSize()}. The font type (STIX, arial, courier, times and so on) can be selected by function LoadFont(). @xref{Font settings}.
The font parameters are described by string. This string may set the text color @samp{wkrgbcymhRGBCYMHW} (see @ref{Color styles}). Also, after delimiter symbol @samp{:}, it can contain characters of font type (@samp{rbiwou}) and/or align (@samp{LRC}) specification. The font types are: @samp{r} -- roman (or regular) font, @samp{i} -- italic style, @samp{b} -- bold style, @samp{w} -- wired style, @samp{o} -- over-lined text, @samp{u} -- underlined text. By default roman font is used. The align types are: @samp{L} -- align left (default), @samp{C} -- align center, @samp{R} -- align right. For example, string @samp{b:iC} correspond to italic font style for centered text which printed by blue color.
-If string contains symbols @samp{aA} then text is printed at absolute position @{@var{x}, @var{y}@} (supposed to be in range [0,1]) of subplot (for @samp{a}) or picture (for @samp{A}). If string contains symbol @samp{@@} then box around text is drawn.
+If string contains symbols @samp{aA} then text is printed at absolute position @{@var{x}, @var{y}@} (supposed to be in range [0,1]) of picture (for @samp{A}) or subplot/inplot (for @samp{a}). If string contains symbol @samp{@@} then box around text is drawn.
@sref{Text features}
@deftypefn {MGL command} {} text @code{x y} 'text' ['fnt'='' @code{size=-1}]
@deftypefnx {MGL command} {} text @code{x y z} 'text' ['fnt'='' @code{size=-1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{const char *}text, @code{const char *}fnt=@code{":C"}, @code{float} size=@code{-1})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{const wchar_t *}text, @code{const char *}fnt=@code{":C"}, @code{float} size=@code{-1})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Puts (@code{float} x, @code{float} y, @code{const char *}text, @code{const char *}fnt=@code{":AC"}, @code{float} size=@code{-1})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Putsw (@code{float} x, @code{float} y, @code{const wchar_t *}text, @code{const char *}fnt=@code{":AC"}, @code{float} size=@code{-1})
-@deftypefnx {C function} @code{void} mgl_puts (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const char *}text, @code{const char *}fnt, @code{float} size)
-@deftypefnx {C function} @code{void} mgl_putsw (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const wchar_t *}text, @code{const char *}fnt, @code{float} size)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{const char *}text, @code{const char *}fnt=@code{":C"}, @code{mreal} size=@code{-1})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{const wchar_t *}text, @code{const char *}fnt=@code{":C"}, @code{mreal} size=@code{-1})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Puts (@code{mreal} x, @code{mreal} y, @code{const char *}text, @code{const char *}fnt=@code{":AC"}, @code{mreal} size=@code{-1})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Putsw (@code{mreal} x, @code{mreal} y, @code{const wchar_t *}text, @code{const char *}fnt=@code{":AC"}, @code{mreal} size=@code{-1})
+@deftypefnx {C function} @code{void} mgl_puts (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{const char *}text, @code{const char *}fnt, @code{mreal} size)
+@deftypefnx {C function} @code{void} mgl_putsw (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{const wchar_t *}text, @code{const char *}fnt, @code{mreal} size)
@end ifclear
-The function plots the string @var{text} at position @var{p} with fonts specifying by the criteria @var{fnt}. The size of font is set by @var{size} parameter (default is @var{FontSize}).
+The function plots the string @var{text} at position @var{p} with fonts specifying by the criteria @var{fnt}. The size of font is set by @var{size} parameter (default is @code{-1}).
@end deftypefn
@deftypefn {MGL command} {} text @code{x y dx dy} 'text' ['fnt'=':L' @code{size=-1}]
@deftypefnx {MGL command} {} text @code{x y z dx dy dz} 'text' ['fnt'=':L' @code{size=-1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{mglPoint} d, @code{const char *}text, @code{const char *}fnt=@code{":L"}, @code{float} size=@code{-1})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{mglPoint} d, @code{const wchar_t *}text, @code{const char *}fnt=@code{":L"}, @code{float} size=@code{-1})
-@deftypefnx {C function} @code{void} mgl_puts_dir (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{float} dx, @code{float} dy, @code{float} dz, @code{const char *}text, @code{const char *}fnt, @code{float} size)
-@deftypefnx {C function} @code{void} mgl_putsw_dir (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{float} dx, @code{float} dy, @code{float} dz, @code{const wchar_t *}text, @code{const char *}fnt, @code{float} size)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{mglPoint} d, @code{const char *}text, @code{const char *}fnt=@code{":L"}, @code{mreal} size=@code{-1})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{mglPoint} d, @code{const wchar_t *}text, @code{const char *}fnt=@code{":L"}, @code{mreal} size=@code{-1})
+@deftypefnx {C function} @code{void} mgl_puts_dir (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{const char *}text, @code{const char *}fnt, @code{mreal} size)
+@deftypefnx {C function} @code{void} mgl_putsw_dir (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{const wchar_t *}text, @code{const char *}fnt, @code{mreal} size)
@end ifclear
The function plots the string @var{text} at position @var{p} along direction @var{d} with specified @var{size}. Parameter @var{fnt} set text style and text position: above (@samp{T}) or under (@samp{t}) the line.
@end deftypefn
Draws unrotated @var{n}-th line of file @var{fname} at position @{@var{x},@var{y},@var{z}@} with specified @var{size}. By default parameters from @ref{font} command are used.
@end deftypefn
-
@deftypefn {MGL command} {} text ydat 'text' ['fnt'='']
@deftypefnx {MGL command} {} text xdat ydat 'text' ['fnt'='']
@deftypefnx {MGL command} {} text xdat ydat zdat 'text' ['fnt'='']
@end deftypefn
@c ##################################################################
+@external
@node Axis and Colorbar, Legend, Text printing, MathGL core
@section Axis and Colorbar
@cindex Axis
@item
@samp{_} for disabling tick labels;
@item
+@samp{U} for disabling rotation of tick labels;
+@item
@samp{AKDTVISO} for drawing arrow at the end of axis;
@item
@samp{a} for forced adjusting of axis ticks.
@deftypefn {MGL command} {} colorbar 'sch' @code{x y [w=1 h=1]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Colorbar (@code{const char *}sch, @code{float} x, @code{float} y, @code{float} w=@code{1}, @code{float} h=@code{1})
-@deftypefnx {C function} @code{void} mgl_colorbar_ext (@code{HMGL} gr, @code{const char *}sch, @code{float} x, @code{float} y, @code{float} w, @code{float} h)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Colorbar (@code{const char *}sch, @code{mreal} x, @code{mreal} y, @code{mreal} w=@code{1}, @code{mreal} h=@code{1})
+@deftypefnx {C function} @code{void} mgl_colorbar_ext (@code{HMGL} gr, @code{const char *}sch, @code{mreal} x, @code{mreal} y, @code{mreal} w, @code{mreal} h)
@end ifclear
The same as first one but at arbitrary position of subplot @{@var{x}, @var{y}@} (supposed to be in range [0,1]). Parameters @var{w}, @var{h} set the relative width and height of the colorbar.
@end deftypefn
@deftypefn {MGL command} {} colorbar vdat 'sch' @code{x y [w=1 h=1]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Colorbar (@code{const mglData &}v, @code{const char *}sch, @code{float} x, @code{float} y, @code{float} w=@code{1}, @code{float} h=@code{1})
-@deftypefnx {C function} @code{void} mgl_colorbar_val_ext (@code{HMGL} gr, @code{HCDT} v, @code{const char *}sch, @code{float} x, @code{float} y, @code{float} w, @code{float} h)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Colorbar (@code{const mglData &}v, @code{const char *}sch, @code{mreal} x, @code{mreal} y, @code{mreal} w=@code{1}, @code{mreal} h=@code{1})
+@deftypefnx {C function} @code{void} mgl_colorbar_val_ext (@code{HMGL} gr, @code{HCDT} v, @code{const char *}sch, @code{mreal} x, @code{mreal} y, @code{mreal} w, @code{mreal} h)
@end ifclear
The same as previous but with sharp colors @var{sch} (current palette if @code{sch=""}) for values @var{v}. @sref{ContD sample}
@end deftypefn
@deftypefnx {MGL command} {} zlabel 'text' [@code{pos=1 shift=0}]
@deftypefnx {MGL command} {} tlabel 'text' [@code{pos=1 shift=0}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{char} dir, @code{const char *}text, @code{float} pos=@code{1}, @code{float} shift=@code{0})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{char} dir, @code{const wchar_t *}text, @code{float} pos=@code{1}, @code{float} shift=@code{0})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{char} dir, @code{const char *}text, @code{mreal} pos=@code{1}, @code{mreal} shift=@code{0})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Label (@code{char} dir, @code{const wchar_t *}text, @code{mreal} pos=@code{1}, @code{mreal} shift=@code{0})
@deftypefnx {C function} @code{void} mgl_label (@code{HMGL} gr, @code{char} dir, @code{const char *}text)
-@deftypefnx {C function} @code{void} mgl_label_ext (@code{HMGL} gr, @code{char} dir, @code{const char *}text, @code{float} pos, @code{float} shift)
-@deftypefnx {C function} @code{void} mgl_labelw_ext (@code{HMGL} gr, @code{char} dir, @code{const wchar_t *}text, @code{float} pos, @code{float} shift)
+@deftypefnx {C function} @code{void} mgl_label_ext (@code{HMGL} gr, @code{char} dir, @code{const char *}text, @code{mreal} pos, @code{mreal} shift)
+@deftypefnx {C function} @code{void} mgl_labelw_ext (@code{HMGL} gr, @code{char} dir, @code{const wchar_t *}text, @code{mreal} pos, @code{mreal} shift)
@end ifclear
Prints the label @var{text} for axis @var{dir}=@samp{x},@samp{y},@samp{z},@samp{t} (here @samp{t} is ``ternary'' axis @math{t=1-x-y}). The position of label is determined by @var{pos} parameter. If @var{pos}=0 then label is printed at the center of axis. If @var{pos}>0 then label is printed at the maximum of axis. If @var{pos}<0 then label is printed at the minimum of axis. @xref{Text printing}.
@end deftypefn
@c ##################################################################
+@external
@node Legend, 1D plotting, Axis and Colorbar, MathGL core
@section Legend
@cindex Legend
@anchor{legend}
@deftypefn {MGL command} {} legend [@code{pos=3} 'fnt'='#' @code{size=-0.8 llen=0.1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Legend (@code{int} pos=@code{0x3}, @code{const char *}fnt=@code{"#"}, @code{float} size=@code{-0.8}, @code{float} llen=@code{0.1})
-@deftypefnx {C function} @code{void} mgl_legend (@code{HMGL} gr, @code{int} pos, @code{const char *}fnt, @code{float} size, @code{float} llen)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Legend (@code{int} pos=@code{0x3}, @code{const char *}fnt=@code{"#"}, @code{mreal} size=@code{-0.8}, @code{mreal} llen=@code{0.1})
+@deftypefnx {C function} @code{void} mgl_legend (@code{HMGL} gr, @code{int} pos, @code{const char *}fnt, @code{mreal} size, @code{mreal} llen)
@end ifclear
Draws legend of accumulated legend entries by font @var{fnt} with @var{size}. Parameter @var{pos} sets the position of the legend: @samp{0} is bottom left corner, @samp{1} is bottom right corner, @samp{2} is top left corner, @samp{3} is top right corner (is default). Parameter @var{fnt} can contain colors for face (1st one), for border (2nd one) and for text (last one). If less than 3 colors are specified then the color for border is black (for 2 and less colors), and the color for face is white (for 1 or none colors). If string @var{fnt} contain @samp{#} then border around the legend is drawn.
@end deftypefn
@deftypefn {MGL command} {} legend @code{x y} ['fnt'='#' @code{size=-1 llen=0.1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Legend (@code{float} x, @code{float} y, @code{const char *}fnt=@code{"#"}, @code{float} size=@code{-0.8}, @code{float} llen=@code{0.1})
-@deftypefnx {C function} @code{void} mgl_legend_pos (@code{HMGL} gr, @code{float} x, @code{float} y, @code{const char *}fnt, @code{float} size, @code{float} llen)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Legend (@code{mreal} x, @code{mreal} y, @code{const char *}fnt=@code{"#"}, @code{mreal} size=@code{-0.8}, @code{mreal} llen=@code{0.1})
+@deftypefnx {C function} @code{void} mgl_legend_pos (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{const char *}fnt, @code{mreal} size, @code{mreal} llen)
@end ifclear
Draws legend of accumulated legend entries by font @var{fnt} with @var{size}. Position of legend is determined by parameter @var{x}, @var{y} which supposed to be normalized to interval [0,1].
@end deftypefn
@end deftypefn
@c ##################################################################
+@external
@node 1D plotting, 2D plotting, Legend, MathGL core
@section 1D plotting
@cindex Plot
@deftypefnx {C function} @code{void} mgl_tape_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_tape_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
@end ifclear
-These functions draw tapes of normals for curve between points @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Initial tape(s) was selected in x-y plane (for @samp{x} in @var{pen}) and/or y-z plane (for @samp{x} in @var{pen}). The width of tape is proportional to @code{SetBarWidth()}. See also @ref{plot}, @ref{flow}, @ref{barwidth}. @sref{Tape sample}
+These functions draw tapes of normals for curve between points @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Initial tape(s) was selected in x-y plane (for @samp{x} in @var{pen}) and/or y-z plane (for @samp{x} in @var{pen}). The width of tape is proportional to @ref{barwidth}. See also @ref{plot}, @ref{flow}, @ref{barwidth}. @sref{Tape sample}
@end deftypefn
@anchor{area}
These functions draw string @var{txt} as marks with size proportional to @var{r}[i]*@var{marksize} at points @{@var{x}[i], @var{y}[i], @var{z}[i]@}. By default (if omitted) @var{r}[i]=1. See also @ref{plot}, @ref{mark}, @ref{stem}. @sref{TextMark sample}
@end deftypefn
-
-
@anchor{label}
@deftypefn {MGL command} {} label ydat 'txt' ['stl'='']
@deftypefnx {MGL command} {} label xdat ydat 'txt' ['stl'='']
@deftypefnx {MGL command} {} tube xdat ydat zdat @code{rval} ['stl'='']
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}y, @code{float} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}y, @code{mreal} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{float} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{mreal} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{float} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{mreal} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {C function} @code{void} mgl_tube_r (@code{HMGL} gr, @code{HCDT} y, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_tube (@code{HMGL} gr, @code{HCDT} y, @code{float} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tube (@code{HMGL} gr, @code{HCDT} y, @code{mreal} r, @code{const char *}pen, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_tube_xyr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_tube_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{float} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tube_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{mreal} r, @code{const char *}pen, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_tube_xyzr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_tube_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{float} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_tube_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{mreal} r, @code{const char *}pen, @code{const char *}opt)
@end ifclear
These functions draw the tube with variable radius @var{r}[i] along the curve between points @{@var{x}[i], @var{y}[i], @var{z}[i]@}. See also @ref{plot}. @sref{Tube sample}
@end deftypefn
@end deftypefn
@c ##################################################################
+@external
@node 2D plotting, 3D plotting, 1D plotting, MathGL core
@section 2D plotting
@cindex Mesh
@cindex Grad
@cindex Grid
-
These functions perform plotting of 2D data. 2D means that data depend from 2 independent parameters like matrix @math{f(x_i,y_j), i=1...n, j=1...m}. By default (if absent) values of @var{x}, @var{y} are equidistantly distributed in axis range. The plots are drawn for each z slice of the data. The minor dimensions of arrays @var{x}, @var{y}, @var{z} should be equal @code{x.nx=z.nx && y.nx=z.ny} or @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Arrays @var{x} and @var{y} can be vectors (not matrices as @var{z}). String @var{sch} sets the color scheme (see @ref{Color scheme}) for plot. String @var{opt} contain command options (see @ref{Command options}). @sref{2D samples}
@anchor{surf}
@deftypefnx {C function} @code{void} mgl_mesh (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_mesh_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws mesh lines for surface specified parametrically @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. See also @ref{surf}, @ref{fall}, @ref{meshnum}, @ref{cont}, @ref{tens}. @sref{Mesh sample}
+The function draws mesh lines for surface specified parametrically @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. See also @ref{surf}, @ref{fall}, @ref{meshnum}, @ref{cont}, @ref{tens}. @sref{Mesh sample}
@end deftypefn
@anchor{fall}
@deftypefn {MGL command} {} dens zdat ['sch'='']
@deftypefnx {MGL command} {} dens xdat ydat zdat ['sch'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Dens (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Dens (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{float} zVal=@code{NAN})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Dens (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{mreal} zVal=@code{NAN})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Dens (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{mreal} zVal=@code{NAN})
@deftypefnx {C function} @code{void} mgl_dens (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_dens_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@end ifclear
@c ##################################################################
+@external
@node 3D plotting, Dual plotting, 2D plotting, MathGL core
@section 3D plotting
@cindex Surf3
@deftypefn {MGL command} {} surf3 adat @code{val} ['sch'='']
@deftypefnx {MGL command} {} surf3 xdat ydat zdat adat @code{val} ['sch'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3 (@code{float} val, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3 (@code{float} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_surf3_val (@code{HMGL} gr, @code{float} val, @code{HCDT} a, @code{const char *}sch, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_surf3_xyz_val (@code{HMGL} gr, @code{float} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3 (@code{mreal} val, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3 (@code{mreal} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_surf3_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} a, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_surf3_xyz_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{const char *}opt)
@end ifclear
The function draws isosurface plot for 3d array specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]) at @var{a}(x,y,z)=@var{val}. If string contain @samp{#} then wire plot is produced. Note, that there is possibility of incorrect plotting due to uncertainty of cross-section defining if there are two or more isosurface intersections inside one cell. See also @ref{cloud}, @ref{dens3}, @ref{surf3c}, @ref{surf3a}, @ref{axial}. @sref{Surf3 sample}
@end deftypefn
@deftypefnx {C function} @code{void} mgl_cloud (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_cloud_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws cloud plot for 3d data specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). This plot is a set of cubes with color and transparency proportional to value of @var{a}. The resulting plot is like cloud -- low value is transparent but higher ones are not. The number of plotting cells depend on @ref{MeshNum}. If string @var{sch} contain symbol @samp{.} then lower quality plot will produced with much low memory usage. If string @var{sch} contain symbol @samp{!} then transparency will be inversed, i.e. higher become transparent and lower become not transparent. See also @ref{surf3}, @ref{meshnum}. @sref{Cloud sample}
+The function draws cloud plot for 3d data specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). This plot is a set of cubes with color and transparency proportional to value of @var{a}. The resulting plot is like cloud -- low value is transparent but higher ones are not. The number of plotting cells depend on @ref{meshnum}. If string @var{sch} contain symbol @samp{.} then lower quality plot will produced with much low memory usage. If string @var{sch} contain symbol @samp{!} then transparency will be inversed, i.e. higher become transparent and lower become not transparent. See also @ref{surf3}, @ref{meshnum}. @sref{Cloud sample}
@end deftypefn
@anchor{dens3}
@deftypefn {MGL command} {} dens3 adat ['sch'='' @code{sval=-1}]
@deftypefnx {MGL command} {} dens3 xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Dens3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Dens3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_dens3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_dens3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Dens3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Dens3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_dens3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_dens3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
The function draws density plot for 3d data specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). Density is plotted at slice @var{sVal} in direction @{@samp{x}, @samp{y}, @samp{z}@} if @var{sch} contain corresponding symbol (by default, @samp{y} direction is used). If string @var{stl} have symbol @samp{#} then grid lines are drawn. See also @ref{cont3}, @ref{contf3}, @ref{dens}, @ref{grid3}. @sref{Dens3 sample}
@end deftypefn
@deftypefn {MGL command} {} cont3 vdat adat ['sch'='' @code{sval=-1}]
@deftypefnx {MGL command} {} cont3 vdat xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_cont3_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_cont3_xyz_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_cont3_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_cont3_xyz_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
-The function draws contour plot for 3d data specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). Contours are plotted for values specified in array @var{v} at slice @var{sVal} in direction @{@samp{x}, @samp{y}, @samp{z}@} if @var{sch} contain corresponding symbol (by default, @samp{y} direction is used). If string @var{stl} have symbol @samp{#} then grid lines are drawn. If string @var{stl} have symbol @samp{t} or @samp{T} then contour labels will be drawn below (or above) the contours. See also @ref{dens3}, @ref{contf3}, @ref{cont}, @ref{grid3}. @sref{Cont3 sample}
+The function draws contour plot for 3d data specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). Contours are plotted for values specified in array @var{v} at slice @var{sVal} in direction @{@samp{x}, @samp{y}, @samp{z}@} if @var{sch} contain corresponding symbol (by default, @samp{y} direction is used). If string @var{sch} have symbol @samp{#} then grid lines are drawn. If string @var{sch} have symbol @samp{t} or @samp{T} then contour labels will be drawn below (or above) the contours. See also @ref{dens3}, @ref{contf3}, @ref{cont}, @ref{grid3}. @sref{Cont3 sample}
@end deftypefn
@deftypefn {MGL command} {} cont3 adat ['sch'='' @code{sval=-1}]
@deftypefnx {MGL command} {} cont3 xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_cont3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_cont3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_cont3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_cont3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
The same as previous with vector @var{v} of @var{num}-th elements equidistantly distributed in color range. Here @var{num} is equal to parameter @var{value} in options @var{opt} (default is 7).
@end deftypefn
@deftypefn {MGL command} {} contf3 vdat adat ['sch'='' @code{sval=-1}]
@deftypefnx {MGL command} {} contf3 vdat xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_contf3_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_contf3_xyz_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_contf3_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contf3_xyz_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
-The function draws solid (or filled) contour plot for 3d data specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). Contours are plotted for values specified in array @var{v} at slice @var{sVal} in direction @{@samp{x}, @samp{y}, @samp{z}@} if @var{sch} contain corresponding symbol (by default, @samp{y} direction is used). If string @var{stl} have symbol @samp{#} then grid lines are drawn. If string @var{stl} have symbol @samp{t} or @samp{T} then contour labels will be drawn below (or above) the contours. See also @ref{dens3}, @ref{cont3}, @ref{contf}, @ref{grid3}. @sref{Cont3 sample}
+The function draws solid (or filled) contour plot for 3d data specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). Contours are plotted for values specified in array @var{v} at slice @var{sVal} in direction @{@samp{x}, @samp{y}, @samp{z}@} if @var{sch} contain corresponding symbol (by default, @samp{y} direction is used). If string @var{sch} have symbol @samp{#} then grid lines are drawn. See also @ref{dens3}, @ref{cont3}, @ref{contf}, @ref{grid3}. @sref{ContF3 sample}
@end deftypefn
@deftypefn {MGL command} {} contf3 adat ['sch'='' @code{sval=-1}]
@deftypefnx {MGL command} {} contf3 xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_contf3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_contf3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_contf3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contf3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
The same as previous with vector @var{v} of @var{num}-th elements equidistantly distributed in color range. Here @var{num} is equal to parameter @var{value} in options @var{opt} (default is 7).
@end deftypefn
@deftypefn {MGL command} {} grid3 adat ['sch'='' @code{sval=-1}]
@deftypefnx {MGL command} {} grid3 xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Grid3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Grid3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_grid3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_grid3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Grid3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Grid3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_grid3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_grid3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
The function draws grid for 3d data specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). Grid is plotted at slice @var{sVal} in direction @{@samp{x}, @samp{y}, @samp{z}@} if @var{sch} contain corresponding symbol (by default, @samp{y} direction is used). See also @ref{cont3}, @ref{contf3}, @ref{dens3}, @ref{grid2}, @ref{meshnum}.
@end deftypefn
@anchor{beam}
@deftypefn {MGL command} {} beam tr g1 g2 adat @code{rval} ['sch'='' @code{flag=0 num=3}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Beam (@code{const mglData &}tr, @code{const mglData &}g1, @code{const mglData &}g2, @code{const mglData &}a, @code{float} r, @code{const char *}stl=@code{""}, @code{int} flag=@code{0}, @code{int} num=@code{3})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Beam (@code{float} val, @code{const mglData &}tr, @code{const mglData &}g1, @code{const mglData &}g2, @code{const mglData &}a, @code{float} r, @code{const char *}stl=@code{""}, @code{int} flag=@code{0})
-@deftypefnx {C function} @code{void} mgl_beam (@code{HMGL} gr, @code{HCDT} tr, @code{HCDT} g1, @code{HCDT} g2, @code{HCDT} a, @code{float} r, @code{const char *}stl, @code{int} flag, @code{int} num)
-@deftypefnx {C function} @code{void} mgl_beam_val (@code{HMGL} gr, @code{float} val, @code{HCDT} tr, @code{HCDT} g1, @code{HCDT} g2, @code{HCDT} a, @code{float} r, @code{const char *}stl, @code{int} flag)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Beam (@code{const mglData &}tr, @code{const mglData &}g1, @code{const mglData &}g2, @code{const mglData &}a, @code{mreal} r, @code{const char *}stl=@code{""}, @code{int} flag=@code{0}, @code{int} num=@code{3})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Beam (@code{mreal} val, @code{const mglData &}tr, @code{const mglData &}g1, @code{const mglData &}g2, @code{const mglData &}a, @code{mreal} r, @code{const char *}stl=@code{""}, @code{int} flag=@code{0})
+@deftypefnx {C function} @code{void} mgl_beam (@code{HMGL} gr, @code{HCDT} tr, @code{HCDT} g1, @code{HCDT} g2, @code{HCDT} a, @code{mreal} r, @code{const char *}stl, @code{int} flag, @code{int} num)
+@deftypefnx {C function} @code{void} mgl_beam_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} tr, @code{HCDT} g1, @code{HCDT} g2, @code{HCDT} a, @code{mreal} r, @code{const char *}stl, @code{int} flag)
@end ifclear
Draws the isosurface for 3d array @var{a} at constant values of @var{a}=@var{val}. This is special kind of plot for @var{a} specified in accompanied coordinates along curve @var{tr} with orts @var{g1}, @var{g2} and with transverse scale @var{r}. Variable @var{flag} is bitwise: @samp{0x1} - draw in accompanied (not laboratory) coordinates; @samp{0x2} - draw projection to @math{\rho-z} plane; @samp{0x4} - draw normalized in each slice field. The x-size of data arrays @var{tr}, @var{g1}, @var{g2} must be nx>2. The y-size of data arrays @var{tr}, @var{g1}, @var{g2} and z-size of the data array @var{a} must be equal. See also @ref{surf3}.
@end deftypefn
-
@c ##################################################################
+@external
@node Dual plotting, Vector fields, 3D plotting, MathGL core
@section Dual plotting
@cindex SurfC
@deftypefn {MGL command} {} surf3c adat cdat @code{val} ['sch'='']
@deftypefnx {MGL command} {} surf3c xdat ydat zdat adat cdat @code{val} ['sch'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3C (@code{float} val, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3C (@code{float} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_surf3c_val (@code{HMGL} gr, @code{float} val, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_surf3c_xyz_val (@code{HMGL} gr, @code{float} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3C (@code{mreal} val, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3C (@code{mreal} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_surf3c_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_surf3c_xyz_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws isosurface plot for 3d array specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]) at @var{a}(x,y,z)=@var{val}. It is mostly the same as @ref{surf3} function but the color of isosurface depends on values of array @var{c}. If string contain @samp{#} then wire plot is produced. See also @ref{surf3}, @ref{surfc}, @ref{surf3a}. @sref{Surf3C sample}
+The function draws isosurface plot for 3d array specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]) at @var{a}(x,y,z)=@var{val}. It is mostly the same as @ref{surf3} function but the color of isosurface depends on values of array @var{c}. If string @var{sch} contain @samp{#} then wire plot is produced. See also @ref{surf3}, @ref{surfc}, @ref{surf3a}. @sref{Surf3C sample}
@end deftypefn
@deftypefn {MGL command} {} surf3c adat cdat ['sch'='']
@deftypefn {MGL command} {} surf3a adat cdat @code{val} ['sch'='']
@deftypefnx {MGL command} {} surf3a xdat ydat zdat adat cdat @code{val} ['sch'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3A (@code{float} val, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3A (@code{float} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_surf3a_val (@code{HMGL} gr, @code{float} val, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_surf3a_xyz_val (@code{HMGL} gr, @code{float} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3A (@code{mreal} val, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Surf3A (@code{mreal} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_surf3a_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_surf3a_xyz_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws isosurface plot for 3d array specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]) at @var{a}(x,y,z)=@var{val}. It is mostly the same as @ref{surf3} function but the color of isosurface depends on values of array @var{c}. If string contain @samp{#} then wire plot is produced. See also @ref{surf3}, @ref{surfc}, @ref{surf3a}. @sref{Surf3A sample}
+The function draws isosurface plot for 3d array specified parametrically @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]) at @var{a}(x,y,z)=@var{val}. It is mostly the same as @ref{surf3} function but the color of isosurface depends on values of array @var{c}. If string @var{sch} contain @samp{#} then wire plot is produced. See also @ref{surf3}, @ref{surfc}, @ref{surf3a}. @sref{Surf3A sample}
@end deftypefn
@deftypefn {MGL command} {} surf3a adat cdat ['sch'='']
@deftypefnx {C function} @code{void} mgl_map (@code{HMGL} gr, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_map_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws mapping plot for matrices @{@var{ax}, @var{ay} @} which parametrically depend on coordinates @var{x}, @var{y}. The initial position of the cell (point) is marked by color. Height is proportional to Jacobian(ax,ay). This plot is like Arnold diagram ???. If string @var{sch} contain symbol @samp{.} then the color ball at matrix knots are drawn otherwise face is drawn. @sref{Mapping visualization}
+The function draws mapping plot for matrices @{@var{ax}, @var{ay} @} which parametrically depend on coordinates @var{x}, @var{y}. The initial position of the cell (point) is marked by color. Height is proportional to Jacobian(ax,ay). This plot is like Arnold diagram ??? If string @var{sch} contain symbol @samp{.} then the color ball at matrix knots are drawn otherwise face is drawn. @sref{Mapping visualization}
@end deftypefn
@anchor{stfa}
@c ##################################################################
+@external
@node Vector fields, Other plotting, Dual plotting, MathGL core
@section Vector fields
@cindex Traj
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} FlowP (@code{mglPoint} p0, @code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Method on @code{mglGraph}} @code{void} FlowP (@code{mglPoint} p0, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_flowp_2d (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_flowp_xy (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_flowp_2d (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_flowp_xy (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
@end ifclear
The same as first one (@ref{flow}) but draws single flow thread starting from point @var{p0}=@{@var{x0},@var{y0},@var{z0}@}.
@end deftypefn
@ifclear UDAV
@deftypefnx {Method on @code{mglGraph}} @code{void} FlowP (@code{mglPoint} p0, @code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Method on @code{mglGraph}} @code{void} FlowP (@code{mglPoint} p0, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_flowp_3d (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_flowp_xyz (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_flowp_3d (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_flowp_xyz (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{const char *}opt)
@end ifclear
This is 3D version of the previous functions.
@end deftypefn
@deftypefnx {C function} @code{void} mgl_grad_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} phi, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_grad_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} phi, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws gradient lines for scalar field @var{phi}[i,j] (or @var{phi}[i,j,k] in 3d case) specified parametrically @{@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]@}. Number of lines is proportional to @var{value} option (default is 5). If @var{value}<0 then lines start only from edges of axis range. Warm color corresponds to normal flow (like minimum). Cold one corresponds to inverse flow (like maximum). If string @var{sch} contain symbol @samp{v} then arrows are drawn on flow threads. See also @ref{dens}, @ref{cont}, @ref{flow}.
+The function draws gradient lines for scalar field @var{phi}[i,j] (or @var{phi}[i,j,k] in 3d case) specified parametrically @{@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]@}. Number of lines is proportional to @var{value} option (default is 5). See also @ref{dens}, @ref{cont}, @ref{flow}.
@end deftypefn
@anchor{pipe}
@deftypefn {MGL command} {} pipe udat vdat ['sch'='' @code{r0=0.05}]
@deftypefnx {MGL command} {} pipe xdat ydat udat vdat ['sch'='' @code{r0=0.05}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Pipe (@code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{float} r0=@code{0.05}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Pipe (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{float} r0=@code{0.05}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_pipe_2d (@code{HMGL} gr, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{float} r0, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_pipe_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{float} r0, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Pipe (@code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{mreal} r0=@code{0.05}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Pipe (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{mreal} r0=@code{0.05}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_pipe_2d (@code{HMGL} gr, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{mreal} r0, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_pipe_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{mreal} r0, @code{const char *}opt)
@end ifclear
The function draws flow pipes for the plane vector field @{@var{ax}, @var{ay}@} parametrically depending on coordinates @var{x}, @var{y} at level @var{z} = @var{Min}.z. Number of pipes is proportional to @var{value} option (default is 5). If @samp{#} symbol is specified then pipes start only from edges of axis range. The color of lines is proportional to @math{\sqrt@{ax^2+ay^2@}}. Warm color corresponds to normal flow (like attractor). Cold one corresponds to inverse flow (like source). Parameter @var{r0} set the base pipe radius. If @var{r0}<0 or symbol @samp{i} is specified then pipe radius is inverse proportional to amplitude. The vector field is plotted for each z slice of @var{ax}, @var{ay}. See also @ref{flow}, @ref{vect}. @sref{Pipe sample}
@end deftypefn
@deftypefn {MGL command} {} pipe udat vdat wdat ['sch'='' @code{r0=0.05}]
@deftypefnx {MGL command} {} pipe xdat ydat zdat udat vdat wdat ['sch'='' @code{r0=0.05}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} Pipe (@code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{float} r0=@code{0.05}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} Pipe (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{float} r0=@code{0.05}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_pipe_3d (@code{HMGL} gr, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{float} r0, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_pipe_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{float} r0, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} Pipe (@code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{mreal} r0=@code{0.05}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} Pipe (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{mreal} r0=@code{0.05}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_pipe_3d (@code{HMGL} gr, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{mreal} r0, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_pipe_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{mreal} r0, @code{const char *}opt)
@end ifclear
This is 3D version of the first functions. Here arrays @var{ax}, @var{ay}, @var{az} must be 3-ranged tensors with equal sizes and the color of line is proportional to @math{\sqrt@{ax^2+ay^2+az^2@}}.
@end deftypefn
@c ##################################################################
+@external
@node Other plotting, Nonlinear fitting, Vector fields, MathGL core
@section Other plotting
@cindex DensXYZ
@deftypefnx {MGL command} {} densy dat ['sch'='' @code{sval=nan}]
@deftypefnx {MGL command} {} densz dat ['sch'='' @code{sval=nan}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} DensX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} DensY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} DensZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_dens_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_dens_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_dens_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} DensX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} DensY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} DensZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_dens_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_dens_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_dens_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
-These plotting functions draw density plot in x, y, or z plain. If @var{a} is a tensor (3-dimensional data) then interpolation to a given @var{sVal} is performed. These functions are useful for creating projections of the 3D data array to the bounding box. For example, code like
-@example
-gr->DensX(c.Sum("x"),"BbcyrR",-1);
-gr->DensY(c.Sum("y"),"",1);
-gr->DensZ(c.Sum("z"),"",-1);
-@end example
-will produce the following picture. See also @ref{ContXYZ}, @ref{ContFXYZ}, @ref{dens}, @ref{Data manipulation}. @sref{Dens projection sample}
+These plotting functions draw density plot in x, y, or z plain. If @var{a} is a tensor (3-dimensional data) then interpolation to a given @var{sVal} is performed. These functions are useful for creating projections of the 3D data array to the bounding box. See also @ref{ContXYZ}, @ref{ContFXYZ}, @ref{dens}, @ref{Data manipulation}. @sref{Dens projection sample}
@end deftypefn
@anchor{contz} @anchor{conty} @anchor{contx} @anchor{ContXYZ}
@deftypefnx {MGL command} {} conty dat ['sch'='' @code{sval=nan}]
@deftypefnx {MGL command} {} contz dat ['sch'='' @code{sval=nan}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} ContX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} ContY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} ContZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_cont_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_cont_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_cont_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@end ifclear
-These plotting functions draw contour lines in x, y, or z plain. If @var{a} is a tensor (3-dimensional data) then interpolation to a given @var{sVal} is performed. These functions are useful for creating projections of the 3D data array to the bounding box. For example, code like
-@example
-gr->ContX(c.Sum("x"),"BbcyrR",-1);
-gr->ContY(c.Sum("y"),0,1);
-gr->ContZ(c.Sum("z"),0,-1);
-@end example
-will produce the following picture. See also @ref{ContFXYZ}, @ref{DensXYZ}, @ref{cont}, @ref{Data manipulation}. @sref{Cont projection sample}
-@end deftypefn
-
-@ifclear UDAV
-@deftypefn {Method on @code{mglGraph}} @code{void} ContX (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} ContY (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} ContZ (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_cont_x_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_cont_y_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_cont_z_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_cont_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_cont_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_cont_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@end ifclear
+These plotting functions draw contour lines in x, y, or z plain. If @var{a} is a tensor (3-dimensional data) then interpolation to a given @var{sVal} is performed. These functions are useful for creating projections of the 3D data array to the bounding box. See also @ref{ContFXYZ}, @ref{DensXYZ}, @ref{cont}, @ref{Data manipulation}. @sref{Cont projection sample}
+@end deftypefn
+
+@ifclear UDAV
+@deftypefn {Method on @code{mglGraph}} @code{void} ContX (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContY (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContZ (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_cont_x_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_cont_y_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_cont_z_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
The same as previous with manual contour levels.
@end deftypefn
@end ifclear
@deftypefnx {MGL command} {} contfy dat ['sch'='' @code{sval=nan}]
@deftypefnx {MGL command} {} contfz dat ['sch'='' @code{sval=nan}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} ContFX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} ContFY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} ContFZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_contf_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_contf_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_contf_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@end ifclear
-These plotting functions draw solid contours in x, y, or z plain. If @var{a} is a tensor (3-dimensional data) then interpolation to a given @var{sVal} is performed. These functions are useful for creating projections of the 3D data array to the bounding box. For example, code like
-@example
-gr->ContFX(c.Sum("x"),"BbcyrR",-1);
-gr->ContFY(c.Sum("y"),0,1);
-gr->ContFZ(c.Sum("z"),0,-1);
-@end example
-will produce the following picture. See also @ref{ContFXYZ}, @ref{DensXYZ}, @ref{cont}, @ref{Data manipulation}. @sref{ContF projection sample}
-@end deftypefn
-
-@ifclear UDAV
-@deftypefn {Method on @code{mglGraph}} @code{void} ContFX (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} ContFY (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglGraph}} @code{void} ContFZ (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_contf_x_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_contf_y_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {C function} @code{void} mgl_contf_z_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContFX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContFY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContFZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_contf_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contf_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contf_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@end ifclear
+These plotting functions draw solid contours in x, y, or z plain. If @var{a} is a tensor (3-dimensional data) then interpolation to a given @var{sVal} is performed. These functions are useful for creating projections of the 3D data array to the bounding box. See also @ref{ContFXYZ}, @ref{DensXYZ}, @ref{cont}, @ref{Data manipulation}. @sref{ContF projection sample}
+@end deftypefn
+
+@ifclear UDAV
+@deftypefn {Method on @code{mglGraph}} @code{void} ContFX (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContFY (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Method on @code{mglGraph}} @code{void} ContFZ (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_contf_x_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contf_y_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {C function} @code{void} mgl_contf_z_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
The same as previous with manual contour levels.
@end deftypefn
@end ifclear
@deftypefnx {C function} @code{void} mgl_triplot_xyz (@code{HMGL} gr, @code{HCDT} id, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_triplot_xyzc (@code{HMGL} gr, @code{HCDT} id, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws the surface of triangles. Triangle vertexes are set by indexes @var{id} of data points @{@var{x}[i], @var{y}[i], @var{z}[i]@}. String @var{sch} sets the color scheme. If string contain @samp{#} then wire plot is produced. First dimensions of @var{id} must be 3 or greater. Arrays @var{x}, @var{y}, @var{z} must have equal sizes. Parameter @var{c} set the colors of triangles (if @var{id}.ny=@var{c}.nx) or colors of vertexes (if @var{x}.nx=@var{c}.nx). See also @ref{dots}, @ref{crust}, @ref{quadplot}. @sref{TriPlot and QuadPlot}
+The function draws the surface of triangles. Triangle vertexes are set by indexes @var{id} of data points @{@var{x}[i], @var{y}[i], @var{z}[i]@}. String @var{sch} sets the color scheme. If string contain @samp{#} then wire plot is produced. First dimensions of @var{id} must be 3 or greater. Arrays @var{x}, @var{y}, @var{z} must have equal sizes. Parameter @var{c} set the colors of triangles (if @var{id}.ny=@var{c}.nx) or colors of vertexes (if @var{x}.nx=@var{c}.nx). See also @ref{dots}, @ref{crust}, @ref{quadplot}, @ref{triangulation}. @sref{TriPlot and QuadPlot}
@end deftypefn
@anchor{tricont}
@deftypefnx {C function} @code{void} mgl_tricont_xyzcv (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} id, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_tricont_xyzv (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} id, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws contour lines for surface of triangles at @var{z}=@var{v}[k] (or at @var{z} = @var{Min}.z if @var{sch} contain symbol @samp{_}). Triangle vertexes are set by indexes @var{id} of data points @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Contours are plotted for @var{z}[i,j]=@var{v}[k] where @var{v}[k] are values of data array @var{v}. String @var{sch} sets the color scheme. Array @var{c} (if specified) is used for contour coloring. First dimensions of @var{id} must be 3 or greater. Arrays @var{x}, @var{y}, @var{z} must have equal sizes. Parameter @var{c} set the colors of triangles (if @var{id}.ny=@var{c}.nx) or colors of vertexes (if @var{x}.nx=@var{c}.nx). See also @ref{triplot}, @ref{cont}.
+The function draws contour lines for surface of triangles at @var{z}=@var{v}[k] (or at @var{z} = @var{Min}.z if @var{sch} contain symbol @samp{_}). Triangle vertexes are set by indexes @var{id} of data points @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Contours are plotted for @var{z}[i,j]=@var{v}[k] where @var{v}[k] are values of data array @var{v}. String @var{sch} sets the color scheme. Array @var{c} (if specified) is used for contour coloring. First dimensions of @var{id} must be 3 or greater. Arrays @var{x}, @var{y}, @var{z} must have equal sizes. Parameter @var{c} set the colors of triangles (if @var{id}.ny=@var{c}.nx) or colors of vertexes (if @var{x}.nx=@var{c}.nx). See also @ref{triplot}, @ref{cont}, @ref{triangulation}.
@end deftypefn
@anchor{quadplot}
@deftypefnx {C function} @code{void} mgl_dots (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {C function} @code{void} mgl_dots_a (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-The function draws the arbitrary placed points @{@var{x}[i], @var{y}[i], @var{z}[i]@}. String @var{sch} sets the color scheme. If array @var{a} is specified then it define the transparency of dots. Arrays @var{x}, @var{y}, @var{z}, @var{a} must have equal sizes. See also @ref{crust}, @ref{mark}, @ref{plot}. @sref{Dots sample}
+The function draws the arbitrary placed points @{@var{x}[i], @var{y}[i], @var{z}[i]@}. String @var{sch} sets the color scheme. If array @var{a} is specified then it define colors of dots. Arrays @var{x}, @var{y}, @var{z}, @var{a} must have equal sizes. See also @ref{crust}, @ref{mark}, @ref{plot}. @sref{Dots sample}
@end deftypefn
@anchor{crust}
@end deftypefn
@c ##################################################################
+@external
@node Nonlinear fitting, Data manipulation, Other plotting, MathGL core
@section Nonlinear fitting
@cindex Fit
@anchor{putsfit}
@deftypefn {MGL command} {} putsfit @code{x y} ['pre'='' 'fnt'='' @code{size=-1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{void} PutsFit (@code{mglPoint} p, @code{const char *}prefix=@code{""}, @code{const char *}font=@code{""}, @code{float} size=@code{-1})
-@deftypefnx {C function} @code{void} mgl_puts_fit (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const char *}prefix, @code{const char *}font, @code{float} size)
+@deftypefnx {Method on @code{mglGraph}} @code{void} PutsFit (@code{mglPoint} p, @code{const char *}prefix=@code{""}, @code{const char *}font=@code{""}, @code{mreal} size=@code{-1})
+@deftypefnx {C function} @code{void} mgl_puts_fit (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{const char *}prefix, @code{const char *}font, @code{mreal} size)
@end ifclear
Print last fitted formula with found coefficients (as numbers) at position @var{p0}. The string @var{prefix} will be printed before formula. All other parameters are the same as in @ref{Text printing}.
@end deftypefn
@c ##################################################################
-@node Data manipulation, IDTF functions, Nonlinear fitting, MathGL core
+@external
+@node Data manipulation, , Nonlinear fitting, MathGL core
@section Data manipulation
@cindex Hist
+@cindex Fill
+@cindex DataGrid
@deftypefn {MGL command} {} hist @sc{res} xdat adat
@deftypefnx {MGL command} {} hist @sc{res} xdat ydat adat
@deftypefnx {Method on @code{mglGraph}} @code{void} Fill (@code{mglData &}u, @code{const char *}eq, @code{const mglData &}v, @code{const mglData &}w, @code{const char *}opt=@code{""})
@deftypefnx {C function} @code{void} mgl_data_fill_eq (@code{HMGL} gr, @code{HMDT} u, @code{const char *}eq, @code{HCDT}v, @code{HCDT}w, @code{const char *}opt)
@end ifclear
-Fills the value of array according to the formula in string @var{eq}. Formula is an arbitrary expression depending on variables @samp{x}, @samp{y}, @samp{z}, @samp{u}, @samp{v}, @samp{w}. Coordinates @samp{x}, @samp{y}, @samp{z} are supposed to be normalized in axis range. Variable @samp{u} is the original value of the array. Variables @samp{v} and @samp{w} are values of arrays @var{v}, @var{w} which can be @code{NULL} (i.e. can be omitted).
+Fills the value of array @samp{u} according to the formula in string @var{eq}. Formula is an arbitrary expression depending on variables @samp{x}, @samp{y}, @samp{z}, @samp{u}, @samp{v}, @samp{w}. Coordinates @samp{x}, @samp{y}, @samp{z} are supposed to be normalized in axis range. Variable @samp{u} is the original value of the array. Variables @samp{v} and @samp{w} are values of arrays @var{v}, @var{w} which can be @code{NULL} (i.e. can be omitted).
@end deftypefn
+@deftypefn {MGL command} {} datagrid dat xdat ydat zdat
+@ifclear UDAV
+@deftypefnx {Method on @code{mglGraph}} @code{void} DataGrid (@code{mglData &}u, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_data_grid (@code{HMGL} gr, @code{HMDT} u, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}opt)
+@end ifclear
+Fills the value of array @samp{u} according to the linear interpolation of triangulated surface, found for arbitrary placed points @samp{x}, @samp{y}, @samp{z}. Interpolation is done at points equidistantly distributed in axis range. NAN value is used for grid points placed outside of triangulated surface.
+@end deftypefn
+
+
+
@deftypefn {MGL command} {} pde @sc{res} 'ham' ini_re ini_im [@code{dz=0.1 k0=100}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglGraph}} @code{mglData} PDE (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{float} dz=@code{0.1}, @code{float} k0=@code{100}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{HMDT} mgl_pde_solve (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{float} dz, @code{float} k0, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{mglData} PDE (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{mreal} dz=@code{0.1}, @code{mreal} k0=@code{100}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{HMDT} mgl_pde_solve (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{mreal} dz, @code{mreal} k0, @code{const char *}opt)
@end ifclear
-Solves equation du/dz = i*k0*@var{ham}(p,q,x,y,z,|u|)[u], where p=-i/k0*d/dx, q=-i/k0*d/dy are pseudo-differential operators. Parameters @var{ini_re}, @var{ini_im} specify real and imaginary part of initial field distribution. Parameters @var{Min}, @var{Max} set the bounding box for the solution. Note, that really this ranges are increased by factor 3/2 for purpose of reducing reflection from boundaries. Parameter @var{dz} set the step along evolutionary coordinate z. At this moment, simplified form of function @var{ham} is supported -- all ``mixed'' terms (like @samp{x*p}->x*d/dx) are excluded. For example, in 2D case this function is effectively @math{ham = f(p,z) + g(x,z,u)}. However commutable combinations (like @samp{x*q}->x*d/dy) are allowed. Here variable @samp{u} is used for field amplitude |u|. This allow one solve nonlinear problems -- for example, for nonlinear Shrodinger equation you may set @code{ham="p^2 + q^2 - u^2"}. You may specify imaginary part for wave absorption, like @code{ham = "p^2 + i*x*(x>0)"}, but only if dependence on variable @samp{i} is linear (i.e. @math{ham = hre+i*him}). @sref{PDE solving hints}
+Solves equation du/dz = i*k0*@var{ham}(p,q,x,y,z,|u|)[u], where p=-i/k0*d/dx, q=-i/k0*d/dy are pseudo-differential operators. Parameters @var{ini_re}, @var{ini_im} specify real and imaginary part of initial field distribution. Coordinates @samp{x}, @samp{y}, @samp{z} are supposed to be normalized in axis range. Note, that really this ranges are increased by factor 3/2 for purpose of reducing reflection from boundaries. Parameter @var{dz} set the step along evolutionary coordinate z. At this moment, simplified form of function @var{ham} is supported -- all ``mixed'' terms (like @samp{x*p}->x*d/dx) are excluded. For example, in 2D case this function is effectively @math{ham = f(p,z) + g(x,z,u)}. However commutable combinations (like @samp{x*q}->x*d/dy) are allowed. Here variable @samp{u} is used for field amplitude |u|. This allow one solve nonlinear problems -- for example, for nonlinear Shrodinger equation you may set @code{ham="p^2 + q^2 - u^2"}. You may specify imaginary part for wave absorption, like @code{ham = "p^2 + i*x*(x>0)"}, but only if dependence on variable @samp{i} is linear (i.e. @math{ham = hre+i*him}). @sref{PDE solving hints}
@end deftypefn
@c ##################################################################
-@node IDTF functions, , Data manipulation, MathGL core
-@section IDTF functions
+@c @external
+@c @node IDTF functions, , Data manipulation, MathGL core
+@c @section IDTF functions
-These functions provide IDTF specific features. In all other cases they do nothing.
+@c These functions provide IDTF specific features. In all other cases they do nothing.
-@ifclear UDAV
+@c @ifclear UDAV
-@deftypefn {Method on @code{mglGraph}} @code{void} VertexColor (@code{bool} enable)
-Enables smooth color change.
-@end deftypefn
+@c @deftypefn {Method on @code{mglGraph}} @code{void} VertexColor (@code{bool} enable)
+@c Enables smooth color change.
+@c @end deftypefn
-@deftypefn {Method on @code{mglGraph}} @code{void} Compression (@code{bool} enable)
-Gives smaller files, but quality degrades.
-@end deftypefn
+@c @deftypefn {Method on @code{mglGraph}} @code{void} Compression (@code{bool} enable)
+@c Gives smaller files, but quality degrades.
+@c @end deftypefn
-@c inline void DoubleSided(bool){} // NOTE: Add later -- IDTF
-@c inline void TextureColor(bool){} // NOTE: Add later -- IDTF
+@c inline void DoubleSided(bool){} // NOTE: Add later -- IDTF
+@c inline void TextureColor(bool){} // NOTE: Add later -- IDTF
+
+@c @end ifclear
+
+@external
-@end ifclear
* Other plotting::
* Nonlinear fitting::
* Data manipulation::
-* IDTF functions::
+@c * IDTF functions::
@end menu
@c ##################################################################
+@external
@node Constructor, Graphics setup, , MathGL core
@section Создание и удаление графического объекта
@ifclear UDAV
-@deftypefn {Constructor on @code{mglGraph}} {} mglGraph (@code{int} kind=@code{0}, @code{int} width=@code{600}, @code{int} height=@code{400})
-@deftypefnx {Constructor on @code{mglGraph}} {} mglGraph (@code{const mglGraph &}gr)
-@deftypefnx {Constructor on @code{mglGraph}} {} mglGraph (@code{HMGL} gr)
+@deftypefn {Конструктор класса @code{mglGraph}} {} mglGraph (@code{int} kind=@code{0}, @code{int} width=@code{600}, @code{int} height=@code{400})
+@deftypefnx {Конструктор класса @code{mglGraph}} {} mglGraph (@code{const mglGraph &}gr)
+@deftypefnx {Конструктор класса @code{mglGraph}} {} mglGraph (@code{HMGL} gr)
@deftypefnx {Функция С} @code{HMGL} mgl_create_graph (@code{int} width, @code{int} height)
@deftypefnx {Функция С} @code{HMGL} mgl_create_graph_gl ()
-Создает (или использует созданный) экземпляр класса, производного от @code{mglBase} (тип @code{HMGL}) с указанными размерами @var{width} и @var{height}. Параметр @var{kind} может иметь следующие значения: @samp{0} -- использовать рисование по умолчанию, @samp{1} -- использовать рисование в OpenGL.
+Создает (или использует созданный) экземпляр класса, производного от @code{mglGraph} (тип @code{HMGL}) с указанными размерами @var{width} и @var{height}. Параметр @var{kind} может иметь следующие значения: @samp{0} -- использовать рисование по умолчанию, @samp{1} -- использовать рисование в OpenGL.
@end deftypefn
-@deftypefnx {Destructor on @code{mglGraph}} {} ~mglGraph ()
+@deftypefn {Destructor on @code{mglGraph}} {} ~mglGraph ()
@deftypefnx {Функция С} @code{HMGL} mgl_delete_graph (@code{HMGL} gr)
Удаляет экземпляр класса mglGraph.
@end deftypefn
@end ifset
@c ##################################################################
+@external
@node Graphics setup, Axis settings, Constructor, MathGL core
@section Настройка графика
@cindex Настройка MathGL
@end menu
@c ==================================================================
+@external
@node Transparency, Lighting, , Graphics setup
@subsection Прозрачность
@cindex Alpha
@cindex AlphaDef
@cindex TranspType
-Эти функции и переменные настраивают тип и степень прозрачности поверхностей. Главной является функция @code{Alpha()}, которая включает/выключает прозрачность для всех графиков, созданных после вызова @code{Alpha()} (за исключением mglGraphGL). Функция @code{SetAlphaDef} устанавливает величину alpha-канала по умолчанию. Прозрачность можно выключить для отдельного графика с помощью @code{SetTransparent}. Наконец, функция @code{SetTranspType} задает тип прозрачности. @sref{Transparency and lighting}
+Эти функции и переменные настраивают тип и степень прозрачности поверхностей. Главной является функция @ref{alpha}, которая включает/выключает прозрачность для всего графика. Функция @ref{alphadef} устанавливает величину alpha-канала по умолчанию. Наконец, функция @ref{transptype} задает тип прозрачности. @sref{Transparency and lighting}
@anchor{alpha}
@deftypefn {Команда MGL} {} alpha @code{[val=on]}
@anchor{alphadef}
@deftypefn {Команда MGL} {} alphadef @code{val}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetAlphaDef (@code{float} val)
-@deftypefnx {Функция С} @code{void} mgl_set_alpha_default (@code{HMGL} gr, @code{float} alpha)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetAlphaDef (@code{mreal} val)
+@deftypefnx {Функция С} @code{void} mgl_set_alpha_default (@code{HMGL} gr, @code{mreal} alpha)
@end ifclear
Задает значение прозрачности по умолчанию для всех графиков. Значение по умолчанию 0.5.
@end deftypefn
@end deftypefn
@c ==================================================================
+@external
@node Lighting, Fog, Transparency, Graphics setup
@subsection Освещение
@ifclear UDAV
@cindex Light
@cindex Ambient
-Эти функции настраивают освещение графика. Главная функция @code{Light(bool)} включает/выключает освещение графиков построенных после ее вызова (в OpenGL работает сразу для всего рисунка). MathGL поддерживает до 10 независимых источников света. Но в режиме OpenGL можно использовать только первые 8 из них. Положение, цвет, яркость каждого источника света можно задавать по отдельности. По умолчанию включен только первый (с порядковым номером @code{0}) источник света белого цвета, расположенный сверху.
+Эти функции настраивают освещение графика. Главная функция @ref{light} включает/выключает освещение графиков построенных после ее вызова (в OpenGL работает сразу для всего рисунка). MathGL поддерживает до 10 независимых источников света. Но в режиме OpenGL можно использовать только первые 8 из них. Положение, цвет, яркость каждого источника света можно задавать по отдельности. По умолчанию включен только первый (с порядковым номером @code{0}) источник света белого цвета, расположенный сверху.
@anchor{light}
@deftypefn {Команда MGL} {} light @code{[val=on]}
@deftypefn {Команда MGL} {} light @code{num xdir ydir zdir} ['col'='w' @code{br=0.5}]
@deftypefnx {Команда MGL} {} light @code{num xdir ydir zdir xpos ypos zpos} ['col'='w' @code{br=0.5}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} AddLight (@code{int} n, @code{mglPoint} d, @code{char} c=@code{'w'}, @code{float} bright=@code{0.5}, @code{float} ap=@code{0})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} AddLight (@code{int} n, @code{mglPoint} r, @code{mglPoint} d, @code{char} c=@code{'w'}, @code{float} bright=@code{0.5}, @code{float} ap=@code{0})
-@deftypefnx {Функция С} @code{void} mgl_add_light (@code{HMGL} gr, @code{int} n, @code{float} dx, @code{float} dy, @code{float} dz)
-@deftypefnx {Функция С} @code{void} mgl_add_light_ext (@code{HMGL} gr, @code{int} n, @code{float} dx, @code{float} dy, @code{float} dz, @code{char} c, @code{float} bright, @code{float} ap)
-@deftypefnx {Функция С} @code{void} mgl_add_light_loc (@code{HMGL} gr, @code{int} n, @code{float} rx, @code{float} ry, @code{float} rz, @code{float} dx, @code{float} dy, @code{float} dz, @code{char} c, @code{float} bright, @code{float} ap)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} AddLight (@code{int} n, @code{mglPoint} d, @code{char} c=@code{'w'}, @code{mreal} bright=@code{0.5}, @code{mreal} ap=@code{0})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} AddLight (@code{int} n, @code{mglPoint} r, @code{mglPoint} d, @code{char} c=@code{'w'}, @code{mreal} bright=@code{0.5}, @code{mreal} ap=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_add_light (@code{HMGL} gr, @code{int} n, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz)
+@deftypefnx {Функция С} @code{void} mgl_add_light_ext (@code{HMGL} gr, @code{int} n, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{char} c, @code{mreal} bright, @code{mreal} ap)
+@deftypefnx {Функция С} @code{void} mgl_add_light_loc (@code{HMGL} gr, @code{int} n, @code{mreal} rx, @code{mreal} ry, @code{mreal} rz, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{char} c, @code{mreal} bright, @code{mreal} ap)
@end ifclear
Добавляет источник света с номером @var{n} в положение @var{p} с цветом @var{c} и яркостью @var{bright}, которая должна быть в диапазоне [0,1]. Если указано положение источника @var{r} и оно не NAN, то источник считается локальным, иначе источник полагается бесконечно удалённым (для более быстрого рисования).
@end deftypefn
@anchor{ambient}
@deftypefn {Команда MGL} {} ambient @code{val}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetAmbient (@code{float} bright=@code{0.5})
-@deftypefnx {Функция С} @code{void} mgl_set_ambbr (@code{HMGL} gr, @code{float} bright)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetAmbient (@code{mreal} bright=@code{0.5})
+@deftypefnx {Функция С} @code{void} mgl_set_ambbr (@code{HMGL} gr, @code{mreal} bright)
@end ifclear
Задает яркость рассеянного освещения. Значение должно быть в диапазоне [0,1].
@end deftypefn
@c ==================================================================
+@external
@node Fog, Default sizes, Lighting, Graphics setup
@subsection Туман
@cindex Fog
@anchor{fog}
@deftypefn {Команда MGL} {} fog @code{val [dz=0.25]}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Fog (@code{float} d, @code{float} dz=@code{0.25})
-@deftypefnx {Функция С} @code{void} mgl_set_fog (@code{HMGL} gr, @code{float} d, @code{float} dz)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Fog (@code{mreal} d, @code{mreal} dz=@code{0.25})
+@deftypefnx {Функция С} @code{void} mgl_set_fog (@code{HMGL} gr, @code{mreal} d, @code{mreal} dz)
@end ifclear
-Имитирует туман на графике. Туман начинается на относительном расстоянии @var{dz} от точки обзора и его плотность растет экспоненциально вглубь по закону ~@math{1-exp(-d*z)}. Здесь @emph{z} -- нормализованная на 1 глубина графика. Если @var{d}=@code{0} то туман отсутствует. @sref{Adding fog}
+Имитирует туман на графике. Туман начинается на относительном расстоянии @var{dz} от точки обзора и его плотность растет экспоненциально вглубь по закону ~ 1-exp(-@emph{d*z}). Здесь @emph{z} -- нормализованная на 1 глубина графика. Если @var{d}=@code{0} то туман отсутствует. @sref{Adding fog}
@end deftypefn
@c ==================================================================
+@external
@node Default sizes, Cutting, Fog, Graphics setup
@subsection Базовые размеры
@ifclear UDAV
@anchor{barwidth}
@deftypefn {Команда MGL} {} barwidth @code{val}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetBarWidth ( @code{float} val)
-@deftypefnx {Функция С} @code{void} mgl_set_bar_width (@code{HMGL} gr, @code{float} val)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetBarWidth ( @code{mreal} val)
+@deftypefnx {Функция С} @code{void} mgl_set_bar_width (@code{HMGL} gr, @code{mreal} val)
@end ifclear
-Задает относительный размер прямоугольников в Bars, Barh, BoxPlot (см. @ref{Bars}). Значение по умолчанию @code{0.7}.
+Задает относительный размер прямоугольников в @ref{bars}, @ref{barh}, @ref{boxplot}, @ref{candle}. Значение по умолчанию @code{0.7}.
@end deftypefn
@anchor{marksize}
@deftypefn {Команда MGL} {} marksize @code{val}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetMarkSize (@code{float} val)
-@deftypefnx {Функция С} @code{void} mgl_set_mark_size (@code{HMGL} gr, @code{float} val)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetMarkSize (@code{mreal} val)
+@deftypefnx {Функция С} @code{void} mgl_set_mark_size (@code{HMGL} gr, @code{mreal} val)
@end ifclear
-Задает размер маркеров для @ref{1D plotting}. Значение по умолчанию @code{0.02}.
+Задает размер маркеров для @ref{1D plotting}. Значение по умолчанию @code{1}.
@end deftypefn
@anchor{arrowsize}
@deftypefn {Команда MGL} {} arrowsize @code{val}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetArrowSize (@code{float} val)
-@deftypefnx {Функция С} @code{void} mgl_set_arrow_size (@code{HMGL} gr, @code{float} val)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetArrowSize (@code{mreal} val)
+@deftypefnx {Функция С} @code{void} mgl_set_arrow_size (@code{HMGL} gr, @code{mreal} val)
@end ifclear
-Задает размер стрелок для @ref{1D plotting}, линий и кривых (см. @ref{Primitives drawing}). Значение по умолчанию @code{0.03}.
+Задает размер стрелок для @ref{1D plotting}, линий и кривых (см. @ref{Primitives}). Значение по умолчанию @code{1}.
@end deftypefn
@anchor{meshnum}
@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetMeshNum (@code{int} val)
@deftypefnx {Функция С} @code{void} mgl_set_meshnum (@code{HMGL} gr, @code{int} num)
@end ifclear
-Задает ориентировочное число линий в Mesh(), Fall(), Grid() и число стрелок (штрихов) в Vect(), Dew() и число ячеек в Cloud*(). По умолчанию (=0) рисуются все линии, стрелки, ячейки.
+Задает ориентировочное число линий в @ref{mesh}, @ref{fall}, @ref{grid} и число стрелок (штрихов) в @ref{vect}, @ref{dew} и число ячеек в @ref{cloud}. По умолчанию (=0) рисуются все линии, стрелки, ячейки.
@end deftypefn
@c ==================================================================
+@external
@node Cutting, Font settings, Default sizes, Graphics setup
@subsection Обрезание
@ifclear UDAV
@deftypefn {Команда MGL} {} cut @code{x1 y1 z1 x2 y2 z2}
@ifclear UDAV
@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetCutBox (@code{mglPoint} p1, @code{mglPoint} p1)
-@deftypefnx {Функция С} @code{void} mgl_set_cut_box (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2)
+@deftypefnx {Функция С} @code{void} mgl_set_cut_box (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2)
@end ifclear
-Задает границы параллелепипеда внутри которого точки не рисуются. Если границы одинаковы (переменные равны), то параллелепипеда считается пустым. @sref{CutMinMax sample}
+Задает границы параллелепипеда внутри которого точки не рисуются. Если границы одинаковы (переменные равны), то параллелепипеда считается пустым.
@end deftypefn
@deftypefn {Команда MGL} {} cut 'cond'
@deftypefnx {Метод класса @code{mglGraph}} @code{void} CutOff (@code{const char *}cond)
@deftypefnx {Функция С} @code{void} mgl_set_cutoff (@code{HMGL} gr, @code{const char *}cond)
@end ifclear
-Задает условие обрезания по формуле @var{cond}. Это условие исключает точки из рисования если результат вычисления формулы не равен нулю. Установите аргумент @code{""} для выключения условия обрезания. @sref{CutOff sample}
+Задает условие обрезания по формуле @var{cond}. Это условие исключает точки из рисования если результат вычисления формулы не равен нулю. Установите аргумент @code{""} для выключения условия обрезания.
@end deftypefn
@c ==================================================================
+@external
@node Font settings, Palette and colors, Cutting, Graphics setup
@subsection Шрифты
@ifclear UDAV
@anchor{font}
@deftypefn {Команда MGL} {} font 'fnt' [@code{val=6}]
-Задает стиль и размер шрифта (см. @ref{Text printing}). Вначале используется @samp{:rC} -- прямой шрифт с выравниванием по центру. По умолчанию размер подписей оси координат в 1.4 раза больше. См. также см. @ref{Font styles}.
+Задает стиль и размер шрифта. Вначале используется @samp{:rC} -- прямой шрифт с выравниванием по центру. По умолчанию размер подписей оси координат в 1.4 раза больше. См. также см. @ref{Font styles}.
@end deftypefn
@anchor{rotatetext}
@deftypefn {Команда MGL} {} rotatetext @code{val}
+@ifclear UDAV
@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRotatedText (@code{bool} val)
@deftypefnx {Функция С} @code{void} mgl_set_rotated_text (@code{HMGL} gr, @code{int} val)
+@end ifclear
Включает/выключает вращение меток и подписей осей координат вдоль оси.
@end deftypefn
Задает стиль шрифта (см. @ref{Text printing}). По умолчанию используется @samp{rC} -- прямой шрифт с выравниванием по центру.
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} SetFontSize (@code{float} val)
-@deftypefnx {Функция С} @code{void} mgl_set_font_size (@code{HMGL} gr, @code{float} val)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetFontSize (@code{mreal} val)
+@deftypefnx {Функция С} @code{void} mgl_set_font_size (@code{HMGL} gr, @code{mreal} val)
Задает базовый размер шрифта. По умолчанию размер подписей оси координат в 1.4 раза больше.
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} SetFontSizePT (@code{float} cm, @code{int} dpi=@code{72})
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetFontSizePT (@code{mreal} cm, @code{int} dpi=@code{72})
Задает размер шрифта в пунктах для заданного DPI (по умолчанию 16 pt для dpi=72).
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{inline void} SetFontSizeCM (@code{float} cm, @code{int} dpi=@code{72})
+@deftypefn {Метод класса @code{mglGraph}} @code{inline void} SetFontSizeCM (@code{mreal} cm, @code{int} dpi=@code{72})
Задает размер шрифта в сантиметрах для заданного DPI (по умолчанию 0.56 см = 16 pt).
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{inline void} SetFontSizeIN (@code{float} cm, @code{int} dpi=@code{72})
+@deftypefn {Метод класса @code{mglGraph}} @code{inline void} SetFontSizeIN (@code{mreal} cm, @code{int} dpi=@code{72})
Задает размер шрифта в дюймах для заданного DPI (по умолчанию 0.22 in = 16 pt).
@end deftypefn
@end ifclear
@c ==================================================================
+@external
@node Palette and colors, Error handling, Font settings, Graphics setup
@subsection Палитра и цвета
@ifclear UDAV
@anchor{palette}
@deftypefn {Команда MGL} {} palette 'colors'
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetPalette (@code{const char *}@var{colors})
-@deftypefnx {Функция С} @code{void} mgl_set_palette (@code{HMGL} gr, @code{const char *}@var{colors})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetPalette (@code{const char *}colors)
+@deftypefnx {Функция С} @code{void} mgl_set_palette (@code{HMGL} gr, @code{const char *}colors)
@end ifclear
-Задает палитру как последовательность цветов. Значение по умолчанию @code{"Hbgrcmyhlnqeup"}, что соответствует цветам: темно серый @samp{H}, синий @samp{b}, зелёный @samp{g}, красный @samp{r}, голубой @samp{c}, малиновый @samp{m}, жёлтый @samp{y}, серый @samp{h}, сине-зелёный @samp{l}, небесно-голубой @samp{n}, оранжевый @samp{q}, желто-зелёный @samp{e}, сине-фиолетовый @samp{u}, фиолетовый @samp{p}. Палитра в основном используется в 1D графиках (см. @ref{1D plotting}) для кривых с неопределённым стилем линии.
+Задает палитру как последовательность цветов. Значение по умолчанию @code{"Hbgrcmyhlnqeup"}, что соответствует цветам: темно серый @samp{H}, синий @samp{b}, зелёный @samp{g}, красный @samp{r}, голубой @samp{c}, малиновый @samp{m}, жёлтый @samp{y}, серый @samp{h}, сине-зелёный @samp{l}, небесно-голубой @samp{n}, оранжевый @samp{q}, желто-зелёный @samp{e}, сине-фиолетовый @samp{u}, фиолетовый @samp{p}. Палитра в основном используется в 1D графиках (см. @ref{1D plotting}) для кривых с неопределённым стилем линии. Внутренний счетчик цвета будет сброшен при любом изменении палитры, включая скрытые (например, функциями @ref{box} или @ref{axis}).
@end deftypefn
-
@ifclear UDAV
@deftypefn {Method on @code{mglGraph}} @code{void} SetDefScheme (@code{const char *}sch)
@deftypefnx {C function} @code{void} mgl_set_def_sch (@code{HMGL} gr, @code{const char *}sch)
Устанавливает @var{sch} в качестве цветовой схемы по умолчанию. Начальное значение @code{"BbcyrR"}.
@end deftypefn
-@deftypefn {C function} @code{void} mgl_set_color (@code{char} id, @code{float} r, @code{float} g, @code{float} b)
+@deftypefn {C function} @code{void} mgl_set_color (@code{char} id, @code{mreal} r, @code{mreal} g, @code{mreal} b)
Задает RGB значения для цвета с заданным @var{id}.
@end deftypefn
@end ifclear
@c ==================================================================
+@external
@node Error handling, , Palette and colors, Graphics setup
@subsection Обработка ошибок
@ifclear UDAV
@c ==================================================================
+@external
@node Axis settings, Subplots and rotation, Graphics setup, MathGL core
@section Настройки осей координат
@end menu
@c ------------------------------------------------------------------
+@external
@node Ranges (bounding box), Curved coordinates, , Axis settings
@subsection Масштаб осей координат
@cindex CRange
@deftypefnx {Команда MGL} {} zrange @code{v1 v2}
@deftypefnx {Команда MGL} {} crange @code{v1 v2}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRange (@code{char} dir, @code{float} v1, @code{float} v2)
-@deftypefnx {Функция С} @code{void} mgl_set_range_val (@code{HMGL} gr, @code{char} dir, @code{float} v1, @code{float} v2)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRange (@code{char} dir, @code{mreal} v1, @code{mreal} v2)
+@deftypefnx {Функция С} @code{void} mgl_set_range_val (@code{HMGL} gr, @code{char} dir, @code{mreal} v1, @code{mreal} v2)
@end ifclear
Задает диапазон изменения @samp{x}-,@samp{y}-,@samp{z}-,@samp{c}-координат. См. также @ref{ranges}.
@end deftypefn
@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRange (@code{char} dir, @code{const mglData &}dat, @code{bool} add=@code{false})
@deftypefnx {Функция С} @code{void} mgl_set_range_dat (@code{HMGL} gr, @code{char} dir, @code{const HCDT} a, @code{int} add)
@end ifclear
-Задает диапазон изменения @samp{x}-,@samp{y}-,@samp{z}-,@samp{c}-координат как минимальное и максимальное значение массива @var{dat}. Параметр @var{add} указывает добавлять новый диапазон к существующему или заменять его.
+Задает диапазон изменения @samp{x}-,@samp{y}-,@samp{z}-,@samp{c}-координат как минимальное и максимальное значение массива @var{dat}. Параметр @code{add=on} указывает добавлять новый диапазон к существующему (не заменять его).
@end deftypefn
@anchor{ranges}
@deftypefn {Команда MGL} {} ranges @code{x1 x2 y1 y2 [z1=0 z2=0]}
@ifclear UDAV
@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRanges (@code{mglPoint} p1, @code{mglPoint} p2)
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRanges (@code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{float} z1=@code{0}, @code{float} z2=@code{0})
-@deftypefnx {Функция С} @code{void} mgl_set_ranges (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{float} z1, @code{float} z2)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetRanges (@code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2, @code{mreal} z1=@code{0}, @code{mreal} z2=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_set_ranges (@code{HMGL} gr, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2, @code{mreal} z1, @code{mreal} z2)
@end ifclear
Задает диапазон изменения координат. Если минимальное и максимальное значение координаты равны, то они игнорируются по данному направлению. Также устанавливает размер цветовой шкалы, аналогично команде @code{crange z1 z2}. Начальные диапазоны равны [-1, 1].
@end deftypefn
@deftypefn {Команда MGL} {} origin @code{x0 y0 [z0=nan]}
@ifclear UDAV
@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetOrigin (@code{mglPoint} p0)
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetOrigin (@code{float} x0, @code{float} y0, @code{float} z0=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_set_origin (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetOrigin (@code{mreal} x0, @code{mreal} y0, @code{mreal} z0=@code{NAN})
+@deftypefnx {Функция С} @code{void} mgl_set_origin (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0)
@end ifclear
Задает центр пересечения осей координат. Если одно из значений равно NAN, то MathGL попытается выбрать оптимальное положение осей координат по этому направлению.
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Curved coordinates, Ticks, Ranges (bounding box), Axis settings
@subsection Криволинейные координаты
@cindex Axis
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Ternary (@code{int} tern)
@deftypefnx {Функция С} @code{void} mgl_set_ternary (@code{HMGL} gr, @code{int} tern)
@end ifclear
-Ð\97адаеÑ\82 Ñ\80иÑ\81ование Ñ\82Ñ\80еÑ\83голÑ\8cнÑ\8bÑ\85 (Ternary) или пиÑ\80амидалÑ\8cнÑ\8bÑ\85 (Quaternary) оÑ\81ей кооÑ\80динаÑ\82. ÐÑ\82о Ñ\81пеÑ\86иалÑ\8cнÑ\8bй Ñ\82ип гÑ\80аÑ\84ика длÑ\8f 3 завиÑ\81имÑ\8bÑ\85 кооÑ\80динаÑ\82 (компоненÑ\82) @var{a}, @var{b}, @var{c} Ñ\82акиÑ\85, Ñ\87Ñ\82о @var{a}+@var{b}+@var{c}=1. MathGL иÑ\81полÑ\8cзÑ\83еÑ\82 Ñ\82олÑ\8cко 2 незавиÑ\81имÑ\8bе кооÑ\80динаÑ\82Ñ\8b @var{a}=x и @var{b}=y поÑ\81колÑ\8cкÑ\83 иÑ\85 доÑ\81Ñ\82аÑ\82оÑ\87но длÑ\8f поÑ\81Ñ\82Ñ\80оениÑ\8f вÑ\81еÑ\85 гÑ\80аÑ\84иков. Ð\9fÑ\80и Ñ\8dÑ\82ом Ñ\82Ñ\80еÑ\82Ñ\8cÑ\8f кооÑ\80динаÑ\82а z Ñ\8fвлÑ\8fеÑ\82Ñ\81Ñ\8f незавиÑ\81имÑ\8bм паÑ\80амеÑ\82Ñ\80ом длÑ\8f поÑ\81Ñ\82Ñ\80оениÑ\8f линий Ñ\83Ñ\80овнÑ\8f, повеÑ\80Ñ\85ноÑ\81Ñ\82ей и Ñ\82.д. СооÑ\82веÑ\82Ñ\81Ñ\82венно Quaternary кооÑ\80динаÑ\82Ñ\8b -- 4 незавиÑ\81имÑ\8bе кооÑ\80динаÑ\82Ñ\8b @var{a}, @var{b}, @var{c} и @var{d}, Ñ\82акие Ñ\87Ñ\82о @var{a}+@var{b}+@var{c}+@var{d}=1. Ð\98Ñ\81полÑ\8cзÑ\83йÑ\82е @code{Ternary(0)}. @sref{Ternary axis}
+Задает рисование треугольных (Ternary) или пирамидальных (Quaternary) осей координат. Это специальный тип графика для 3 зависимых координат (компонент) @var{a}, @var{b}, @var{c} таких, что @var{a}+@var{b}+@var{c}=1. MathGL использует только 2 независимые координаты @var{a}=x и @var{b}=y поскольку их достаточно для построения всех графиков. При этом третья координата z является независимым параметром для построения линий уровня, поверхностей и т.д. Соответственно Quaternary координаты -- 4 зависимые координаты @var{a}, @var{b}, @var{c} и @var{d}, такие что @var{a}+@var{b}+@var{c}+@var{d}=1. Используйте @code{Ternary(0)}. @sref{Ternary axis}
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Ticks, , Curved coordinates, Axis settings
@subsection Метки осей
@cindex AxisStl
@deftypefnx {Команда MGL} {} ztick @code{val [sub=0 org=nan]}
@deftypefnx {Команда MGL} {} ctick @code{val [sub=0 org=nan]}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTicks (@code{char} dir, @code{float} d=@code{0}, @code{int} ns=@code{0}, @code{float} org=@code{NAN})
-@deftypefnx {Функция С} @code{void} mgl_set_ticks_dir (@code{HMGL} gr, @code{char} dir, @code{float} d, @code{int} ns, @code{float} org)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTicks (@code{char} dir, @code{mreal} d=@code{0}, @code{int} ns=@code{0}, @code{mreal} org=@code{NAN})
+@deftypefnx {Функция С} @code{void} mgl_set_ticks_dir (@code{HMGL} gr, @code{char} dir, @code{mreal} d, @code{int} ns, @code{mreal} org)
@deftypefnx {Функция С} @code{void} mgl_set_ticks (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} nz)
@end ifclear
Задает шаг меток осей @var{d}, число подметок @var{ns} и начальное положение меток @var{org} для оси вдоль направления @var{dir} (используйте 'c' для меток colorbar). Переменная @var{d} задает шаг меток (если положительна) или их число на оси (если отрицательна). Нулевое значение задает автоматическую расстановку меток. Если @var{org}=@code{NAN}, то используется значение из переменной @var{Org}.
@deftypefn {Команда MGL} {} ticktime 'dir' [@code{dv} 'tmpl']
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTicksTime (@code{char} dir, @code{float} val, @code{const char *}templ)
-@deftypefnx {Функция С} @code{void} mgl_set_ticks_time (@code{HMGL} gr, @code{float} val, @code{const char *}templ)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTicksTime (@code{char} dir, @code{mreal} val, @code{const char *}templ)
+@deftypefnx {Функция С} @code{void} mgl_set_ticks_time (@code{HMGL} gr, @code{mreal} val, @code{const char *}templ)
@end ifclear
Задает метки времени с шагом @var{val} и шаблоном @var{templ} для меток вдоль x-,y-,z-оси или colorbar. Шаблон может содержать и символы TeX. Формат шаблона @var{templ} такой же как @url{http://www.manpagez.com/man/3/strftime/}. Наиболее употребительные варианты: @samp{%X} для национального представления времени, @samp{%x} для национального представления даты, @samp{%Y} для года с цифрами столетия. Если @var{val}=0 и/или @var{templ}="", то используется автоматическая расстановка меток и/или выбор шаблона.
@end deftypefn
@deftypefn {Команда MGL} {} tuneticks @code{val} [@code{pos=1.15}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTuneTicks (@code{int} tune, @code{float} pos=@code{1.15})
-@deftypefnx {Функция С} @code{void} mgl_tune_ticks (@code{HMGL} gr, @code{int} tune, @code{float} pos)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTuneTicks (@code{int} tune, @code{mreal} pos=@code{1.15})
+@deftypefnx {Функция С} @code{void} mgl_tune_ticks (@code{HMGL} gr, @code{int} tune, @code{mreal} pos)
@end ifclear
Включает/выключает улучшение вида меток осей путем вынесения общего множителя (для маленьких, типа 0.001...0.002, или больших, типа 1000...2000, значений координат) или общей компоненты (для узкого диапазона, типа 0.999...1.000). Также задает положение @var{pos} общего множителя на оси: =0 около минимального значения, =1 около максимального значения.
@end deftypefn
@ifclear UDAV
+
+@deftypefn {Method on @code{mglGraph}} @code{void} SetTickShift (@code{mglPoint} d)
+@deftypefnx {C function} @code{void} mgl_set_tick_shift (@code{HMGL} gr, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{mreal} dc)
+Задает значение дополнительного сдвига меток осей координат.
+@end deftypefn
+
@deftypefn {Метод класса @code{mglGraph}} @code{void} SetTickRotate (@code{bool} val)
@deftypefnx {Функция С} @code{void} mgl_set_tick_rotate (@code{HMGL} gr, @code{bool} val)
Включает/выключает поворот меток если их число или длина меток слишком велики.
@deftypefnx {Функция С} @code{void} mgl_set_tick_skip (@code{HMGL} gr, @code{bool} val)
Включает/выключает пропуск меток если их число или длина меток слишком велики.
@end deftypefn
-@end ifclear
+@deftypefn {Method on @code{mglGraph}} @code{void} SetTimeUTC (@code{bool} val)
+@c @deftypefnx {C function} @code{void} mgl_set_tick_skip (@code{HMGL} gr, @code{bool} val)
+Разрешает/запрещает использование UTC времени в метках осей координат. В C/Fortran следует использовать @code{mgl_set_flag(gr,val, MGL_USE_GMTIME);}.
+@end deftypefn
+
+@end ifclear
@anchor{ticklen}
@deftypefn {Команда MGL} {} ticklen @code{val} [@code{stt=1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTickLen (@code{float} val, @code{float} stt=@code{1})
-@deftypefnx {Функция С} @code{void} mgl_set_tick_len (@code{HMGL} gr, @code{float} val, @code{float} stt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SetTickLen (@code{mreal} val, @code{mreal} stt=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_set_tick_len (@code{HMGL} gr, @code{mreal} val, @code{mreal} stt)
@end ifclear
Задает относительную длину меток осей координат. Значение по умолчанию @code{0.1}. Параметр @var{stt}>0 задает относительную длину подметок, которые в @code{sqrt(1+stt)} раз меньше.
@end deftypefn
@end deftypefn
@c ##################################################################
+@external
@node Subplots and rotation, Export picture, Axis settings, MathGL core
@section Матрица преобразования
@cindex Aspect
@cindex Push
@cindex Pop
-Эти функции контролируют где и как график будет расположен. Существует определенный порядок вызова этих функций для лучшего вида графика. Вначале должны вызываться функции SubPlot() или InPlot() для указания местоположения вывода. После них -- функции вращения Rotate() и сжатия Aspect(). И наконец любые другие функции для рисования графика. Вместо вращения графика можно вызвать функцию ColumnPlot() для расположения графиков в столбец одного над другим без зазора между осями. @sref{Subplots}
+Эти функции контролируют где и как график будет расположен. Существует определенный порядок вызова этих функций для лучшего вида графика. Вначале должны вызываться функции @ref{subplot}, @ref{multiplot} или @ref{inplot} для указания местоположения вывода. После них -- функции вращения @ref{rotate} и @ref{aspect}. И наконец любые другие функции для рисования графика. Вместо вращения графика можно вызвать функцию @ref{columnplot}, @ref{gridplot}, @ref{stickplot} или относительную @ref{inplot} для расположения графиков в столбец одного над другим без зазора между осями. @sref{Subplots}
@anchor{subplot}
@deftypefn {Команда MGL} {} subplot @code{nx ny m ['stl'='<>_^' dx=0 dy=0]}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} SubPlot (@code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl=@code{"<>_^"}, @code{float} dx=@code{0}, @code{float} dy=@code{0})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} SubPlot (@code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl=@code{"<>_^"}, @code{mreal} dx=@code{0}, @code{mreal} dy=@code{0})
@deftypefnx {Функция С} @code{void} mgl_subplot (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl)
-@deftypefnx {Функция С} @code{void} mgl_subplot_d (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl, @code{float} dx, @code{float} dy)
+@deftypefnx {Функция С} @code{void} mgl_subplot_d (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{const char *}stl, @code{mreal} dx, @code{mreal} dy)
@end ifclear
-Помещает последующий вывод в @var{m}-ую ячейку сетки размером @var{nx}*@var{ny} от всего рисунка. Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика". С эстетической точки зрения не рекомендуется вызывать эту функцию с различными (или не кратными) размерами сетки. Место для осей/colorbar резервируется только если строка @var{style} содержит: @samp{L} или @samp{<} -- с левого края, @samp{R} или @samp{>} -- с правого края, @samp{A} или @samp{^} -- с верхнего края, @samp{U} или @samp{_} -- с нижнего края. Ячейка может быть дополнительно сдвинута относительно своего обычного положения на относительный размер @var{dx}, @var{dy}.
+Помещает последующий вывод в @var{m}-ую ячейку сетки размером @var{nx}*@var{ny} от всего рисунка. Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика". С эстетической точки зрения не рекомендуется вызывать эту функцию с различными (или не кратными) размерами сетки. Место для осей/colorbar резервируется только если строка @var{stl} содержит: @samp{L} или @samp{<} -- с левого края, @samp{R} или @samp{>} -- с правого края, @samp{A} или @samp{^} -- с верхнего края, @samp{U} или @samp{_} -- с нижнего края. Ячейка может быть дополнительно сдвинута относительно своего обычного положения на относительный размер @var{dx}, @var{dy}.
@end deftypefn
@anchor{multiplot}
@deftypefnx {Метод класса @code{mglGraph}} @code{void} MultiPlot (@code{int} nx, @code{int} ny, @code{int} m, @code{int} dx, @code{int} dy, @code{const char *}stl=@code{"<>_^"})
@deftypefnx {Функция С} @code{void} mgl_multiplot (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} m, @code{int} dx, @code{int} dy, @code{const char *}stl)
@end ifclear
-Помещает последующий вывод в прямоугольник из @var{dx}*@var{dy} ячеек, начиная с @var{m}-ой ячейки, сетки размером @var{nx}*@var{ny} от всего рисунка. Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика". Место для осей/colorbar резервируется если строка @var{style} содержит: @samp{L} или @samp{<} -- с левого края, @samp{R} или @samp{>} -- с правого края, @samp{A} или @samp{^} -- с верхнего края, @samp{U} или @samp{_} -- с нижнего края.
+Помещает последующий вывод в прямоугольник из @var{dx}*@var{dy} ячеек, начиная с @var{m}-ой ячейки, сетки размером @var{nx}*@var{ny} от всего рисунка. Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика". Место для осей/colorbar резервируется если строка @var{stl} содержит: @samp{L} или @samp{<} -- с левого края, @samp{R} или @samp{>} -- с правого края, @samp{A} или @samp{^} -- с верхнего края, @samp{U} или @samp{_} -- с нижнего края.
@end deftypefn
@anchor{inplot}
@deftypefn {Команда MGL} {} inplot @code{x1 x2 y1 y2 [rel=off]}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} InPlot (@code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{bool} rel=@code{false})
-@deftypefnx {Функция С} @code{void} mgl_inplot (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2)
-@deftypefnx {Функция С} @code{void} mgl_relplot (@code{HMGL} gr, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} InPlot (@code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2, @code{bool} rel=@code{false})
+@deftypefnx {Функция С} @code{void} mgl_inplot (@code{HMGL} gr, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2)
+@deftypefnx {Функция С} @code{void} mgl_relplot (@code{HMGL} gr, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2)
@end ifclear
-Помещает последующий вывод в прямоугольную область [@var{x1}, @var{x2}]*[@var{y1}, @var{y2}] (исходный размер [0,1]*[0,1]). Эта функция позволяет поместить график в произвольную область рисунка. Если параметр @var{rel}=@code{true}, то используется позиция относительно текущего SubPlot() (или InPlot() с @var{rel}=@code{false}). Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика".
+Помещает последующий вывод в прямоугольную область [@var{x1}, @var{x2}]*[@var{y1}, @var{y2}] (исходный размер [0,1]*[0,1]). Эта функция позволяет поместить график в произвольную область рисунка. Если параметр @var{rel}=@code{true}, то используется позиция относительно текущего @ref{subplot} (или @ref{inplot} с @var{rel}=@code{false}). Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться первой для создания "подграфика".
@end deftypefn
@anchor{columnplot}
@deftypefn {Команда MGL} {} columnplot @code{num ind [d=0]}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} ColumnPlot (@code{int} num, @code{int} ind, @code{float} d=@code{0})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ColumnPlot (@code{int} num, @code{int} ind, @code{mreal} d=@code{0})
@deftypefnx {Функция С} @code{void} mgl_columnplot (@code{HMGL} gr, @code{int} num, @code{int} ind)
-@deftypefnx {Функция С} @code{void} mgl_columnplot_d (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{float} d)
+@deftypefnx {Функция С} @code{void} mgl_columnplot_d (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{mreal} d)
@end ifclear
-Помещает последующий вывод в @var{ind}-ую строку столбца из @var{num} строк. Положение столбца выбирается относительно последнего вызова SubPlot() (или InPlot() с @var{rel}=@code{false}). Параметр @var{d} задает дополнительный зазор между строк.
+Помещает последующий вывод в @var{ind}-ую строку столбца из @var{num} строк. Положение столбца выбирается относительно последнего вызова @ref{subplot} (или @ref{inplot} с @var{rel}=@code{false}). Параметр @var{d} задает дополнительный зазор между строк.
@end deftypefn
@anchor{gridplot}
@deftypefn {Команда MGL} {} gridplot @code{nx ny ind [d=0]}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} GridPlot (@code{int} nx, @code{int} ny, @code{int} ind, @code{float} d=@code{0})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} GridPlot (@code{int} nx, @code{int} ny, @code{int} ind, @code{mreal} d=@code{0})
@deftypefnx {Функция С} @code{void} mgl_gridplot (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} ind)
-@deftypefnx {Функция С} @code{void} mgl_gridplot_d (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} ind, @code{float} d)
+@deftypefnx {Функция С} @code{void} mgl_gridplot_d (@code{HMGL} gr, @code{int} nx, @code{int} ny, @code{int} ind, @code{mreal} d)
@end ifclear
-Помещает последующий вывод в @var{ind}-ую ячейку таблицы @var{nx}*@var{ny}. Положение ячейки выбирается относительно последнего вызова SubPlot() (или InPlot() с @var{rel}=@code{false}). Параметр @var{d} задает дополнительный зазор между строк.
+Помещает последующий вывод в @var{ind}-ую ячейку таблицы @var{nx}*@var{ny}. Положение ячейки выбирается относительно последнего вызова @ref{subplot} (или @ref{inplot} с @var{rel}=@code{false}). Параметр @var{d} задает дополнительный зазор между строк.
@end deftypefn
@anchor{stickplot}
@deftypefn {Команда MGL} {} stickplot @code{num ind tet phi}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} StickPlot (@code{int} num, @code{int} ind, @code{float} tet, @code{float} phi)
-@deftypefnx {Функция С} @code{void} mgl_stickplot (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{float} tet, @code{float} phi)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} StickPlot (@code{int} num, @code{int} ind, @code{mreal} tet, @code{mreal} phi)
+@deftypefnx {Функция С} @code{void} mgl_stickplot (@code{HMGL} gr, @code{int} num, @code{int} ind, @code{mreal} tet, @code{mreal} phi)
@end ifclear
-Помещает последующий вывод в @var{ind}-ую ячейку "бруска" из @var{num} ячеек. При этом сам брусок повернут на углы @var{tet}, @var{phi}. Положение выбирается относительно последнего вызова SubPlot() (или InPlot() с @var{rel}=@code{false}).
+Помещает последующий вывод в @var{ind}-ую ячейку "бруска" из @var{num} ячеек. При этом сам брусок повернут на углы @var{tet}, @var{phi}. Положение выбирается относительно последнего вызова @ref{subplot} (или @ref{inplot} с @var{rel}=@code{false}).
@end deftypefn
-
@anchor{title}
@deftypefn {Команда MGL} {} title 'title' ['stl'='' @code{size=-2}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Title (@code{const char *}txt, @code{const char *}stl=@code{""}, @code{float} size=@code{-2})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Title (@code{const wchar_t *}txt, @code{const char *}stl=@code{""}, @code{float} size=@code{-2})
-@deftypefnx {Функция С} @code{void} mgl_title (@code{HMGL} gr, @code{const char *}txt, @code{const char *}stl, @code{float} size)
-@deftypefnx {Функция С} @code{void} mgl_titlew (@code{HMGL} gr, @code{const wchar_t *}txt, @code{const char *}stl, @code{float} size)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Title (@code{const char *}txt, @code{const char *}stl=@code{""}, @code{mreal} size=@code{-2})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Title (@code{const wchar_t *}txt, @code{const char *}stl=@code{""}, @code{mreal} size=@code{-2})
+@deftypefnx {Функция С} @code{void} mgl_title (@code{HMGL} gr, @code{const char *}txt, @code{const char *}stl, @code{mreal} size)
+@deftypefnx {Функция С} @code{void} mgl_titlew (@code{HMGL} gr, @code{const wchar_t *}txt, @code{const char *}stl, @code{mreal} size)
@end ifclear
Выводит заголовок @var{title} для текущего "подграфика" шрифтом @var{stl} с размером @var{size}. Если строка @var{stl} содержит @samp{#}, то рисуется обрамляющий прямоугольник. Функция сбрасывает матрицу трансформации (повороты и сжатие графика) и должна вызываться сразу после создания "подграфика".
@end deftypefn
@anchor{rotate}
@deftypefn {Команда MGL} {} rotate @code{tetz tetx [tety=0]}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Rotate (@code{float} TetX, @code{float} TetZ, @code{float} TetY=@code{0})
-@deftypefnx {Функция С} @code{void} mgl_rotate (@code{HMGL} gr, @code{float} TetX, @code{float} TetZ, @code{float} TetY)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Rotate (@code{mreal} TetX, @code{mreal} TetZ, @code{mreal} TetY=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_rotate (@code{HMGL} gr, @code{mreal} TetX, @code{mreal} TetZ, @code{mreal} TetY)
@end ifclear
Вращает систему координат относительно осей @{x, z, y@} последовательно на углы @var{TetX}, @var{TetZ}, @var{TetY}.
@end deftypefn
@deftypefn {Команда MGL} {} rotate @code{tet x y z}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} RotateN (@code{float} Tet, @code{float} x, @code{float} y, @code{float} z)
-@deftypefnx {Функция С} @code{void} mgl_rotate_vector (@code{HMGL} gr, @code{float Tet}, @code{float x}, @code{float y}, @code{float z})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} RotateN (@code{mreal} Tet, @code{mreal} x, @code{mreal} y, @code{mreal} z)
+@deftypefnx {Функция С} @code{void} mgl_rotate_vector (@code{HMGL} gr, @code{mreal Tet}, @code{mreal x}, @code{mreal y}, @code{mreal z})
@end ifclear
Вращает систему координат относительно вектора @{@var{x}, @var{y}, @var{z}@} на угол @var{Tet}.
@end deftypefn
@anchor{aspect}
@deftypefn {Команда MGL} {} aspect @code{ax ay [az=1]}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Aspect (@code{float} Ax, @code{float} Ay, @code{float} Az=@code{1})
-@deftypefnx {Функция С} @code{void} mgl_aspect (@code{HMGL} gr, @code{float} Ax, @code{float} Ay, @code{float} Az)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Aspect (@code{mreal} Ax, @code{mreal} Ay, @code{mreal} Az=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_aspect (@code{HMGL} gr, @code{mreal} Ax, @code{mreal} Ay, @code{mreal} Az)
@end ifclear
-Устанавливает соотношение размеров осей в отношении @var{Ax:Ay:Az}. Для лучшего вида следует вызывать после функции Rotate().
+Устанавливает соотношение размеров осей в отношении @var{Ax:Ay:Az}. Для лучшего вида следует вызывать после функции @ref{rotate}.
@end deftypefn
@anchor{perspective}
@deftypefn {Команда MGL} {} perspective @code{val}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Perspective (@code{float} a)
-@deftypefnx {Функция С} @code{void} mgl_perspective (@code{HMGL} gr, @code{float} a)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Perspective (@code{mreal} a)
+@deftypefnx {Функция С} @code{void} mgl_perspective (@code{HMGL} gr, @code{mreal} a)
@end ifclear
Добавляет (включает) перспективу для графика. Параметр @math{a ~ 1/z_@{eff@} \in [0,1)}. По умолчанию (@code{a=0}) перспектива отключена.
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{void} Push ()
@deftypefnx {Функция С} @code{void} mgl_mat_push (@code{HMGL} gr)
-Помещает матрицу преобразования в стек. Позднее вы можете восстановить текущее состояние с помощью функции Pop(). Стек может содержать до 10 матриц.
+Помещает матрицу преобразования в стек. Позднее вы можете восстановить текущее состояние с помощью функции Pop().
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{void} Pop ()
Заменяет (восстанавливает) матрицу преобразования на последнюю помещенную в стек матрицу.
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} SetPlotFactor (@code{float} val)
-@deftypefnx {Функция С} @code{void} mgl_set_plotfactor (@code{HMGL} gr, @code{float} val)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} SetPlotFactor (@code{mreal} val)
+@deftypefnx {Функция С} @code{void} mgl_set_plotfactor (@code{HMGL} gr, @code{mreal} val)
Задает масштаб картинки. Не рекомендуется устанавливать значения меньше 1.5. Это аналог функции Zoom(), но применяется только к конкретному подграфику. Используйте ноль для включения автоматического масштабирования.
@end deftypefn
Также есть 2 функции, которые управляют масштабированием @code{Zoom()} и вращением @code{View()} всего рисунка. Т.е. они действуют как ещё одна матрица трансформации. Они были введены для вращения/приближения графика с помощью мыши.
-@deftypefn {Метод класса @code{mglGraph}} @code{void} View (@code{float} TetX, @code{float} TetZ, @code{float} TetY=@code{0})
-@deftypefnx {Функция С} @code{void} mgl_view (@code{HMGL} gr, @code{float} TetX, @code{float} TetZ, @code{float} TetY)
-Вращает систему координат относительно осей @{x, z, y@} последовательно на углы @var{TetX}, @var{TetZ}, @var{TetY}. Вращение происходит независимо от @code{Rotate()}.
+@deftypefn {Метод класса @code{mglGraph}} @code{void} View (@code{mreal} TetX, @code{mreal} TetZ, @code{mreal} TetY=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_view (@code{HMGL} gr, @code{mreal} TetX, @code{mreal} TetZ, @code{mreal} TetY)
+Вращает систему координат относительно осей @{x, z, y@} последовательно на углы @var{TetX}, @var{TetZ}, @var{TetY}. Вращение происходит независимо от @ref{rotate}. Используйте @code{Zoom(0,0,1,1)} для возвращения к виду по умолчанию.
@end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Zoom (@code{float} x1, @code{float} y1, @code{float} x2, @code{float} y2)
-@deftypefnx {Функция С} @code{void} mgl_set_zoom (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} x2, @code{float} y2)
-Ð\9cаÑ\81Ñ\88Ñ\82абиÑ\80Ñ\83еÑ\82 веÑ\81Ñ\8c Ñ\80иÑ\81Ñ\83нок. Ð\9fоÑ\81ле вÑ\8bзова Ñ\84Ñ\83нкÑ\86ии Ñ\82екÑ\83Ñ\89ий гÑ\80аÑ\84ик бÑ\83деÑ\82 оÑ\87иÑ\89ен и в далÑ\8cнейÑ\88ем Ñ\80иÑ\81Ñ\83нок бÑ\83деÑ\82 Ñ\81одеÑ\80жаÑ\82Ñ\8c Ñ\82олÑ\8cко облаÑ\81Ñ\82Ñ\8c [x1,x2]*[y1,y2] оÑ\82 иÑ\81Ñ\85одного Ñ\80иÑ\81Ñ\83нка. Ð\9aооÑ\80динаÑ\82Ñ\8b @var{x1}, @var{x2}, @var{y1}, @var{y2} менÑ\8fÑ\8eÑ\82Ñ\81Ñ\8f в диапазоне оÑ\82 0 до 1. Ð\92нимание! Ñ\8dÑ\82и наÑ\81Ñ\82Ñ\80ойки не могÑ\83Ñ\82 бÑ\8bÑ\82Ñ\8c пеÑ\80епиÑ\81анÑ\8b никакими дÑ\80Ñ\83гими Ñ\84Ñ\83нкÑ\86иÑ\8fми. Ð\98Ñ\81полÑ\8cзÑ\83йÑ\82е @code{Zoom(0,0,1,1)} длÑ\8f пеÑ\80еÑ\85ода в маÑ\81Ñ\88Ñ\82аб по умолчанию.
+@deftypefn {Метод класса @code{mglGraph}} @code{void} Zoom (@code{mreal} x1, @code{mreal} y1, @code{mreal} x2, @code{mreal} y2)
+@deftypefnx {Функция С} @code{void} mgl_set_zoom (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} x2, @code{mreal} y2)
+Ð\9cаÑ\81Ñ\88Ñ\82абиÑ\80Ñ\83еÑ\82 веÑ\81Ñ\8c Ñ\80иÑ\81Ñ\83нок. Ð\9fоÑ\81ле вÑ\8bзова Ñ\84Ñ\83нкÑ\86ии Ñ\82екÑ\83Ñ\89ий гÑ\80аÑ\84ик бÑ\83деÑ\82 оÑ\87иÑ\89ен и в далÑ\8cнейÑ\88ем Ñ\80иÑ\81Ñ\83нок бÑ\83деÑ\82 Ñ\81одеÑ\80жаÑ\82Ñ\8c Ñ\82олÑ\8cко облаÑ\81Ñ\82Ñ\8c [x1,x2]*[y1,y2] оÑ\82 иÑ\81Ñ\85одного Ñ\80иÑ\81Ñ\83нка. Ð\9aооÑ\80динаÑ\82Ñ\8b @var{x1}, @var{x2}, @var{y1}, @var{y2} менÑ\8fÑ\8eÑ\82Ñ\81Ñ\8f в диапазоне оÑ\82 0 до 1. Ð\92нимание! Ñ\8dÑ\82и наÑ\81Ñ\82Ñ\80ойки не могÑ\83Ñ\82 бÑ\8bÑ\82Ñ\8c пеÑ\80епиÑ\81анÑ\8b никакими дÑ\80Ñ\83гими Ñ\84Ñ\83нкÑ\86иÑ\8fми. Ð\98Ñ\81полÑ\8cзÑ\83йÑ\82е @code{Zoom(0,0,1,1)} длÑ\8f возвÑ\80аÑ\89ениÑ\8f к видÑ\83 по умолчанию.
@end deftypefn
@end ifclear
-
@c ##################################################################
+@external
@node Export picture, Primitives, Subplots and rotation, MathGL core
@section Экспорт рисунка
@cindex SetSize
@end menu
@c ==================================================================
+@external
@node Export to file, Frames/Animation, , Export picture
@subsection Экспорт в файл
@cindex Write
@deftypefn {Метод класса @code{mglGraph}} @code{void} WritePNG (@code{const char *}fname, @code{const char *}descr=@code{""}, @code{int} compr=@code{""}, @code{bool} alpha=@code{true})
@deftypefnx {Функция С} @code{void} mgl_write_png (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
@deftypefnx {Функция С} @code{void} mgl_write_png_solid (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
-Экспортирует текущий кадр в PNG файл. Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла, @var{alpha} -- прозрачность фона.
+Экспортирует текущий кадр в PNG файл. Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла, @var{alpha} -- прозрачность фона. Если при компиляции MathGL не был определен флаг HAVE_PNG, то экспорт в файл не производится.
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{void} WriteJPEG (@code{const char *}fname, @code{const char *}descr=@code{""})
@c @end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} WriteIDTF (@code{const char *}fname, @code{const char *}descr=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_write_idtf (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
-Экспортирует текущий кадр в IDTF файл, используя векторное представление графика (класс mglGraphIDTF). Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
-@end deftypefn
+@c @deftypefn {Метод класса @code{mglGraph}} @code{void} WriteIDTF (@code{const char *}fname, @code{const char *}descr=@code{""})
+@c @deftypefnx {Функция С} @code{void} mgl_write_idtf (@code{HMGL} gr, @code{const char *}fname, @code{const char *}descr)
+@c Экспортирует текущий кадр в IDTF файл, используя векторное представление графика (класс mglGraphIDTF). Параметры функции следующие: @var{fname} -- имя файла, @var{descr} -- описание файла.
+@c @end deftypefn
-@deftypefn {Метод класса @code{mglGraph}} @code{void} ShowImage (@code{const char *}viewer=@code{"kuickshow"}, @code{bool} nowait=@code{false})
+@deftypefn {Метод класса @code{mglGraph}} @code{void} ShowImage (@code{const char *}viewer, @code{bool} nowait=@code{false})
@deftypefnx {Функция С} @code{void} mgl_show_image (@code{const char *}viewer, @code{int} nowait)
Отображает текущий кадр используя внешнюю программу просмотра @var{viewer}. Функция сохраняет картинку во временный файл и вызывает @var{viewer} для его отображения. Если @var{nowait}=@code{true}, то функция возвращает управление немедленно -- не ждет пока окно просмотра будет закрыто.
@end deftypefn
@c ##################################################################
+@external
@node Frames/Animation, Bitmap in memory, Export to file, Export picture
@subsection Кадры/Анимация
@ifset UDAV
-В MGL нет специальных команд для создания анимации. Однако можно воспользоваться возможностями утилит (см. @ref{Utilities}). Например, используя комментарии спеиального вида @samp{##a } или @samp{##c }.
+В MGL нет специальных команд для создания анимации. Однако можно воспользоваться возможностями утилит @code{mglconv} и @code{mglview}. Например, используя комментарии спеиального вида @samp{##a } или @samp{##c }.
@end ifset
@ifclear UDAV
@end ifclear
@c ------------------------------------------------------------------
+@external
@node Bitmap in memory, Parallelization, Frames/Animation, Export picture
@subsection Рисование в памяти
@deftypefnx {Метод класса @code{mglGraph}} @code{void} GetRGB (@code{char *}buf, @code{int} size)
@deftypefnx {Метод класса @code{mglGraph}} @code{void} GetBGRN (@code{char *}buf, @code{int} size)
@deftypefnx {Функция С} @code{const unsigned char *} mgl_get_rgb (@code{HMGL} gr)
-Возвращает растровое изображение в формате RGB для текущего кадра. Формат каждого элемента (пикселя): @{red, green, blue@}. Число элементов Width*Height. Положение элемента @{i,j@} есть [3*i + 3*Width*j] (или [4*i + 4*Width*j] для @code{GetBGRN()}). В Python вы должны предоставить буфер @var{buf} достаточного размера @var{size}, т.е. код должен выглядеть следующим образом
+Возвращает растровое изображение в формате RGB для текущего кадра. Формат каждого элемента (пикселя): @{red, green, blue@}. Число элементов Width*Height. Положение элемента @{i,j@} есть [3*i + 3*Width*j] (или [4*i + 4*Width*j] для @code{GetBGRN()}). В Python вы должны предоставить буфер @var{buf} достаточного размера @var{size}, т.е. код должен выглядеть следующим образом (для Python)
@verbatim
from mathgl import *
gr = mglGraph();
@deftypefn {Метод класса @code{mglGraph}} @code{mglPoint} CalcXYZ (@code{int} xs, @code{int} ys)
-@deftypefnx {Функция С} @code{void} mgl_calc_xyz (@code{HMGL} gr, @code{int} xs, @code{int} ys, @code{float *}x, @code{float *}y, @code{float *}z)
-Вычисляет 3D координаты @{x,y,z@} для экранной точки @{xs,ys@}. В данный момент игнорируется перспектива графика и формулы перехода в криволинейные координаты. Вычисления производятся для последнего использованного InPlot (см. @ref{Transformation matrix}).
+@deftypefnx {Функция С} @code{void} mgl_calc_xyz (@code{HMGL} gr, @code{int} xs, @code{int} ys, @code{mreal *}x, @code{mreal *}y, @code{mreal *}z)
+Вычисляет 3D координаты @{x,y,z@} для экранной точки @{xs,ys@}. В данный момент игнорируется перспектива графика и формулы перехода в криволинейные координаты. Вычисления производятся для последнего использованного InPlot (см. @ref{Subplots and rotation}).
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{mglPoint} CalcScr (@code{mglPoint} p)
-@deftypefnx {Функция С} @code{void} mgl_calc_scr (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{int *}xs, @code{int *}ys)
-Вычисляет экранные координаты @{xs,ys@} для 3D координат @{x,y,z@}. Вычисления производятся для последнего использованного InPlot (см. @ref{Transformation matrix}).
+@deftypefnx {Функция С} @code{void} mgl_calc_scr (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{int *}xs, @code{int *}ys)
+Вычисляет экранные координаты @{xs,ys@} для 3D координат @{x,y,z@}. Вычисления производятся для последнего использованного InPlot (см. @ref{Subplots and rotation}).
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{void} SetObjId (@code{int} id)
@deftypefnx {Функция С} @code{void} mgl_set_obj_id (@code{HMGL} gr, @code{int} id)
-Задает числовой идентификатор для объектов или "подграфиков".
+Задает числовой идентификатор для объектов или subplot/inplot.
@end deftypefn
@deftypefn {Метод класса @code{mglGraph}} @code{int} GetObjId (@code{long} xs, @code{long} ys)
@end ifclear
@c ------------------------------------------------------------------
+@external
@node Parallelization, , Bitmap in memory, Export picture
@subsection Распараллеливание
@ifclear UDAV
-@cindex SetDrawReg
-@cindex PutDrawReg
@cindex Combine
@cindex MPI_Send
@cindex MPI_Recv
@c ##################################################################
+@external
@node Primitives, Text printing, Export picture, MathGL core
@section Рисование примитивов
@cindex Ball
@deftypefn {Команда MGL} {} clf
@ifclear UDAV
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Clf ()
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Clf (@code{float} r, @code{float} g, @code{float} b)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Clf (@code{mreal} r, @code{mreal} g, @code{mreal} b)
@deftypefnx {Функция С} @code{void} mgl_clf (@code{HMGL} gr)
-@deftypefnx {Функция С} @code{void} mgl_clf_rgb (@code{HMGL} gr, @code{float} r, @code{float} g, @code{float} b)
+@deftypefnx {Функция С} @code{void} mgl_clf_rgb (@code{HMGL} gr, @code{mreal} r, @code{mreal} g, @code{mreal} b)
@end ifclear
Очищает рисунок и заполняет его заданным цветом.
@end deftypefn
@ifclear UDAV
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Ball (@code{mglPoint} p, @code{char} col=@code{'r'})
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Mark (@code{mglPoint} p, @code{const char *}mark)
-@deftypefnx {Функция С} @code{void} mgl_ball (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z)
-@deftypefnx {Функция С} @code{void} mgl_mark (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const char *}mark)
+@deftypefnx {Функция С} @code{void} mgl_mark (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{const char *}mark)
@end ifclear
Рисует маркер (точку по умолчанию) с координатами @var{p}=@{@var{x}, @var{y}, @var{z}@} и цветом @var{col}.
@end deftypefn
@ifclear UDAV
@deftypefn {Метод класса @code{mglGraph}} @code{void} Error (@code{mglPoint} p, @code{mglPoint} e, @code{char} *stl=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_error_box (@code{HMGL} gr, @code{float} px, @code{float} py, @code{float} pz, @code{float} ex, @code{float} ey, @code{float} ez, @code{char *}stl)
-Рисует 3d error box в точке @var{p} размером @var{e} и стилем @var{stl}.
+@deftypefnx {Функция С} @code{void} mgl_error_box (@code{HMGL} gr, @code{mreal} px, @code{mreal} py, @code{mreal} pz, @code{mreal} ex, @code{mreal} ey, @code{mreal} ez, @code{char *}stl)
+Рисует 3d error box в точке @var{p} размером @var{e} и стилем @var{stl}. Используйте NAN в компонентах @var{e} для уменьшения рисуемых элементов.
@end deftypefn
@end ifclear
@deftypefnx {Команда MGL} {} line @code{x1 y1 z1 x2 y2 z2} ['stl'='']
@ifclear UDAV
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Line (@code{mglPoint} p1, @code{mglPoint} p2, @code{char *}stl=@code{"B"}, @code{int}num=@code{2})
-@deftypefnx {Функция С} @code{void} mgl_line (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{char *}stl, @code{int}num)
+@deftypefnx {Функция С} @code{void} mgl_line (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{char *}stl, @code{int}num)
@end ifclear
-Рисует геодезическую линию (декартовых координатах -- прямую) из точки @var{p1} в @var{p2} использую стиль линии @var{stl}. Параметр @var{num} определяет гладкость линии (число точек на линии). Если @var{num}=@code{2}, то рисуется прямая даже в криволинейных координатах. Наоборот, для больших значений (например, =@code{100}) рисуется геодезическая линия (окружность в полярных координатах, парабола в параболических и т.д.). Линия рисуется даже если часть ее лежит вне диапазона осей координат.
+Рисует геодезическую линию (декартовых координатах -- прямую) из точки @var{p1} в @var{p2} использую стиль линии @var{stl}. Параметр @var{num} определяет гладкость линии (число точек на линии). Если @var{num}=@code{2}, то рисуется прямая даже в криволинейных координатах (см. @ref{Curved coordinates}). Наоборот, для больших значений (например, =@code{100}) рисуется геодезическая линия (окружность в полярных координатах, парабола в параболических и т.д.). Линия рисуется даже если часть ее лежит вне диапазона осей координат.
@end deftypefn
@anchor{curve}
@deftypefnx {Команда MGL} {} curve @code{x1 y1 z1 dx1 dy1 dz1 x2 y2 z2 dx2 dy2 dz2} ['stl'='']
@ifclear UDAV
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Curve (@code{mglPoint} p1, @code{mglPoint} d1, @code{mglPoint} p2, @code{mglPoint} d2, @code{const char *}stl=@code{"B"}, @code{int} num=@code{100})
-@deftypefnx {Функция С} @code{void} mgl_curve (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} dx1, @code{float} dy1, @code{float} dz1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} dx2, @code{float} dy2, @code{float} dz2, @code{const char *}stl, @code{int} num)
+@deftypefnx {Функция С} @code{void} mgl_curve (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} dx1, @code{mreal} dy1, @code{mreal} dz1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{mreal} dx2, @code{mreal} dy2, @code{mreal} dz2, @code{const char *}stl, @code{int} num)
@end ifclear
-Рисует кривую Безье из точки @var{p1} в @var{p2} используя стиль линии @var{stl}. Касательные в точках пропорциональны @var{d1}, @var{d2}. Параметр @var{num} определяет гладкость линии (число точек на линии). Кривая рисуется даже если часть ее лежит вне диапазона осей координат.
+РиÑ\81Ñ\83еÑ\82 кÑ\80ивÑ\83Ñ\8e Ð\91езÑ\8cе из Ñ\82оÑ\87ки @var{p1} в @var{p2} иÑ\81полÑ\8cзÑ\83Ñ\8f Ñ\81Ñ\82илÑ\8c линии @var{stl}. Ð\9aаÑ\81аÑ\82елÑ\8cнÑ\8bе в Ñ\82оÑ\87каÑ\85 пÑ\80опоÑ\80Ñ\86ионалÑ\8cнÑ\8b @var{d1}, @var{d2}. Ð\9fаÑ\80амеÑ\82Ñ\80 @var{num} опÑ\80еделÑ\8fеÑ\82 гладкоÑ\81Ñ\82Ñ\8c линии (Ñ\87иÑ\81ло Ñ\82оÑ\87ек на линии). Ð\95Ñ\81ли @var{num}=@code{2}, Ñ\82о Ñ\80иÑ\81Ñ\83еÑ\82Ñ\81Ñ\8f пÑ\80Ñ\8fмаÑ\8f даже в кÑ\80иволинейнÑ\8bÑ\85 кооÑ\80динаÑ\82аÑ\85 (Ñ\81м. @ref{Curved coordinates}). Ð\9dаобоÑ\80оÑ\82, длÑ\8f болÑ\8cÑ\88иÑ\85 знаÑ\87ений (напÑ\80имеÑ\80, =@code{100}) Ñ\80иÑ\81Ñ\83еÑ\82Ñ\81Ñ\8f геодезиÑ\87еÑ\81каÑ\8f линиÑ\8f (окÑ\80Ñ\83жноÑ\81Ñ\82Ñ\8c в полÑ\8fÑ\80нÑ\8bÑ\85 кооÑ\80динаÑ\82аÑ\85, паÑ\80абола в паÑ\80аболиÑ\87еÑ\81киÑ\85 и Ñ\82.д.). Ð\9aÑ\80иваÑ\8f Ñ\80иÑ\81Ñ\83еÑ\82Ñ\81Ñ\8f даже еÑ\81ли Ñ\87аÑ\81Ñ\82Ñ\8c ее лежиÑ\82 вне диапазона оÑ\81ей кооÑ\80динаÑ\82.
@end deftypefn
@ifclear UDAV
@deftypefn {Метод класса @code{mglGraph}} @code{void} Face (@code{mglPoint} p1, @code{mglPoint} p2, @code{mglPoint} p3, @code{mglPoint} p4, @code{const char *}stl=@code{"w"})
-@deftypefnx {Функция С} @code{void} mgl_curve (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} x3, @code{float} y3, @code{float} z3, @code{float} x4, @code{float} y4, @code{float} z4, @code{const char *}stl)
+@deftypefnx {Функция С} @code{void} mgl_curve (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{mreal} x3, @code{mreal} y3, @code{mreal} z3, @code{mreal} x4, @code{mreal} y4, @code{mreal} z4, @code{const char *}stl)
Рисует заполненный четырехугольник (грань) с углами в точках @var{p1}, @var{p2}, @var{p3}, @var{p4} и цветом(-ами) @var{stl}. При этом цвет может быть один для всей грани, или различным если указаны все 4 цвета. Грань будет нарисована даже если часть ее лежит вне диапазона осей координат.
@end deftypefn
@end ifclear
@deftypefn {Команда MGL} {} facex @code{x0 y0 z0 wy wz} ['stl'='' @code{d1=0 d2=0}]
@deftypefnx {Команда MGL} {} facey @code{x0 y0 z0 wx wz} ['stl'='' @code{d1=0 d2=0}]
@deftypefnx {Команда MGL} {} facez @code{x0 y0 z0 wx wy} ['stl'='' @code{d1=0 d2=0}]
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} FaceX (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wy, @code{float} wz, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} FaceY (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wz, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} FaceZ (@code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wy, @code{const char *}stl=@code{"w"}, @code{float} d1=@code{0}, @code{float} d2=@code{0})
-@deftypefnx {Функция С} @code{void} mgl_facex (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wy, @code{float} wz, @code{const char *}stl, @code{float} d1, @code{float} d2)
-@deftypefnx {Функция С} @code{void} mgl_facey (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wz, @code{const char *}stl, @code{float} d1, @code{float} d2)
-@deftypefnx {Функция С} @code{void} mgl_facez (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} wx, @code{float} wy, @code{const char *}stl, @code{float} d1, @code{float} d2)
-Рисует закрашенный прямоугольник (грань) перпендикулярно оси [x,y,z] в точке @{@var{x0}, @var{y0}, @var{z0}@} цветом @var{stl} и шириной @var{wx}, @var{wy}, @var{wz} вдоль соответствующего направления. При этом цвет может быть один для всей грани, или различным для разных вершин если указаны все 4 цвета. Параметры @var{d1}!=0, @var{d2}!=0 задают дополнительный сдвиг последней точки (т.е. рисуют четырехугольник).Грань будет нарисована даже если часть ее лежит вне диапазона осей координат.
+@ifclear UDAV
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} FaceX (@code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wy, @code{mreal} wz, @code{const char *}stl=@code{"w"}, @code{mreal} d1=@code{0}, @code{mreal} d2=@code{0})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} FaceY (@code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wx, @code{mreal} wz, @code{const char *}stl=@code{"w"}, @code{mreal} d1=@code{0}, @code{mreal} d2=@code{0})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} FaceZ (@code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wx, @code{mreal} wy, @code{const char *}stl=@code{"w"}, @code{mreal} d1=@code{0}, @code{mreal} d2=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_facex (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wy, @code{mreal} wz, @code{const char *}stl, @code{mreal} d1, @code{mreal} d2)
+@deftypefnx {Функция С} @code{void} mgl_facey (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wx, @code{mreal} wz, @code{const char *}stl, @code{mreal} d1, @code{mreal} d2)
+@deftypefnx {Функция С} @code{void} mgl_facez (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} wx, @code{mreal} wy, @code{const char *}stl, @code{mreal} d1, @code{mreal} d2)
+@end ifclear
+Рисует закрашенный прямоугольник (грань) перпендикулярно оси [x,y,z] в точке @{@var{x0}, @var{y0}, @var{z0}@} цветом @var{stl} и шириной @var{wx}, @var{wy}, @var{wz} вдоль соответствующего направления. При этом цвет может быть один для всей грани, или различным для разных вершин если указаны все 4 цвета. Параметры @var{d1}!=0, @var{d2}!=0 задают дополнительный сдвиг последней точки (т.е. рисуют четырехугольник). Грань будет нарисована даже если часть ее лежит вне диапазона осей координат.
@end deftypefn
@anchor{sphere}
@deftypefn {Команда MGL} {} sphere @code{x0 y0 r} ['col'='r']
@deftypefnx {Команда MGL} {} sphere @code{x0 y0 z0 r} ['col'='r']
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Sphere (@code{mglPoint} p, @code{float} r, @code{const char *}stl=@code{"r"})
-@deftypefnx {Функция С} @code{void} mgl_sphere (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} r, @code{const char *}stl)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Sphere (@code{mglPoint} p, @code{mreal} r, @code{const char *}stl=@code{"r"})
+@deftypefnx {Функция С} @code{void} mgl_sphere (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} r, @code{const char *}stl)
@end ifclear
Рисует сферу радиуса @var{r} с центром в точке @var{p}=@{@var{x0}, @var{y0}, @var{z0}@} цветом @var{stl}.
@end deftypefn
@deftypefn {Команда MGL} {} drop @code{x0 y0 dx dy r} ['col'='r' @code{sh=1 asp=1}]
@deftypefnx {Команда MGL} {} drop @code{x0 y0 z0 dx dy dz r} ['col'='r' @code{sh=1 asp=1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Drop (@code{mglPoint} p, @code{mglPoint} d, @code{float} r, @code{const char *}col=@code{"r"}, @code{float} shift=@code{1}, @code{float} ap=@code{1})
-@deftypefnx {Функция С} @code{void} mgl_drop (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} dx, @code{float} dy, @code{float} dz, @code{float} r, @code{const char *}col, @code{float} shift, @code{float} ap)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Drop (@code{mglPoint} p, @code{mglPoint} d, @code{mreal} r, @code{const char *}col=@code{"r"}, @code{mreal} shift=@code{1}, @code{mreal} ap=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_drop (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{mreal} r, @code{const char *}col, @code{mreal} shift, @code{mreal} ap)
@end ifclear
-Рисует каплю радиуса @var{r} в точке @var{p} вытянутую вдоль направления @var{d} цветом @var{col}. Параметр @var{shift} определяет степень вытянутости: @samp{0} -- сфера, @samp{1} -- классическая капля. Параметр @var{ap} определяет относительную ширину капли (аналог "эллиптичности" для сферы). @sref{Drops sample}
+Рисует каплю радиуса @var{r} в точке @var{p} вытянутую вдоль направления @var{d} цветом @var{col}. Параметр @var{shift} определяет степень вытянутости: @samp{0} -- сфера, @samp{1} -- классическая капля. Параметр @var{ap} определяет относительную ширину капли (аналог "эллиптичности" для сферы).
@end deftypefn
@anchor{cone}
@deftypefn {Команда MGL} {} cone @code{x1 y1 z1 x2 y2 z2 r1} [@code{r2=-1} 'stl'='' @code{edge=off}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Cone (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r1, @code{float} r2=@code{-1}, @code{const char *}stl=@code{"B"}, @code{bool} edge=@code{false})
-@deftypefnx {Функция С} @code{void} mgl_cone (@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r1, @code{float} r2, @code{const char *}stl, @code{int} draw_edge)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Cone (@code{mglPoint} p1, @code{mglPoint} p2, @code{mreal} r1, @code{mreal} r2=@code{-1}, @code{const char *}stl=@code{"B"}, @code{bool} edge=@code{false})
+@deftypefnx {Функция С} @code{void} mgl_cone (@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{mreal} r1, @code{mreal} r2, @code{const char *}stl, @code{int} draw_edge)
@end ifclear
Рисует трубу (или усеченный конус если @var{edge}=@code{false}) между точками @var{p1}, @var{p2} с радиусами на концах @var{r1}, @var{r2}. Если @var{r2}<0, то полагается @var{r2}=@var{r1}. Цвет конуса задается строкой @var{stl}.
@end deftypefn
@deftypefn {Команда MGL} {} circle @code{x0 y0 r} ['col'='r']
@deftypefnx {Команда MGL} {} circle @code{x0 y0 z0 r} ['col'='r']
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Circle (@code{mglPoint} p, @code{float} r, @code{const char *}stl=@code{"r"})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Circle (@code{mglPoint} p, @code{mreal} r, @code{const char *}stl=@code{"r"})
@end ifclear
Рисует круг радиуса @var{r} с центром в точке @var{p}=@{@var{x0}, @var{y0}, @var{z0}@} цветом @var{stl}. Если @var{col} содержит: @samp{#} то рисуется только граница, @samp{@@} то рисуется граница (вторым цветом из @var{col} или черными).
@end deftypefn
@deftypefn {Команда MGL} {} ellipse @code{x1 y1 x2 y2 r} ['col'='r' @code{sh=1 asp=1}]
@deftypefnx {Команда MGL} {} ellipse @code{x1 y1 z1 x2 y2 z2 r} ['col'='r' @code{sh=1 asp=1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Ellipse (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r, @code{const char *}col=@code{"r"})
-@deftypefnx {Функция С} @code{void} mgl_ellipse(@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r, @code{const char *}col)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Ellipse (@code{mglPoint} p1, @code{mglPoint} p2, @code{mreal} r, @code{const char *}col=@code{"r"})
+@deftypefnx {Функция С} @code{void} mgl_ellipse(@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{mreal} r, @code{const char *}col)
@end ifclear
-Рисует круг радиуса @var{r} с фокусами в точках @var{p1}, @var{p2} цветом @var{stl}. Если @var{col} содержит: @samp{#} то рисуется только граница, @samp{@@} то рисуется граница (вторым цветом из @var{col} или черными). @sref{Ellipse sample}
+Рисует круг радиуса @var{r} с фокусами в точках @var{p1}, @var{p2} цветом @var{stl}. Если @var{col} содержит: @samp{#} то рисуется только граница, @samp{@@} то рисуется граница (вторым цветом из @var{col} или черными).
@end deftypefn
@anchor{rhomb}
@deftypefn {Команда MGL} {} rhomb @code{x1 y1 x2 y2 r} ['col'='r' @code{sh=1 asp=1}]
@deftypefnx {Команда MGL} {} rhomb @code{x1 y1 z1 x2 y2 z2 r} ['col'='r' @code{sh=1 asp=1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Rhomb (@code{mglPoint} p1, @code{mglPoint} p2, @code{float} r, @code{const char *}col=@code{"r"})
-@deftypefnx {Функция С} @code{void} mgl_rhomb(@code{HMGL} gr, @code{float} x1, @code{float} y1, @code{float} z1, @code{float} x2, @code{float} y2, @code{float} z2, @code{float} r, @code{const char *}col)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Rhomb (@code{mglPoint} p1, @code{mglPoint} p2, @code{mreal} r, @code{const char *}col=@code{"r"})
+@deftypefnx {Функция С} @code{void} mgl_rhomb(@code{HMGL} gr, @code{mreal} x1, @code{mreal} y1, @code{mreal} z1, @code{mreal} x2, @code{mreal} y2, @code{mreal} z2, @code{mreal} r, @code{const char *}col)
@end ifclear
-Рисует ромб ширины @var{r} с вершинами в точках @var{p1}, @var{p2} цветом @var{stl}. Если @var{col} содержит: @samp{#} то рисуется только граница, @samp{@@} то рисуется граница (вторым цветом из @var{col} или черными). Если @var{col} содержит 3 цвета, то используется градиентная заливка. @sref{Ellipse sample}
+Рисует ромб ширины @var{r} с вершинами в точках @var{p1}, @var{p2} цветом @var{stl}. Если @var{col} содержит: @samp{#} то рисуется только граница, @samp{@@} то рисуется граница (вторым цветом из @var{col} или черными). Если @var{col} содержит 3 цвета, то используется градиентная заливка.
@end deftypefn
@c ##################################################################
+@external
@node Text printing, Axis and Colorbar, Primitives, MathGL core
@section Вывод текста
@ifclear UDAV
@cindex Label
@cindex fgets
-Функции для вывода текста позволяют вывести строку текста в произвольном месте рисунка, в произвольном направлении и вдоль произвольной кривой. MathGL позволяет использовать произвольное начертание шрифта и многие ТеХ-ие команды (детальнее см. @ref{Font styles}). Все функции вывода текста имеют варианты для 8-bit строк (@code{char *}) и для Unicode строк (@code{wchar_t *}). В первом случае используется конверсия из текущей локали, т.е. иногда вам требуется явно указать локаль с помощью функции @code{setlocale()}. Аргумент @var{size} определяет размер текста: размер шрифта если положителен или относительный размер (=-@var{size}*@var{FontSize}) если отрицателен. Начертание шрифта (STIX, arial, courier, times и др) можно изменить с помощью функции LoadFont(). @xref{Font settings}.
+Функции для вывода текста позволяют вывести строку текста в произвольном месте рисунка, в произвольном направлении и вдоль произвольной кривой. MathGL позволяет использовать произвольное начертание шрифта и многие ТеХ-ие команды (детальнее см. @ref{Font styles}). Все функции вывода текста имеют варианты для 8-bit строк (@code{char *}) и для Unicode строк (@code{wchar_t *}). В первом случае используется конверсия из текущей локали, т.е. иногда вам требуется явно указать локаль с помощью функции @code{setlocale()}. Аргумент @var{size} определяет размер текста: размер шрифта если положителен или относительный размер (=-@var{size}*@code{SetFontSize()}) если отрицателен. Начертание шрифта (STIX, arial, courier, times и др.) можно изменить с помощью функции LoadFont(). @xref{Font settings}.
-Параметры шрифта задаются строкой, которая может содержать символы цвета @samp{wkrgbcymhRGBCYMHW} (см. @ref{Line styles}) и, после символа @samp{:}, символы стиля (@samp{rbiwou}) и/или выравнивания (@samp{LRC}). Стили шрифта: @samp{r} -- прямой, @samp{i} -- курсив, @samp{b} -- жирный, @samp{w} -- контурный, @samp{o} -- надчеркнутый, @samp{u} -- подчеркнутый. По умолчанию используется прямой шрифт. Типы выравнивания: @samp{L} -- по левому краю (по умолчанию), @samp{C} -- по центру, @samp{R} -- по правому краю. Например, строка @samp{b:iC} соответствует курсиву синего цвета с выравниванием по центру.
+Параметры шрифта задаются строкой, которая может содержать символы цвета @samp{wkrgbcymhRGBCYMHW} (см. @ref{Color styles}). Также после символа @samp{:} можно указать символы стиля (@samp{rbiwou}) и/или выравнивания (@samp{LRC}). Стили шрифта: @samp{r} -- прямой, @samp{i} -- курсив, @samp{b} -- жирный, @samp{w} -- контурный, @samp{o} -- надчеркнутый, @samp{u} -- подчеркнутый. По умолчанию используется прямой шрифт. Типы выравнивания: @samp{L} -- по левому краю (по умолчанию), @samp{C} -- по центру, @samp{R} -- по правому краю. Например, строка @samp{b:iC} соответствует курсиву синего цвета с выравниванием по центру.
-Если строка содержит символы @samp{aA}, то текст выводится в абсолютных координатах (полагаются в диапазоне [0,1]). При этом используются координаты относительно рисунка (если указано @samp{A}) или относительно последнего SubPlot()/InPlot() (если указано @samp{a}). Если строка содержит символ @samp{@@}, то вокруг текста рисуется прямоугольник.
+Если строка содержит символы @samp{aA}, то текст выводится в абсолютных координатах (полагаются в диапазоне [0,1]). При этом используются координаты относительно рисунка (если указано @samp{A}) или относительно последнего subplot/inplot (если указано @samp{a}). Если строка содержит символ @samp{@@}, то вокруг текста рисуется прямоугольник.
@sref{Text features}
@deftypefn {Команда MGL} {} text @code{x y} 'text' ['fnt'='' @code{size=-1}]
@deftypefnx {Команда MGL} {} text @code{x y z} 'text' ['fnt'='' @code{size=-1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{float} size=@code{-1})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{const wchar_t *}text, @code{const char *}fnt=@code{""}, @code{float} size=@code{-1})
-@deftypefnx {Функция С} @code{void} mgl_puts (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const char *}text, @code{const char *}fnt, @code{float} size)
-@deftypefnx {Функция С} @code{void} mgl_putsw (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const wchar_t *}text, @code{const char *}fnt, @code{float} size)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{const char *}text, @code{const char *}fnt=@code{":C"}, @code{mreal} size=@code{-1})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{const wchar_t *}text, @code{const char *}fnt=@code{":C"}, @code{mreal} size=@code{-1})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Puts (@code{mreal} x, @code{mreal} y, @code{const char *}text, @code{const char *}fnt=@code{":AC"}, @code{mreal} size=@code{-1})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Putsw (@code{mreal} x, @code{mreal} y, @code{const wchar_t *}text, @code{const char *}fnt=@code{":AC"}, @code{mreal} size=@code{-1})
+@deftypefnx {Функция С} @code{void} mgl_puts (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{const char *}text, @code{const char *}fnt, @code{mreal} size)
+@deftypefnx {Функция С} @code{void} mgl_putsw (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{const wchar_t *}text, @code{const char *}fnt, @code{mreal} size)
@end ifclear
-Выводит строку @var{text} от точки @var{p} шрифтом определяемым строкой @var{fnt}.
+Выводит строку @var{text} от точки @var{p} шрифтом определяемым строкой @var{fnt}. Размер шрифта задается параметром @var{size} (по умолчанию @code{-1}).
@end deftypefn
@deftypefn {Команда MGL} {} text @code{x y dx dy} 'text' ['fnt'=':L' @code{size=-1}]
@deftypefnx {Команда MGL} {} text @code{x y z dx dy dz} 'text' ['fnt'=':L' @code{size=-1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{mglPoint} d, @code{const char *}text, @code{const char *}fnt=@code{':L'}, @code{float} size=@code{-1})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{mglPoint} d, @code{const wchar_t *}text, @code{const char *}fnt=@code{':L'}, @code{float} size=@code{-1})
-@deftypefnx {Функция С} @code{void} mgl_puts_dir (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{float} dx, @code{float} dy, @code{float} dz, @code{const char *}text, @code{const char *}fnt, @code{float} size)
-@deftypefnx {Функция С} @code{void} mgl_putsw_dir (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{float} dx, @code{float} dy, @code{float} dz, @code{const wchar_t *}text, @code{const char *}fnt, @code{float} size)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Puts (@code{mglPoint} p, @code{mglPoint} d, @code{const char *}text, @code{const char *}fnt=@code{':L'}, @code{mreal} size=@code{-1})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Putsw (@code{mglPoint} p, @code{mglPoint} d, @code{const wchar_t *}text, @code{const char *}fnt=@code{':L'}, @code{mreal} size=@code{-1})
+@deftypefnx {Функция С} @code{void} mgl_puts_dir (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{const char *}text, @code{const char *}fnt, @code{mreal} size)
+@deftypefnx {Функция С} @code{void} mgl_putsw_dir (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{mreal} dx, @code{mreal} dy, @code{mreal} dz, @code{const wchar_t *}text, @code{const char *}fnt, @code{mreal} size)
@end ifclear
Выводит строку @var{text} от точки @var{p} вдоль направления @var{d}. Параметр @var{fnt} задает стиль текста и указывает выводить текст над линией (@samp{T}) или под ней (@samp{t}).
@end deftypefn
@anchor{fgets}
@deftypefn {Команда MGL} {} fgets @code{x y} 'fname' [@code{n=0} 'fnt'='' @code{size=-1.4}]
@deftypefnx {Команда MGL} {} fgets @code{x y z} 'fname' [@code{n=0} 'fnt'='' @code{size=-1.4}]
-Выводит @var{n}-ую строку файла @var{fname} от точки @{@var{x},@var{y},@var{z}@} шрифтом @var{fnt} и размером @var{size}.
+Выводит @var{n}-ую строку файла @var{fname} от точки @{@var{x},@var{y},@var{z}@} шрифтом @var{fnt} и размером @var{size}. По умолчанию используются параметры заданные командой @ref{font}.
@end deftypefn
@deftypefn {Команда MGL} {} text ydat 'text' ['fnt'='']
@deftypefnx {Команда MGL} {} text xdat ydat 'text' ['fnt'='' @code{size=-1 zval=nan}]
@deftypefnx {Команда MGL} {} text xdat ydat zdat 'text' ['fnt'='' @code{size=-1}]
@ifclear UDAV
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Text (@code{const mglData &}y, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Text (@code{const mglData &}y, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Text (@code{const mglData &}y, @code{const wchar_t *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Text (@code{const mglData &}x, @code{const mglData &}y, @code{const char *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Text (@code{const mglData &}x, @code{const mglData &}y, @code{const wchar_t *}text, @code{const char *}fnt=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Функция С} @code{void} mgl_text_xyz (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}text, @code{const char *}fnt, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_textw_xyz (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const wchar_t *}text, @code{const char *}fnt, @code{const char *}opt)
@end ifclear
-Выводит строку @var{text} вдоль кривой @{@var{x}[i], @var{y}[i], @var{z}[i]@} шрифтом @var{fnt}. Строка @var{fnt} может содержать символы: @samp{t} для вывода текста под кривой (по умолчанию), или @samp{T} для вывода текста над кривой. Размеры по 1-ой размерности должны быть одинаковы для всех массивов @code{x.nx=y.nx=z.nx}. Если массив @var{x} не указан, то используется "автоматический" массив со значениями в диапазоне [@var{Min}.x, @var{Max}.x] (см. @ref{Ranges (bounding box)}). Если массив @var{z} не указан, то используется @var{z}[i] = @var{Min}.z. Строка @var{opt} содержит опции команды (см. @ref{Command options}). @sref{Text sample}
+Выводит строку @var{text} вдоль кривой @{@var{x}[i], @var{y}[i], @var{z}[i]@} шрифтом @var{fnt}. Строка @var{fnt} может содержать символы: @samp{t} для вывода текста под кривой (по умолчанию), или @samp{T} для вывода текста над кривой. Размеры по 1-ой размерности должны быть одинаковы для всех массивов @code{x.nx=y.nx=z.nx}. Если массив @var{x} не указан, то используется "автоматический" массив со значениями в диапазоне [@var{Min}.x, @var{Max}.x] (см. @ref{Ranges (bounding box)}). Если массив @var{z} не указан, то используется @var{z}[i] = @var{Min}.z. Строка @var{opt} содержит опции команды (см. @ref{Command options}).
@end deftypefn
@c ##################################################################
+@external
@node Axis and Colorbar, Legend, Text printing, MathGL core
@section Оси и Colorbar
@cindex Axis
@deftypefn {Команда MGL} {} colorbar 'sch' @code{x y [w=1 h=1]}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Colorbar (@code{const char *}sch, @code{float} x, @code{float} y, @code{float} w=@code{1}, @code{float} h=@code{1})
-@deftypefnx {Функция С} @code{void} mgl_colorbar_ext (@code{HMGL} gr, @code{const char *}sch, @code{float} x, @code{float} y, @code{float} w, @code{float} h)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Colorbar (@code{const char *}sch, @code{mreal} x, @code{mreal} y, @code{mreal} w=@code{1}, @code{mreal} h=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_colorbar_ext (@code{HMGL} gr, @code{const char *}sch, @code{mreal} x, @code{mreal} y, @code{mreal} w, @code{mreal} h)
@end ifclear
Аналогично первому, но в произвольном месте графика @{@var{x}, @var{y}@} (полагаются в диапазоне [0,1]). Параметры @var{w}, @var{h} задают относительную ширину и высоту colorbar.
@end deftypefn
@deftypefn {Команда MGL} {} colorbar vdat 'sch' @code{x y [w=1 h=1]}
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Colorbar (@code{const mglData &}v, @code{const char *}sch, @code{float} x, @code{float} y, @code{float} w=@code{1}, @code{float} h=@code{1})
-@deftypefnx {Функция С} @code{void} mgl_colorbar_val_ext (@code{HMGL} gr, @code{HCDT} v, @code{const char *}sch, @code{float} x, @code{float} y, @code{float} w, @code{float} h)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Colorbar (@code{const mglData &}v, @code{const char *}sch, @code{mreal} x, @code{mreal} y, @code{mreal} w=@code{1}, @code{mreal} h=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_colorbar_val_ext (@code{HMGL} gr, @code{HCDT} v, @code{const char *}sch, @code{mreal} x, @code{mreal} y, @code{mreal} w, @code{mreal} h)
@end ifclear
-Аналогично предыдущему, но для цветовой схемы без сглаживания с заданными значениями @var{v}.
+Аналогично предыдущему, но для цветовой схемы @var{sch} без сглаживания с заданными значениями @var{v}. @sref{ContD sample}
@end deftypefn
@anchor{grid}
@deftypefnx {Команда MGL} {} zlabel 'text' [@code{pos=1 shift=0}]
@deftypefnx {Команда MGL} {} tlabel 'text' [@code{pos=1 shift=0}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Label (@code{char} dir, @code{const char *}text, @code{float} pos=@code{1}, @code{float} shift=@code{0})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Label (@code{char} dir, @code{const wchar_t *}text, @code{float} pos=@code{1}, @code{float} shift=@code{0})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Label (@code{char} dir, @code{const char *}text, @code{mreal} pos=@code{1}, @code{mreal} shift=@code{0})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Label (@code{char} dir, @code{const wchar_t *}text, @code{mreal} pos=@code{1}, @code{mreal} shift=@code{0})
@deftypefnx {Функция С} @code{void} mgl_label (@code{HMGL} gr, @code{char} dir, @code{const char *}text)
-@deftypefnx {Функция С} @code{void} mgl_label_ext (@code{HMGL} gr, @code{char} dir, @code{const char *}text, @code{float} pos, @code{float} shift)
-@deftypefnx {Функция С} @code{void} mgl_labelw_ext (@code{HMGL} gr, @code{char} dir, @code{const wchar_t *}text, @code{float} pos, @code{float} shift)
+@deftypefnx {Функция С} @code{void} mgl_label_ext (@code{HMGL} gr, @code{char} dir, @code{const char *}text, @code{mreal} pos, @code{mreal} shift)
+@deftypefnx {Функция С} @code{void} mgl_labelw_ext (@code{HMGL} gr, @code{char} dir, @code{const wchar_t *}text, @code{mreal} pos, @code{mreal} shift)
@end ifclear
Выводит подпись @var{text} для оси @var{dir}=@samp{x},@samp{y},@samp{z},@samp{t} (где @samp{t} -- ``тернарная'' ось @math{t=1-x-y}). Параметр @var{pos} задает положение подписи: при @var{pos}=0 -- по центру оси, при @var{pos}>0 -- около максимальных значений, при @var{pos}<0 -- около минимальных значений. @xref{Text printing}.
@end deftypefn
@c ##################################################################
+@external
@node Legend, 1D plotting, Axis and Colorbar, MathGL core
@section Легенда
@cindex Legend
@anchor{legend}
@deftypefn {Команда MGL} {} legend [@code{pos=3} 'fnt'='#' @code{size=-0.8 llen=0.1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Legend (@code{int} pos=@code{0x3}, @code{const char *}fnt=@code{"#"}, @code{float} size=@code{-0.8}, @code{float} llen=@code{0.1})
-@deftypefnx {Функция С} @code{void} mgl_legend (@code{HMGL} gr, @code{int} pos, @code{const char *}fnt, @code{float} size, @code{float} llen)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Legend (@code{int} pos=@code{0x3}, @code{const char *}fnt=@code{"#"}, @code{mreal} size=@code{-0.8}, @code{mreal} llen=@code{0.1})
+@deftypefnx {Функция С} @code{void} mgl_legend (@code{HMGL} gr, @code{int} pos, @code{const char *}fnt, @code{mreal} size, @code{mreal} llen)
@end ifclear
Рисует легенду из накопленных записей шрифтом @var{fnt} размером @var{size}. Параметр @var{pos} задает положение легенды: @samp{0} -- в нижнем левом углу, @samp{1} -- нижнем правом углу, @samp{2} -- верхнем левом углу, @samp{3} -- верхнем правом углу (по умолчанию). Строка @var{fnt} может содержать вет для прямоугольника (1-ый цвет), для его границы (2-ой цвет) и для текста (последний). Если указано менее 3 цветов, то цвет рёбер будет чёрным (2 и менее цвета), а цвет прямоугольника белым (1 и менее цвета). Прямоугольник рисуется если строка @var{fnt} содержит @samp{#}.
@end deftypefn
@deftypefn {Команда MGL} {} legend @code{x y} ['fnt'='#' @code{size=-1 llen=0.1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Legend (@code{float} x, @code{float} y, @code{const char *}fnt=@code{"#"}, @code{float} size=@code{-0.8}, @code{float} llen=@code{0.1})
-@deftypefnx {Функция С} @code{void} mgl_legend_pos (@code{HMGL} gr, @code{float} x, @code{float} y, @code{const char *}fnt, @code{float} size, @code{float} llen)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Legend (@code{mreal} x, @code{mreal} y, @code{const char *}fnt=@code{"#"}, @code{mreal} size=@code{-0.8}, @code{mreal} llen=@code{0.1})
+@deftypefnx {Функция С} @code{void} mgl_legend_pos (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{const char *}fnt, @code{mreal} size, @code{mreal} llen)
@end ifclear
Рисует легенду из накопленных записей шрифтом @var{fnt} размером @var{size}. Положение легенды задается параметрами @var{x}, @var{y}, которые полагаются нормированными в диапазоне [0,1].
@end deftypefn
@end deftypefn
@c ##################################################################
+@external
@node 1D plotting, 2D plotting, Legend, MathGL core
@section 1D графики
-
@cindex Plot
@cindex Radar
@cindex Tens
@deftypefnx {Функция С} @code{void} mgl_plot_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_plot_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
@end ifclear
-Функции рисуют ломанную линию по точкам. См. также @ref{area}, @ref{step}, @ref{stem}, @ref{tube}, @ref{mark}, @ref{error}, @ref{belt}, @ref{tens}, @ref{tape}. @sref{Plot sample}
+Функции рисуют ломанную линию по точкам @{@var{x}[i], @var{y}[i], @var{z}[i]@}. См. также @ref{area}, @ref{step}, @ref{stem}, @ref{tube}, @ref{mark}, @ref{error}, @ref{belt}, @ref{tens}, @ref{tape}. @sref{Plot sample}
@end deftypefn
@anchor{radar}
@deftypefnx {Функция С} @code{void} mgl_tape_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{const char *}pen, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_tape_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}pen, @code{const char *}opt)
@end ifclear
-Функции рисуют ленты, которые вращаются вокруг кривой @{@var{x}[i], @var{y}[i], @var{z}[i]@} как её нормали. Начальная лента(ы) выбираются в плоскости x-y (для @samp{x} в @var{pen}) и/или y-z (для @samp{x} в @var{pen}). Ширина лент пропорциональна @code{SetBarWidth()}. См. также @ref{plot}, @ref{flow}, @ref{barwidth}. @sref{Tape sample}
+Функции рисуют ленты, которые вращаются вокруг кривой @{@var{x}[i], @var{y}[i], @var{z}[i]@} как её нормали. Начальная лента(ы) выбираются в плоскости x-y (для @samp{x} в @var{pen}) и/или y-z (для @samp{x} в @var{pen}). Ширина лент пропорциональна @ref{barwidth}. См. также @ref{plot}, @ref{flow}, @ref{barwidth}. @sref{Tape sample}
@end deftypefn
@anchor{area}
@deftypefnx {Функция С} @code{void} mgl_error_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ey, @code{const char *}pen, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_error_exy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ex, @code{HCDT} ey, @code{const char *}pen, @code{const char *}opt)
@end ifclear
-Функции рисуют размер ошибки в точках @{@var{x}[i], @var{y}[i]@} на плоскости @var{z} = @var{zVal} (по умолчанию @var{z}=@var{Min.z}). Такой график полезен для отображения ошибки эксперимента, вычислений и пр. Если @var{pen} содержит @samp{@@}, то будут использованы большие полупрозрачные маркеры. См. также @ref{plot}, @ref{mark}. @sref{Error sample}
+Функции рисуют размер ошибки @{@var{ex}[i], @var{ey}[i]@} в точках @{@var{x}[i], @var{y}[i]@} на плоскости @var{z} = @var{zVal} (по умолчанию @var{z}=@var{Min.z}). Такой график полезен для отображения ошибки эксперимента, вычислений и пр. Если @var{pen} содержит @samp{@@}, то будут использованы большие полупрозрачные маркеры. См. также @ref{plot}, @ref{mark}. @sref{Error sample}
@end deftypefn
@anchor{mark}
@deftypefnx {Функция С} @code{void} mgl_mark_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_mark_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
@end ifclear
-Функции рисуют маркеры размером @var{r}*@var{MarkSize} (см. @ref{Default sizes}) в точках @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Для рисования маркеров одинакового размера можно использовать функцию @ref{plot} с невидимой линией (со стилем содержащим @samp{ }). Для маркеров с размером как у координат можно использовать @ref{error} со стилем @samp{@@}. См. также @ref{plot}, @ref{textmark}, @ref{error}, @ref{stem}. @sref{Mark sample}
+Функции рисуют маркеры размером @var{r}[i]*@ref{marksize} (см. @ref{Default sizes}) в точках @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Для рисования маркеров одинакового размера можно использовать функцию @ref{plot} с невидимой линией (со стилем содержащим @samp{ }). Для маркеров с размером как у координат можно использовать @ref{error} со стилем @samp{@@}. См. также @ref{plot}, @ref{textmark}, @ref{error}, @ref{stem}. @sref{Mark sample}
@end deftypefn
@anchor{textmark}
@deftypefnx {Функция С} @code{void} mgl_textmark_xyzr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} r, @code{const char *}txt, @code{const char *}fnt, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_textmarkw_xyzr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} r, @code{const wchar_t *}txt, @code{const char *}fnt, @code{const char *}opt)
@end ifclear
-Функции рисуют текст @var{text} как маркер с размером пропорциональным @var{r}*@var{MarkSize} (см. @ref{Default sizes}) в точках @{@var{x}[i], @var{y}[i], @var{z}[i]@}. См. также @ref{plot}, @ref{mark}, @ref{stem}. @sref{TextMark sample}
+Функции рисуют текст @var{txt} как маркер с размером пропорциональным @var{r}[i]*@var{marksize} в точках @{@var{x}[i], @var{y}[i], @var{z}[i]@}. См. также @ref{plot}, @ref{mark}, @ref{stem}. @sref{TextMark sample}
@end deftypefn
@anchor{label}
@deftypefnx {Команда MGL} {} tube xdat ydat zdat @code{rval} ['stl'='']
@ifclear UDAV
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}y, @code{float} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}y, @code{mreal} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{float} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{mreal} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{float} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Tube (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{mreal} r, @code{const char *}pen=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Функция С} @code{void} mgl_tube_r (@code{HMGL} gr, @code{HCDT} y, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_tube (@code{HMGL} gr, @code{HCDT} y, @code{float} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_tube (@code{HMGL} gr, @code{HCDT} y, @code{mreal} r, @code{const char *}pen, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_tube_xyr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_tube_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{float} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_tube_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{mreal} r, @code{const char *}pen, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_tube_xyzr (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} r, @code{const char *}pen, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_tube_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{float} r, @code{const char *}pen, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_tube_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{mreal} r, @code{const char *}pen, @code{const char *}opt)
@end ifclear
Функции рисуют трубу радиуса @var{r}[i] вдоль кривой между точками @{@var{x}[i], @var{y}[i], @var{z}[i]@}. См. также @ref{plot}. @sref{Tube sample}
@end deftypefn
@c ##################################################################
+@external
@node 2D plotting, 3D plotting, 1D plotting, MathGL core
@section 2D графики
@cindex Mesh
Эти функции строят графики для двумерных (2D) массивов. Двумерными считаются массивы, зависящие только от двух параметров (индексов) подобно матрице @math{f(x_i,y_j), i=1...n, j=1...m}. По умолчанию (если отсутствуют) значения @var{x}, @var{y} равно распределены в диапазоне осей координат. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=z.nx && y.nx=z.ny} или @code{x.nx=y.nx=z.nx && x.ny=y.ny=z.ny}. Массивы @var{x} и @var{y} могут быть векторами (не матрицами как @var{z}). График строится для каждого z среза данных. Строка @var{sch} задает цветовую схему (см. @ref{Color scheme}). Строка @var{opt} задает опции графика (см. @ref{Command options}). @sref{2D samples}
-
@anchor{surf}
@deftypefn {Команда MGL} {} surf zdat ['sch'='']
@deftypefnx {Команда MGL} {} surf xdat ydat zdat ['sch'='']
@deftypefn {Команда MGL} {} dens zdat ['sch'='']
@deftypefnx {Команда MGL} {} dens xdat ydat zdat ['sch'='']
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Dens (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{float} zVal=@code{NAN})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Dens (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{float} zVal=@code{NAN})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Dens (@code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{mreal} zVal=@code{NAN})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Dens (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""}, @code{mreal} zVal=@code{NAN})
@deftypefnx {Функция С} @code{void} mgl_dens (@code{HMGL} gr, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_dens_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@end ifclear
@deftypefnx {Функция С} @code{void} mgl_contv_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_contv_xy_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Рисует вертикальные цилиндры от линий уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z=v}[k] или при @var{z} = @var{Min}.z если @var{sch} содержит @samp{_}. Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. См. также @ref{cont}, @ref{contf}. @sref{ContV sample}
+Рисует вертикальные цилиндры от линий уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} при @var{z}=@var{v}[k] или при @var{z} = @var{Min}.z если @var{sch} содержит @samp{_}. Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. См. также @ref{cont}, @ref{contf}. @sref{ContV sample}
@end deftypefn
@deftypefn {Команда MGL} {} contv zdat ['sch'='']
@deftypefnx {Функция С} @code{void} mgl_axial_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_axial_xy_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Рисует поверхность вращения линии уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. Если @var{sch} содержит @samp{#}, то рисуется сетчатая поверхность. Если строка содержит символы @samp{x}, @samp{y} или @samp{z}, то ось вращения устанавливается в указанное направление. См. также @ref{cont}, @ref{contf}, @ref{torus}, @ref{surf3}. @sref{Axial sample}
+Рисует поверхность вращения линии уровня для параметрически заданной поверхности @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@}. Линии уровня рисуются для @var{z}[i,j]=@var{v}[k]. Если @var{sch} содержит @samp{#}, то рисуется сетчатая поверхность. Если строка содержит символы @samp{x} или @samp{z}, то ось вращения устанавливается в указанное направление (по умолчанию вдоль @samp{y}). См. также @ref{cont}, @ref{contf}, @ref{torus}, @ref{surf3}. @sref{Axial sample}
@end deftypefn
@deftypefn {Команда MGL} {} axial zdat ['sch'='']
@c ##################################################################
+@external
@node 3D plotting, Dual plotting, 2D plotting, MathGL core
@section 3D графики
@cindex Surf3
@deftypefn {Команда MGL} {} surf3 adat @code{val} ['sch'='']
@deftypefnx {Команда MGL} {} surf3 xdat ydat zdat adat @code{val} ['sch'='']
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3 (@code{float} val, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3 (@code{float} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_surf3_val (@code{HMGL} gr, @code{float} val, @code{HCDT} a, @code{const char *}sch, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_surf3_xyz_val (@code{HMGL} gr, @code{float} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3 (@code{mreal} val, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3 (@code{mreal} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_surf3_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} a, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_surf3_xyz_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{const char *}opt)
@end ifclear
Рисует поверхность уровня для 3d массива, заданного параметрически @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]) при @var{a}(x,y,z)=@var{val}. Если @var{sch} содержит @samp{#}, то рисуется сетчатая поверхность. Замечу, что возможно некорректная отрисовка граней вследствие неопределённости построения сечения если поверхность пересекает ячейку данных 2 и более раз. См. также @ref{cloud}, @ref{dens3}, @ref{surf3c}, @ref{surf3a}, @ref{axial}. @sref{Surf3 sample}
@end deftypefn
@deftypefn {Команда MGL} {} dens3 adat ['sch'='' @code{sval=-1}]
@deftypefnx {Команда MGL} {} dens3 xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Dens3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Dens3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_dens3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_dens3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Dens3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Dens3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_dens3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_dens3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
-Рисует график плотности для 3d массива, заданного параметрически @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). График рисуется на срезе @var{sVal} в направлении @var{dir}=@{@samp{x}, @samp{y}, @samp{z}@}. Если @var{stl} содержит @samp{#}, то на срезе рисуется сетка. См. также @ref{cont3}, @ref{contf3}, @ref{dens}, @ref{grid3}. @sref{Dens3 sample}
+Рисует график плотности для 3d массива, заданного параметрически @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). График рисуется на срезе @var{sVal} в направлении @{@samp{x}, @samp{y}, @samp{z}@}, указанном в строке @var{sch} (по умолчанию, в напралении @samp{y}). Если @var{sch} содержит @samp{#}, то на срезе рисуется сетка. См. также @ref{cont3}, @ref{contf3}, @ref{dens}, @ref{grid3}. @sref{Dens3 sample}
@end deftypefn
@anchor{cont3}
@deftypefn {Команда MGL} {} cont3 vdat adat ['sch'='' @code{sval=-1}]
@deftypefnx {Команда MGL} {} cont3 vdat xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_cont3_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_cont3_xyz_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_cont3_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_cont3_xyz_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
-Рисует линии уровня для 3d массива, заданного параметрически @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). Линии рисуются для значений из массива @var{v} на срезе @var{sVal} в направлении @var{dir}=@{@samp{x}, @samp{y}, @samp{z}@}. Если @var{stl} содержит @samp{#}, то на срезе рисуется сетка. Если @var{sch} содержит @samp{t} или @samp{T}, то значения @var{v}[k] будут выведены вдоль контуров над (или под) кривой. См. также @ref{dens3}, @ref{contf3}, @ref{cont}, @ref{grid3}. @sref{Cont3 sample}
+Рисует линии уровня для 3d массива, заданного параметрически @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). Линии рисуются для значений из массива @var{v} на срезе @var{sVal} в направлении @{@samp{x}, @samp{y}, @samp{z}@}, указанном в строке @var{sch} (по умолчанию, в напралении @samp{y}). Если @var{sch} содержит @samp{#}, то на срезе рисуется сетка. Если @var{sch} содержит @samp{t} или @samp{T}, то значения @var{v}[k] будут выведены вдоль контуров над (или под) кривой. См. также @ref{dens3}, @ref{contf3}, @ref{cont}, @ref{grid3}. @sref{Cont3 sample}
@end deftypefn
@deftypefn {Команда MGL} {} cont3 adat ['sch'='' @code{sval=-1}]
@deftypefnx {Команда MGL} {} cont3 xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_cont3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_cont3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Cont3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_cont3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_cont3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
Аналогично предыдущему для @var{num} линий уровня равномерно распределённых в диапазоне изменения цвета. Величина @var{num} равна значению параметра @var{value} в опциях @var{opt} (по умолчанию 7).
@end deftypefn
@deftypefn {Команда MGL} {} contf3 vdat adat ['sch'='' @code{sval=-1}]
@deftypefnx {Команда MGL} {} contf3 vdat xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_contf3_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_contf3_xyz_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}v, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_contf3_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_contf3_xyz_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
-Рисует закрашенные линии (контуры) уровня для 3d массива, заданного параметрически @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). Линии рисуются для значений из массива @var{v} на срезе @var{sVal} в направлении @var{dir}=@{@samp{x}, @samp{y}, @samp{z}@}. Если @var{stl} содержит @samp{#}, то на срезе рисуется сетка. См. также @ref{dens3}, @ref{cont3}, @ref{contf}, @ref{grid3}. @sref{Cont3 sample}
+Рисует закрашенные линии (контуры) уровня для 3d массива, заданного параметрически @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). Линии рисуются для значений из массива @var{v} на срезе @var{sVal} в направлении @{@samp{x}, @samp{y}, @samp{z}@}, указанном в строке @var{sch} (по умолчанию, в напралении @samp{y}). Если @var{sch} содержит @samp{#}, то на срезе рисуется сетка. См. также @ref{dens3}, @ref{cont3}, @ref{contf}, @ref{grid3}. @sref{ContF3 sample}
@end deftypefn
@deftypefn {Команда MGL} {} contf3 adat ['sch'='' @code{sval=-1}]
@deftypefnx {Команда MGL} {} contf3 xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_contf3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_contf3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Contf3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_contf3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_contf3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
Аналогично предыдущему для @var{num} закрашенных линий (контуров) уровня равномерно распределённых в диапазоне изменения цвета. Величина @var{num} равна значению параметра @var{value} в опциях @var{opt} (по умолчанию 7).
@end deftypefn
@deftypefn {Команда MGL} {} grid3 adat ['sch'='' @code{sval=-1}]
@deftypefnx {Команда MGL} {} grid3 xdat ydat zdat adat ['sch'='' @code{sval=-1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Grid3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Grid3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{float} sVal=@code{-1}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_grid3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_grid3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Grid3 (@code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Grid3 (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const char *}sch=@code{""}, @code{mreal} sVal=@code{-1}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_grid3 (@code{HMGL} gr, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_grid3_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}sch, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
-Рисует сетку для 3d массива, заданного параметрически @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). График рисуется на срезе @var{sVal} в направлении @var{dir}=@{@samp{x}, @samp{y}, @samp{z}@}. См. также @ref{cont3}, @ref{contf3}, @ref{dens3}, @ref{grid2}, @ref{meshnum}.
+Рисует сетку для 3d массива, заданного параметрически @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]). График рисуется на срезе @var{sVal} в направлении @{@samp{x}, @samp{y}, @samp{z}@}, указанном в строке @var{sch} (по умолчанию, в напралении @samp{y}). См. также @ref{cont3}, @ref{contf3}, @ref{dens3}, @ref{grid2}, @ref{meshnum}.
@end deftypefn
@anchor{beam}
@deftypefn {Команда MGL} {} beam tr g1 g2 adat @code{rval} ['sch'='' @code{flag=0 num=3}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Beam (@code{const mglData &}tr, @code{const mglData &}g1, @code{const mglData &}g2, @code{const mglData &}a, @code{float} r, @code{const char *}stl=@code{""}, @code{int} flag=@code{0}, @code{int} num=@code{3})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Beam (@code{float} val, @code{const mglData &}tr, @code{const mglData &}g1, @code{const mglData &}g2, @code{const mglData &}a, @code{float} r, @code{const char *}stl=@code{""}, @code{int} flag=@code{0})
-@deftypefnx {Функция С} @code{void} mgl_beam (@code{HMGL} gr, @code{HCDT} tr, @code{HCDT} g1, @code{HCDT} g2, @code{HCDT} a, @code{float} r, @code{const char *}stl, @code{int} flag, @code{int} num)
-@deftypefnx {Функция С} @code{void} mgl_beam_val (@code{HMGL} gr, @code{float} val, @code{HCDT} tr, @code{HCDT} g1, @code{HCDT} g2, @code{HCDT} a, @code{float} r, @code{const char *}stl, @code{int} flag)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Beam (@code{const mglData &}tr, @code{const mglData &}g1, @code{const mglData &}g2, @code{const mglData &}a, @code{mreal} r, @code{const char *}stl=@code{""}, @code{int} flag=@code{0}, @code{int} num=@code{3})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Beam (@code{mreal} val, @code{const mglData &}tr, @code{const mglData &}g1, @code{const mglData &}g2, @code{const mglData &}a, @code{mreal} r, @code{const char *}stl=@code{""}, @code{int} flag=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_beam (@code{HMGL} gr, @code{HCDT} tr, @code{HCDT} g1, @code{HCDT} g2, @code{HCDT} a, @code{mreal} r, @code{const char *}stl, @code{int} flag, @code{int} num)
+@deftypefnx {Функция С} @code{void} mgl_beam_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} tr, @code{HCDT} g1, @code{HCDT} g2, @code{HCDT} a, @code{mreal} r, @code{const char *}stl, @code{int} flag)
@end ifclear
Рисует поверхность уровня для 3d массива @var{a} при постоянном значении @var{a}=@var{val}. Это специальный тип графика для @var{a} заданного в сопровождающей системе координат вдоль кривой @var{tr} с ортами @var{g1}, @var{g2} и с поперечным размером @var{r}. Переменная @var{flag} -- битовый флаг: @samp{0x1} - рисовать в сопровождающих (не лабораторных) координатах; @samp{0x2} - рисовать проекцию на плоскость @math{\rho-z}; @samp{0x4} - рисовать нормированное в каждом сечении поле. Размеры массивов по 1-му индексу @var{tr}, @var{g1}, @var{g2} должны быть nx>2. Размеры массивов по 2-му индексу @var{tr}, @var{g1}, @var{g2} и размер по 3-му индексу массива @var{a} должны быть одинаковы. См. также @ref{surf3}.
@end deftypefn
@c ##################################################################
+@external
@node Dual plotting, Vector fields, 3D plotting, MathGL core
@section Парные графики
@cindex SurfC
@cindex Map
@cindex STFA
-Эти функции строят графики для двух связанных массивов. Есть несколько основных типов 3D графиков: поверхность и поверхность уровня с окраской по второму массиву (SurfC, Surf3C), поверхность и поверхность уровня с прозрачностью по второму массиву (SurfA, Surf3A), плитки переменного размера (TileS), диаграмма точечного отображения (Map), STFA диаграмма (STFA). По умолчанию (если отсутствуют) значения @var{x}, @var{y} (и @var{z} для @code{Surf3C, Surf3A}) равно распределены в диапазоне осей координат. Младшие размерности массивов @var{x}, @var{y}, @var{z} должны быть одинаковы @code{x.nx=a.nx && y.nx=a.ny && z.nz=a.nz} или @code{x.nx=y.nx=z.nx=a.nx && x.ny=y.ny=z.ny=a.ny && x.nz=y.nz=z.nz=a.nz}. Массивы @var{x}, @var{y} (и @var{z} для @code{Surf3C, Surf3A}) могут быть векторами (не матрицами как @var{a}). Строка @var{sch} задает цветовую схему (см. @ref{Color scheme}). Строка @var{opt} задает опции графика (см. @ref{Command options}).
+Эти функции строят графики для двух связанных массивов. Есть несколько основных типов 3D графиков: поверхность и поверхность уровня с окраской по второму массиву (SurfC, Surf3C), поверхность и поверхность уровня с прозрачностью по второму массиву (SurfA, Surf3A), плитки переменного размера (TileS), диаграмма точечного отображения (Map), STFA диаграмма (STFA). По умолчанию (если отсутствуют) значения @var{x}, @var{y} (и @var{z} для @code{Surf3C, Surf3A}) равно распределены в диапазоне осей координат. Младшие размерности массивов @var{x}, @var{y}, @var{z}, @var{c} должны быть одинаковы @code{x.nx=a.nx && y.nx=a.ny && z.nz=a.nz} или @code{x.nx=y.nx=z.nx=a.nx && x.ny=y.ny=z.ny=a.ny && x.nz=y.nz=z.nz=a.nz}. Массивы @var{x}, @var{y} (и @var{z} для @code{Surf3C, Surf3A}) могут быть векторами (не матрицами как @var{c}). Строка @var{sch} задает цветовую схему (см. @ref{Color scheme}). Строка @var{opt} задает опции графика (см. @ref{Command options}).
@anchor{surfc}
@deftypefnx {Функция С} @code{void} mgl_surfc (@code{HMGL} gr, @code{HCDT} z, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_surfc_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Рисует параметрически заданную поверхность @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} с цветом, заданным массивом @var{c}[i,j]. Если @var{sch} содержит @samp{#}, то на поверхности рисуется сетка. График строится для каждого z среза данных. См. также @ref{surf}, @ref{surfa}, @ref{surf3c}. @sref{SurfC sample}
+РиÑ\81Ñ\83еÑ\82 паÑ\80амеÑ\82Ñ\80иÑ\87еÑ\81ки заданнÑ\83Ñ\8e повеÑ\80Ñ\85ноÑ\81Ñ\82Ñ\8c @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} Ñ\81 Ñ\86веÑ\82ом, заданнÑ\8bм маÑ\81Ñ\81ивом @var{c}[i,j]. Ð\95Ñ\81ли @var{sch} Ñ\81одеÑ\80жиÑ\82 @samp{#}, Ñ\82о на повеÑ\80Ñ\85ноÑ\81Ñ\82и Ñ\80иÑ\81Ñ\83еÑ\82Ñ\81Ñ\8f Ñ\81еÑ\82ка. РазмеÑ\80ноÑ\81Ñ\82Ñ\8c маÑ\81Ñ\81ивов @var{z} и @var{c} должна бÑ\8bÑ\82Ñ\8c одинакова. Ð\93Ñ\80аÑ\84ик Ñ\81Ñ\82Ñ\80оиÑ\82Ñ\81Ñ\8f длÑ\8f каждого z Ñ\81Ñ\80еза даннÑ\8bÑ\85. См. Ñ\82акже @ref{surf}, @ref{surfa}, @ref{surf3c}. @sref{SurfC sample}
@end deftypefn
@anchor{surf3c}
@deftypefn {Команда MGL} {} surf3c adat cdat @code{val} ['sch'='']
@deftypefnx {Команда MGL} {} surf3c xdat ydat zdat adat cdat @code{val} ['sch'='']
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3C (@code{float} val, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3C (@code{float} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_surf3c_val (@code{HMGL} gr, @code{float} val, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_surf3c_xyz_val (@code{HMGL} gr, @code{float} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3C (@code{mreal} val, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3C (@code{mreal} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_surf3c_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_surf3c_xyz_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@end ifclear
Рисует поверхность уровня для 3d массива, заданного параметрически @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]) при @var{a}(x,y,z)=@var{val}. Аналогично @ref{surf3}, но цвет задается массивом @var{c}. Если @var{sch} содержит @samp{#}, то рисуется сетчатая поверхность. См. также @ref{surf3}, @ref{surfc}, @ref{surf3a}. @sref{Surf3C sample}
@end deftypefn
@deftypefnx {Функция С} @code{void} mgl_surfa (@code{HMGL} gr, @code{HCDT} z, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_surfa_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Рисует параметрически заданную поверхность @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} с прозрачностью, заданной массивом @var{c}[i,j]. Если @var{sch} содержит @samp{#}, то на поверхности рисуется сетка. График строится для каждого z среза данных. См. также @ref{surf}, @ref{surfc}, @ref{surf3a}. @sref{SurfA sample}
+РиÑ\81Ñ\83еÑ\82 паÑ\80амеÑ\82Ñ\80иÑ\87еÑ\81ки заданнÑ\83Ñ\8e повеÑ\80Ñ\85ноÑ\81Ñ\82Ñ\8c @{@var{x}[i,j], @var{y}[i,j], @var{z}[i,j]@} Ñ\81 пÑ\80озÑ\80аÑ\87ноÑ\81Ñ\82Ñ\8cÑ\8e, заданной маÑ\81Ñ\81ивом @var{c}[i,j]. Ð\95Ñ\81ли @var{sch} Ñ\81одеÑ\80жиÑ\82 @samp{#}, Ñ\82о на повеÑ\80Ñ\85ноÑ\81Ñ\82и Ñ\80иÑ\81Ñ\83еÑ\82Ñ\81Ñ\8f Ñ\81еÑ\82ка. РазмеÑ\80ноÑ\81Ñ\82Ñ\8c маÑ\81Ñ\81ивов @var{z} и @var{c} должна бÑ\8bÑ\82Ñ\8c одинакова. Ð\93Ñ\80аÑ\84ик Ñ\81Ñ\82Ñ\80оиÑ\82Ñ\81Ñ\8f длÑ\8f каждого z Ñ\81Ñ\80еза даннÑ\8bÑ\85. См. Ñ\82акже @ref{surf}, @ref{surfc}, @ref{surf3a}. @sref{SurfA sample}
@end deftypefn
@anchor{surf3a}
@deftypefn {Команда MGL} {} surf3a adat cdat @code{val} ['sch'='']
@deftypefnx {Команда MGL} {} surf3a xdat ydat zdat adat cdat @code{val} ['sch'='']
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3A (@code{float} val, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3A (@code{float} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_surf3a_val (@code{HMGL} gr, @code{float} val, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_surf3a_xyz_val (@code{HMGL} gr, @code{float} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3A (@code{mreal} val, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Surf3A (@code{mreal} val, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}a, @code{const mglData &}c, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_surf3a_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_surf3a_xyz_val (@code{HMGL} gr, @code{mreal} val, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@end ifclear
Рисует поверхность уровня для 3d массива, заданного параметрически @var{a}[i,j,k](@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]) при @var{a}(x,y,z)=@var{val}. Аналогично @ref{surf3}, но прозрачность задается массивом @var{c}. Если @var{sch} содержит @samp{#}, то рисуется сетчатая поверхность. См. также @ref{surf3}, @ref{surfc}, @ref{surf3a}. @sref{Surf3A sample}
@end deftypefn
@deftypefnx {Функция С} @code{void} mgl_surf3a (@code{HMGL} gr, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_surf3a_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Ð\90налогиÑ\87но пÑ\80едÑ\8bдÑ\83Ñ\89емÑ\83 длÑ\8f @var{num} повеÑ\80Ñ\85ноÑ\81Ñ\82ей Ñ\83Ñ\80овнÑ\8f Ñ\80авномеÑ\80но Ñ\80аÑ\81пÑ\80еделÑ\91ннÑ\8bÑ\85 в диапазоне изменениÑ\8f Ñ\86веÑ\82а. Ð\92еличина @var{num} равна значению параметра @var{value} в опциях @var{opt} (по умолчанию 3).
+Ð\90налогиÑ\87но пÑ\80едÑ\8bдÑ\83Ñ\89емÑ\83 длÑ\8f @var{num} повеÑ\80Ñ\85ноÑ\81Ñ\82ей Ñ\83Ñ\80овнÑ\8f Ñ\80авномеÑ\80но Ñ\80аÑ\81пÑ\80еделÑ\91ннÑ\8bÑ\85 в диапазоне изменениÑ\8f Ñ\86веÑ\82а. Ð\9fÑ\80и Ñ\8dÑ\82ом маÑ\81Ñ\81ив @var{c} можеÑ\82 бÑ\8bÑ\82Ñ\8c векÑ\82оÑ\80ом Ñ\81о знаÑ\87ениÑ\8fми пÑ\80озÑ\80аÑ\87ноÑ\81Ñ\82и и @var{num}=@var{c}.nx. Ð\92 пÑ\80оÑ\82ивном Ñ\81лÑ\83Ñ\87ае величина @var{num} равна значению параметра @var{value} в опциях @var{opt} (по умолчанию 3).
@end deftypefn
@anchor{tiles}
@deftypefnx {Функция С} @code{void} mgl_map (@code{HMGL} gr, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_map_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Рисует точечное отображение для матриц @{@var{ax}, @var{ay} @} параметрически зависящих от координат @var{x}, @var{y}. Исходное положение ячейки задает ее цвет. Высота пропорциональна якобиану J(ax,ay). График является аналогом диаграммы Арнольда. Если @var{sch} содержит @samp{.}, то цветные точки рисуются в узлах матриц (полезно для "запутанного" отображения), иначе рисуются грани. @sref{Mapping visualization}
+Рисует точечное отображение для матриц @{@var{ax}, @var{ay} @} параметрически зависящих от координат @var{x}, @var{y}. Исходное положение ячейки задает ее цвет. Высота пропорциональна якобиану J(ax,ay). График является аналогом диаграммы Арнольда ??? Если @var{sch} содержит @samp{.}, то цветные точки рисуются в узлах матриц (полезно для "запутанного" отображения), иначе рисуются грани. @sref{Mapping visualization}
@end deftypefn
@anchor{stfa}
@c ##################################################################
+@external
@node Vector fields, Other plotting, Dual plotting, MathGL core
@section Векторные поля
@cindex Traj
Эти функции рисуют графики для 2D и 3D векторных полей. Есть несколько типов графиков: просто векторное поле (Vect), вектора вдоль траектории (Traj), векторное поле каплями (Dew), нити тока (Flow, FlowP), трубки тока (Pipe). По умолчанию (если отсутствуют) значения @var{x}, @var{y} и @var{z} равно распределены в диапазоне осей координат. Младшие размерности массивов @var{x}, @var{y}, @var{z} и @var{ax} должны быть одинаковы. Размеры массивов @var{ax}, @var{ay} и @var{az} должны быть одинаковы. Массивы @var{x}, @var{y} и @var{z} могут быть векторами (не матрицами как @var{ax}). Строка @var{sch} задает цветовую схему (см. @ref{Color scheme}). Строка @var{opt} задает опции графика (см. @ref{Command options}).
-
@anchor{traj}
@deftypefn {Команда MGL} {} traj xdat ydat udat vdat ['sch'='']
@deftypefnx {Команда MGL} {} traj xdat ydat zdat udat vdat wdat ['sch'='']
@deftypefnx {Функция С} @code{void} mgl_vect_3d (@code{HMGL} gr, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_vect_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Это 3d версия графика. Здесь массивы должны трёхмерными тензорами и длина вектора пропорциональна @math{\sqrt@{ax^2+ay^2+az^2@}}.
+Это 3d версия графика. Здесь массивы @var{ax}, @var{ay}, @var{az} должны трёхмерными тензорами и длина вектора пропорциональна @math{\sqrt@{ax^2+ay^2+az^2@}}.
@end deftypefn
@anchor{dew}
@ifclear UDAV
@deftypefnx {Метод класса @code{mglGraph}} @code{void} FlowP (@code{mglPoint} p0, @code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Метод класса @code{mglGraph}} @code{void} FlowP (@code{mglPoint} p0, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_flowp_2d (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_flowp_xy (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_flowp_2d (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_flowp_xy (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Аналогично @ref{flow}, @var{p0}=@{@var{x0},@var{y0},@var{z0}@}.
+Аналогично @ref{flow}, но рисует одну нить из точки @var{p0}=@{@var{x0},@var{y0},@var{z0}@}.
@end deftypefn
@deftypefn {Команда MGL} {} flow @code{x0 y0 z0} udat vdat wdat ['sch'='']
@ifclear UDAV
@deftypefnx {Метод класса @code{mglGraph}} @code{void} FlowP (@code{mglPoint} p0, @code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
@deftypefnx {Метод класса @code{mglGraph}} @code{void} FlowP (@code{mglPoint} p0, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_flowp_3d (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_flowp_xyz (@code{HMGL} gr, @code{float} x0, @code{float} y0, @code{float} z0, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_flowp_3d (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_flowp_xyz (@code{HMGL} gr, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Это 3d версия графика. Здесь массивы должны трёхмерными тензорами и цвет пропорционален @math{\sqrt@{ax^2+ay^2+az^2@}}.
+Это 3d версия графика.
@end deftypefn
@anchor{grad}
@deftypefnx {Функция С} @code{void} mgl_grad_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} phi, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_grad_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} phi, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Рисует линии градиента скалярного поля @var{phi}[i,j] (или @var{phi}[i,j,k] в 3d случае) заданного параметрически @{@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]@}. Число линий пропорционально значению опции @var{value}. Линии рисуются только с границ интервала при @var{value}<0. См. также @ref{dens}, @ref{cont}, @ref{flow}.
+Рисует линии градиента скалярного поля @var{phi}[i,j] (или @var{phi}[i,j,k] в 3d случае) заданного параметрически @{@var{x}[i,j,k], @var{y}[i,j,k], @var{z}[i,j,k]@}. Число линий пропорционально значению опции @var{value} (по умолчанию 5). См. также @ref{dens}, @ref{cont}, @ref{flow}.
@end deftypefn
@anchor{pipe}
@deftypefn {Команда MGL} {} pipe udat vdat ['sch'='' @code{r0=0.05}]
@deftypefnx {Команда MGL} {} pipe xdat ydat udat vdat ['sch'='' @code{r0=0.05}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Pipe (@code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{float} r0=@code{0.05}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Pipe (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{float} r0=@code{0.05}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_pipe_2d (@code{HMGL} gr, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{float} r0, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_pipe_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{float} r0, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Pipe (@code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{mreal} r0=@code{0.05}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Pipe (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}ax, @code{const mglData &}ay, @code{const char *}sch=@code{""}, @code{mreal} r0=@code{0.05}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_pipe_2d (@code{HMGL} gr, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{mreal} r0, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_pipe_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} ax, @code{HCDT} ay, @code{const char *}sch, @code{mreal} r0, @code{const char *}opt)
@end ifclear
Рисует трубки тока для векторного поля @{@var{ax}, @var{ay}@}, параметрически зависящего от координат @var{x}, @var{y} на плоскости при @var{z} = @var{Min}.z. Число трубок пропорционально значению опции @var{value}. Цвет и радиус трубок пропорционален @math{\sqrt@{ax^2+ay^2@}}. Тёплые цвета соответствуют нормальному току (типа стока). Холодные цвета соответствуют обратному току (типа источника). Параметр @var{r0} задает радиус трубок. При @var{r0}<0 радиус трубок обратно пропорционален их амплитуде. См. также @ref{flow}, @ref{vect}. @sref{Pipe sample}
@end deftypefn
@deftypefn {Команда MGL} {} pipe udat vdat wdat ['sch'='' @code{r0=0.05}]
@deftypefnx {Команда MGL} {} pipe xdat ydat zdat udat vdat wdat ['sch'='' @code{r0=0.05}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Pipe (@code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{float} r0=@code{0.05}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} Pipe (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{float} r0=@code{0.05}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_pipe_3d (@code{HMGL} gr, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{float} r0, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_pipe_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{float} r0, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Pipe (@code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{mreal} r0=@code{0.05}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} Pipe (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const mglData &}ax, @code{const mglData &}ay, @code{const mglData &}az, @code{const char *}sch=@code{""}, @code{mreal} r0=@code{0.05}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_pipe_3d (@code{HMGL} gr, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{mreal} r0, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_pipe_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} ax, @code{HCDT} ay, @code{HCDT} az, @code{const char *}sch, @code{mreal} r0, @code{const char *}opt)
@end ifclear
-Это 3d версия графика. Здесь массивы должны трёхмерными тензорами и цвет пропорционален @math{\sqrt@{ax^2+ay^2+az^2@}}.
+Это 3d версия графика. Здесь массивы @var{ax}, @var{ay}, @var{az} должны трёхмерными тензорами и цвет пропорционален @math{\sqrt@{ax^2+ay^2+az^2@}}.
@end deftypefn
@c ##################################################################
+@external
@node Other plotting, Nonlinear fitting, Vector fields, MathGL core
@section Прочие графики
@cindex DensXYZ
@deftypefnx {Команда MGL} {} densy dat ['sch'='' @code{sval=nan}]
@deftypefnx {Команда MGL} {} densz dat ['sch'='' @code{sval=nan}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} DensX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} DensY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} DensZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_dens_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_dens_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_dens_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} DensX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} DensY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} DensZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_dens_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_dens_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_dens_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
Эти функции рисуют график плотности на x, y или z плоскостях. Если @var{a} -- 3d массив, то выполняется интерполяция к заданному срезу @var{sVal}. Функции полезны для создания проекций 3D массивов на оси координат. См. также @ref{ContXYZ}, @ref{ContFXYZ}, @ref{dens}, @ref{Data manipulation}. @sref{Dens projection sample}
@end deftypefn
@deftypefnx {Команда MGL} {} conty dat ['sch'='' @code{sval=nan}]
@deftypefnx {Команда MGL} {} contz dat ['sch'='' @code{sval=nan}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_cont_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_cont_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_cont_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_cont_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_cont_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_cont_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
Эти функции рисуют линии уровня на x, y или z плоскостях. Если @var{a} -- 3d массив, то выполняется интерполяция к заданному срезу @var{sVal}. Функции полезны для создания проекций 3D массивов на оси координат. См. также @ref{ContFXYZ}, @ref{DensXYZ}, @ref{cont}, @ref{Data manipulation}. @sref{Cont projection sample}
@end deftypefn
@ifclear UDAV
-@deftypefn {Метод класса @code{mglGraph}} @code{void} ContX (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContY (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContZ (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_cont_x_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_cont_y_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_cont_z_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} ContX (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContY (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContZ (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_cont_x_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_cont_y_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_cont_z_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
Аналогично предыдущему с ручным заданием значений для линий уровня.
@end deftypefn
@end ifclear
@deftypefnx {Команда MGL} {} contfy dat ['sch'='' @code{sval=nan}]
@deftypefnx {Команда MGL} {} contfz dat ['sch'='' @code{sval=nan}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContFX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContFY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContFZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_contf_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_contf_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_contf_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContFX (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContFY (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContFZ (@code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_contf_x (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_contf_y (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_contf_z (@code{HMGL} gr, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
@end ifclear
Эти функции рисуют закрашенные контуры уровня на x, y или z плоскостях. Если @var{a} -- 3d массив, то выполняется интерполяция к заданному срезу @var{sVal}. Функции полезны для создания проекций 3D массивов на оси координат. См. также @ref{ContFXYZ}, @ref{DensXYZ}, @ref{cont}, @ref{Data manipulation}. @sref{ContF projection sample}
@end deftypefn
@ifclear UDAV
-@deftypefn {Метод класса @code{mglGraph}} @code{void} ContFX (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContFY (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContFZ (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{float} sVal=@code{NAN}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{void} mgl_contf_x_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_contf_y_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
-@deftypefnx {Функция С} @code{void} mgl_contf_z_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{float} sVal, @code{const char *}opt)
+@deftypefn {Метод класса @code{mglGraph}} @code{void} ContFX (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContFY (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} ContFZ (@code{const mglData &}v, @code{const mglData &}a, @code{const char *}stl=@code{""}, @code{mreal} sVal=@code{NAN}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_contf_x_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_contf_y_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
+@deftypefnx {Функция С} @code{void} mgl_contf_z_val (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} a, @code{const char *}stl, @code{mreal} sVal, @code{const char *}opt)
Аналогично предыдущему с ручным заданием значений для линий уровня.
@end deftypefn
@end ifclear
@deftypefnx {Метод класса @code{mglGraph}} @code{void} FSurf (@code{const char *}eqZ, @code{const char *}sch=@code{""}, @code{const char *}opt=@code{""});
@deftypefnx {Функция С} @code{void} mgl_fsurf (@code{HMGL} gr, @code{const char *}eqZ, @code{const char *}sch, @code{const char *}opt);
@end ifclear
-Рисует поверхность @samp{eqY(x,y)} с координатами @samp{x}, @samp{y} в диапазоне [@var{Min}, @var{Max}]. См. также @ref{surf}.
+Рисует поверхность @samp{eqY(x,y)} с координатами @samp{x}, @samp{y} в диапазоне @code{xrange, yrange}. См. также @ref{surf}.
@end deftypefn
@deftypefn {Команда MGL} {} fsurf 'x(u,v)' 'y(u,v)' 'z(u,v)' ['sch'='']
@deftypefnx {Функция С} @code{void} mgl_triplot_xyz (@code{HMGL} gr, @code{HCDT} id, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_triplot_xyzc (@code{HMGL} gr, @code{HCDT} id, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Рисует поверхность из треугольников. Вершины треугольников задаются индексами @var{id} в массиве точек @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Строка @var{sch} задает цветовую схему. Если строка содержит @samp{#}, то рисуется сетчатая поверхность. Размер по 1-му индексу массива @var{id} должен быть 3 или больше. Массивы @var{x}, @var{y}, @var{z} должны иметь одинаковые размеры. Массив @var{c} задает цвет треугольников (если @var{id}.ny=@var{c}.nx) или цвет вершин (если @var{x}.nx=@var{c}.nx). См. также @ref{dots}, @ref{crust}, @ref{quadplot}. @sref{TriPlot and QuadPlot}
+Рисует поверхность из треугольников. Вершины треугольников задаются индексами @var{id} в массиве точек @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Строка @var{sch} задает цветовую схему. Если строка содержит @samp{#}, то рисуется сетчатая поверхность. Размер по 1-му индексу массива @var{id} должен быть 3 или больше. Массивы @var{x}, @var{y}, @var{z} должны иметь одинаковые размеры. Массив @var{c} задает цвет треугольников (если @var{id}.ny=@var{c}.nx) или цвет вершин (если @var{x}.nx=@var{c}.nx). См. также @ref{dots}, @ref{crust}, @ref{quadplot}, @ref{triangulation}. @sref{TriPlot and QuadPlot}
@end deftypefn
@anchor{tricont}
@deftypefnx {Функция С} @code{void} mgl_tricont_xyzcv (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} id, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} c, @code{const char *}sch, @code{const char *}opt)
@deftypefnx {Функция С} @code{void} mgl_tricont_xyzv (@code{HMGL} gr, @code{HCDT} v, @code{HCDT} id, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}sch, @code{const char *}opt)
@end ifclear
-Рисует линии уровня поверхности из треугольников при @var{z}=@var{v}[k] (или при @var{z} = @var{Min}.z если @var{sch} содержит @samp{_}). Вершины треугольников задаются индексами @var{id} в массиве точек @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Строка @var{sch} задает цветовую схему. Размер по 1-му индексу массива @var{id} должен быть 3 или больше. Массивы @var{x}, @var{y}, @var{z} должны иметь одинаковые размеры. Массив @var{c} задает цвет треугольников (если @var{id}.ny=@var{c}.nx) или цвет вершин (если @var{x}.nx=@var{c}.nx). См. также @ref{triplot}, @ref{cont}.
+Рисует линии уровня поверхности из треугольников при @var{z}=@var{v}[k] (или при @var{z} = @var{Min}.z если @var{sch} содержит @samp{_}). Вершины треугольников задаются индексами @var{id} в массиве точек @{@var{x}[i], @var{y}[i], @var{z}[i]@}. Строка @var{sch} задает цветовую схему. Размер по 1-му индексу массива @var{id} должен быть 3 или больше. Массивы @var{x}, @var{y}, @var{z} должны иметь одинаковые размеры. Массив @var{c} задает цвет треугольников (если @var{id}.ny=@var{c}.nx) или цвет вершин (если @var{x}.nx=@var{c}.nx). См. также @ref{triplot}, @ref{cont}, @ref{triangulation}.
@end deftypefn
@anchor{quadplot}
@end deftypefn
@c ##################################################################
+@external
@node Nonlinear fitting, Data manipulation, Other plotting, MathGL core
@section Nonlinear fitting
@cindex Fit
@anchor{putsfit}
@deftypefn {Команда MGL} {} putsfit @code{x y} ['pre'='' 'fnt'='' @code{size=-1}]
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{void} PutsFit (@code{mglPoint} p, @code{const char *}prefix=@code{""}, @code{const char *}font=@code{""}, @code{float} size=@code{-1})
-@deftypefnx {Функция С} @code{void} mgl_puts_fit (@code{HMGL} gr, @code{float} x, @code{float} y, @code{float} z, @code{const char *}prefix, @code{const char *}font, @code{float} size)
+@deftypefnx {Метод класса @code{mglGraph}} @code{void} PutsFit (@code{mglPoint} p, @code{const char *}prefix=@code{""}, @code{const char *}font=@code{""}, @code{mreal} size=@code{-1})
+@deftypefnx {Функция С} @code{void} mgl_puts_fit (@code{HMGL} gr, @code{mreal} x, @code{mreal} y, @code{mreal} z, @code{const char *}prefix, @code{const char *}font, @code{mreal} size)
@end ifclear
Печатает последнюю подобранную формулу с найденными коэффициентами в точке @var{p0}. Строка @var{prefix} будет напечатана перед формулой. Все другие параметры такие же как в @ref{Text printing}.
@end deftypefn
@end deftypefn
@end ifclear
-@deftypevr {Переменная(C++)} @code{int} mglFitPnts
-Минимальное число точек для массива со значениями подобранной формулы.
-@end deftypevr
-
-
-
@c ##################################################################
-@node Data manipulation, IDTF functions, Nonlinear fitting, MathGL core
+@external
+@node Data manipulation, , Nonlinear fitting, MathGL core
@section Распределение данных
@cindex Hist
+@cindex Fill
+@cindex DataGrid
@deftypefn {Команда MGL} {} hist @sc{res} xdat adat
@deftypefnx {Команда MGL} {} hist @sc{res} xdat ydat adat
@deftypefnx {Функция С} @code{HMDT} mgl_hist_xy (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} a, @code{const char *}opt)
@deftypefnx {Функция С} @code{HMDT} mgl_hist_xyz (@code{HMGL} gr, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{HCDT} a, @code{const char *}opt)
@end ifclear
-ÐÑ\82и Ñ\84Ñ\83нкÑ\86ии Ñ\81оздают распределения данных. Они не рисуют данные. Функции могут быть полезны в случае когда данные пользователя определены на случайно расположенных точка (например, после PIC расчетов) и он хочет построить график, требующий регулярных данных (данных на сетках). Диапазон сеток равен диапазону осей координат. Массивы @var{x}, @var{y}, @var{z} определяют положение (координаты) точек. Массив @var{a} задает значения данных. Число точек в результате @var{res} -- максимум из размера @var{res} и значения @var{mglFitPnts}.
+Создают распределения данных. Они не рисуют данные. Функции могут быть полезны в случае когда данные пользователя определены на случайно расположенных точка (например, после PIC расчетов) и он хочет построить график, требующий регулярных данных (данных на сетках). Диапазон сеток равен диапазону осей координат. Массивы @var{x}, @var{y}, @var{z} определяют положение (координаты) точек. Массив @var{a} задает значения данных. Число точек в результате @var{res} -- максимум из размера @var{res} и значения @var{mglFitPnts}.
@end deftypefn
@deftypefnx {Метод класса @code{mglGraph}} @code{void} Fill (@code{mglData &}u, @code{const char *}eq, @code{const mglData &}v, @code{const mglData &}w, @code{const char *}opt=@code{""})
@deftypefnx {Функция С} @code{void} mgl_data_fill_eq (@code{HMGL} gr, @code{HMDT} u, @code{const char *}eq, @code{HCDT}v, @code{HCDT}w, @code{const char *}opt)
@end ifclear
-Fills the value of array according to the formula in string @var{eq}. Formula is an arbitrary expression depending on variables @samp{x}, @samp{y}, @samp{z}, @samp{u}, @samp{v}, @samp{w}. Coordinates @samp{x}, @samp{y}, @samp{z} are supposed to be normalized in axis range. Variable @samp{u} is the original value of the array. Variables @samp{v} and @samp{w} are values of arrays @var{v}, @var{w} which can be @code{NULL} (i.e. can be omitted).
+Заполняют значения массива @samp{u} в соответствии с формулой в строке @var{eq}. Формула -- произвольное выражение, зависящее от переменных @samp{x}, @samp{y}, @samp{z}, @samp{u}, @samp{v}, @samp{w}. Координаты @samp{x}, @samp{y}, @samp{z} полагаются в диапазоне изменения осей координат. Переменная @samp{u} -- значение исходного массива. Переменные @samp{v} и @samp{w} -- значения массивов @var{v}, @var{w}, которые могут быть @code{NULL} (т.е. могут быть опущены).
@end deftypefn
-@deftypefn {Команда MGL} {} pde @sc{res} 'ham' ini_re ini_im [@code{dz=0.1 k0=100}]
+@deftypefn {MGL command} {} datagrid dat xdat ydat zdat
@ifclear UDAV
-@deftypefnx {Метод класса @code{mglGraph}} @code{mglData} PDE (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{float} dz=@code{0.1}, @code{float} k0=@code{100}, @code{const char *}opt=@code{""})
-@deftypefnx {Функция С} @code{HMDT} mgl_pde_solve (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{float} dz, @code{float} k0, @code{const char *}opt)
+@deftypefnx {Method on @code{mglGraph}} @code{void} DataGrid (@code{mglData &}u, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_data_grid (@code{HMGL} gr, @code{HMDT} u, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}opt)
@end ifclear
-Solves equation du/dz = i*k0*@var{ham}(p,q,x,y,z,|u|)[u], where p=-i/k0*d/dx, q=-i/k0*d/dy are pseudo-differential operators. Parameters @var{ini_re}, @var{ini_im} specify real and imaginary part of initial field distribution. Parameters @var{Min}, @var{Max} set the bounding box for the solution. Note, that really this ranges are increased by factor 3/2 for purpose of reducing reflection from boundaries. Parameter @var{dz} set the step along evolutionary coordinate z. At this moment, simplified form of function @var{ham} is supported -- all ``mixed'' terms (like @samp{x*p}->x*d/dx) are excluded. For example, in 2D case this function is effectively @math{ham = f(p,z) + g(x,z,u)}. However commutable combinations (like @samp{x*q}->x*d/dy) are allowed. Here variable @samp{u} is used for field amplitude |u|. This allow one solve nonlinear problems -- for example, for nonlinear Shrodinger equation you may set @code{ham="p^2 + q^2 - u^2"}. You may specify imaginary part for wave absorption, like @code{ham = "p^2 + i*x*(x>0)"}, but only if dependence on variable @samp{i} is linear (i.e. @math{ham = hre+i*him}). @sref{PDE solving hints}
+Заполняет значения массива @samp{u} результатом линейной интерполяции по триангулированной поверхности, найденной по произвольно расположенным точкам @samp{x}, @samp{y}, @samp{z}. NAN значение используется для точек сетки вне триангулированной поверхности.
@end deftypefn
+
+@deftypefn {Команда MGL} {} pde @sc{res} 'ham' ini_re ini_im [@code{dz=0.1 k0=100}]
+@ifclear UDAV
+@deftypefnx {Метод класса @code{mglGraph}} @code{mglData} PDE (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{mreal} dz=@code{0.1}, @code{mreal} k0=@code{100}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{HMDT} mgl_pde_solve (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{mreal} dz, @code{mreal} k0, @code{const char *}opt)
+@end ifclear
+Решает уравнение в частных производных du/dz = i*k0*@var{ham}(p,q,x,y,z,|u|)[u], где p=-i/k0*d/dx, q=-i/k0*d/dy -- псевдо-дифференциальные оперторы. Параметры @var{ini_re}, @var{ini_im} задают действительную и мнимую часть начального распределения поля. Координаты @samp{x}, @samp{y}, @samp{z} полагаются в диапазоне изменения осей координат. Отмечу, ято в действительности этот диапазон увеличен на 3/2 для уменьшения отражения от границ сетки. Параметр @var{dz} задает шаг по эволюционной координате z. Сейчас используется упрощенный вид функции @var{ham} -- исключены все ``смешанные'' члены (типа @samp{x*p}->x*d/dx). Например, в 2D случае это функция вида @math{ham = f(p,z) + g(x,z,u)}. Однако, коммутирующие члены (типа @samp{x*q}->x*d/dy) разрешены. Переменная @samp{u} используется для амплитуды поля |u|, что позволяет решать нелинейные задачи -- например уравнение Шредингера @code{ham="p^2 + q^2 - u^2"}. Вы можете задавать мнимую часть для поглощения волн, например @code{ham = "p^2 + i*x*(x>0)"}, но только для линейной зависимости от переменной @samp{i} (т.е. @math{ham = hre+i*him}). @sref{PDE solving hints}
+@end deftypefn
+
@c ##################################################################
-@node IDTF functions, , Data distributions, MathGL core
-@section IDTF функции
-@cindex NewFrame
-@cindex EndFrame
-@cindex GetNumFrame
+@c @external
+@c @node IDTF functions, , Data distributions, MathGL core
+@c @section IDTF функции
-Эти функции обеспечивают поддержку особых возможностей при создании IDTF. Во всех прочих случаях они не делают ничего.
+@c Эти функции обеспечивают поддержку особых возможностей при создании IDTF. Во всех прочих случаях они не делают ничего.
-@deftypefn {Метод класса @code{mglGraph}} @code{void} VertexColor (@code{bool} enable)
-Разрешает плавное изменение цвета.
-@end deftypefn
+@c @deftypefn {Метод класса @code{mglGraph}} @code{void} VertexColor (@code{bool} enable)
+@c Разрешает плавное изменение цвета.
+@c @end deftypefn
+
+@c @deftypefn {Метод класса @code{mglGraph}} @code{void} Compression (@code{bool} enable)
+@c Дает меньший объем файла, но с худшим качеством.
+@c @end deftypefn
+
+@c inline void DoubleSided(bool){} // NOTE: Add later -- IDTF
+@c inline void TextureColor(bool){} // NOTE: Add later -- IDTF
+
+@c @end ifclear
+
+@external
-@deftypefn {Метод класса @code{mglGraph}} @code{void} Compression (@code{bool} enable)
-Дает меньший объем файла, но с худшим качеством.
-@end deftypefn
@chapter Data processing
@ifset UDAV
-This chapter describe commands for allocation, resizing, loading and saving, modifying of data arrays. Also it can numerically differentiate and integrate data, interpolate, fill data by formula and so on. Class supports data with dimensions up to 3 (like function of 3 variables -- x,y,z). The internal representation of numbers is float. Float type was chosen because it has smaller size in memory and usually it has enough precision in plotting purposes. Data arrays are denoted by Small Caps (like @sc{dat}) if it can be (re-)created by MGL commands.
+This chapter describe commands for allocation, resizing, loading and saving, modifying of data arrays. Also it can numerically differentiate and integrate data, interpolate, fill data by formula and so on. Class supports data with dimensions up to 3 (like function of 3 variables -- x,y,z). Data arrays are denoted by Small Caps (like @sc{dat}) if it can be (re-)created by MGL commands.
@end ifset
@ifclear UDAV
-This chapter describe class @code{mglData} for working with data array. This class is defined in @code{#include <mgl2/data.h>}. The class has functions for easy and safe allocation, resizing, loading and saving, modifying of data arrays. Also it can numerically differentiate and integrate data, interpolate, fill data by formula and so on. Class supports data with dimensions up to 3 (like function of 3 variables -- x,y,z). The internal representation of numbers is float. Float type was chosen because it has smaller size in memory and usually it has enough precision in plotting purposes. You can change it by selecting option @code{--enable-double} at the library configuring (see @ref{Installation}). Data arrays are denoted by Small Caps (like @sc{dat}) if it can be (re-)created by MGL commands.
+This chapter describe class @code{mglData} for working with data array. This class is defined in @code{#include <mgl2/data.h>}. The class has functions for easy and safe allocation, resizing, loading and saving, modifying of data arrays. Also it can numerically differentiate and integrate data, interpolate, fill data by formula and so on. Class supports data with dimensions up to 3 (like function of 3 variables -- x,y,z). The internal representation of numbers is mreal. Float type was chosen because it has smaller size in memory and usually it has enough precision in plotting purposes. You can change it by selecting option @code{--enable-double} at the library configuring (see @ref{Installation}). Data arrays are denoted by Small Caps (like @sc{dat}) if it can be (re-)created by MGL commands.
@end ifclear
@menu
@end menu
@c ------------------------------------------------------------------
+@external
@node Public variables, Data constructor, , Data processing
@section Public variables
@end ifset
@ifclear UDAV
-@deftypecv {Variable} mglData @code{float *} a
+@deftypecv {Variable} mglData @code{mreal *} a
Data array itself. The flat data representation is used. For example, matrix [nx x ny] is presented as flat (1d-) array with length nx*ny. The element with indexes @{i, j, k@} is a[i+nx*j+nx*ny*k] (indexes are zero based).
@end deftypecv
@deftypecv {Variable} mglData @code{int} nx
Flag to use external data, i.e. don't delete it.
@end deftypecv
-@deftypefn {Method on @code{mglData}} @code{float} GetVal (@code{long} i)
-@deftypefnx {Method on @code{mglData}} @code{void} SetVal (@code{float} val, @code{long} i)
+@deftypefn {Method on @code{mglData}} @code{mreal} GetVal (@code{long} i)
+@deftypefnx {Method on @code{mglData}} @code{void} SetVal (@code{mreal} val, @code{long} i)
Gets or sets the value in by "flat" index @var{i} without border checking. Index @var{i} should be in range [0, nx*ny*nz-1].
@end deftypefn
Gets the x-, y-, z-size of the data.
@end deftypefn
-@deftypefn {C function} @code{float} mgl_data_get_value (@code{HCDT} dat, @code{int} i, @code{int} j, @code{int} k)
-@deftypefnx {C function} @code{float *} mgl_data_value (@code{HMDT} dat, @code{int} i, @code{int} j, @code{int} k)
-@deftypefnx {C function} @code{void} mgl_data_set_value (@code{HMDT} dat, @code{float} v, @code{int} i, @code{int} j, @code{int} k)
+@deftypefn {C function} @code{mreal} mgl_data_get_value (@code{HCDT} dat, @code{int} i, @code{int} j, @code{int} k)
+@deftypefnx {C function} @code{mreal *} mgl_data_value (@code{HMDT} dat, @code{int} i, @code{int} j, @code{int} k)
+@deftypefnx {C function} @code{void} mgl_data_set_value (@code{HMDT} dat, @code{mreal} v, @code{int} i, @code{int} j, @code{int} k)
Gets or sets the value in specified cell of the data with border checking.
@end deftypefn
-@deftypefn {C function} @code{const float *} mgl_data_data (@code{HCDT} dat)
+@deftypefn {C function} @code{const mreal *} mgl_data_data (@code{HCDT} dat)
Returns pointer to internal data array.
@end deftypefn
@end ifclear
@c ------------------------------------------------------------------
+@external
@node Data constructor, Data resizing, Public variables, Data processing
@section Data constructor
@cindex mglData
@deftypefnx {C function} @code{HMDT} mgl_create_data ()
@deftypefnx {C function} @code{HMDT} mgl_create_data_size (@code{int} mx, @code{int} my, @code{int} mz)
@end ifclear
-Default constructor. Allocates the memory for data array and initializes it by zero. If string @var{eq} is specified then data will be filled by corresponding formula as in @ref{fill} function.
+Default constructor. Allocates the memory for data array and initializes it by zero. If string @var{eq} is specified then data will be filled by corresponding formula as in @ref{fill}.
@end deftypefn
@anchor{copy}
@ifclear UDAV
@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{const mglData &}dat2)
@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{const mglDataA *}dat2)
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{int} size, @code{const float *}dat2)
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{int} size, @code{int} cols, @code{const float *}dat2)
+@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{int} size, @code{const mreal *}dat2)
+@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{int} size, @code{int} cols, @code{const mreal *}dat2)
@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{int} size, @code{const double *}dat2)
@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{int} size, @code{int} cols, @code{const double *}dat2)
@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{const double *}dat2, @code{int} size)
@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{const double *}dat2, @code{int} size, @code{int} cols)
@end ifclear
-Copy constructor. Allocates the memory for data array and copy values from other array. At this, if parameter @var{eq} is specified then the data will be modified by corresponding formula similarly to @ref{fill} function.
+Copy constructor. Allocates the memory for data array and copy values from other array. At this, if parameter @var{eq} is specified then the data will be modified by corresponding formula similarly to @ref{fill}.
@end deftypefn
@deftypefn {MGL command} {} read @sc{dat} 'fname'
@c ------------------------------------------------------------------
+@external
@node Data resizing, Data filling, Data constructor, Data processing
@section Data resizing
@cindex Create
@deftypefnx {Method on @code{mglData}} @code{void} Rearrange (@code{int} mx, @code{int} my=@code{0}, @code{int} mz=@code{0})
@deftypefnx {C function} @code{void} mgl_data_rearrange (@code{HMDT} dat, @code{int} mx, @code{int} my, @code{int} mz)
@end ifclear
-Rearrange dimensions without changing data array so that resulting sizes should be @var{mx}*@var{my}*@var{mz} < nx*ny*nz. If some of parameter @var{my} or @var{mz} are zero then it will be selected to optimal fill of data array. For example, if @var{my}=0 then it will be change to @var{my}=nx*ny*nz/@var{mx} and @var{mz} will be 1.
+Rearrange dimensions without changing data array so that resulting sizes should be @var{mx}*@var{my}*@var{mz} < nx*ny*nz. If some of parameter @var{my} or @var{mz} are zero then it will be selected to optimal fill of data array. For example, if @var{my}=0 then it will be change to @var{my}=nx*ny*nz/@var{mx} and @var{mz}=1.
@end deftypefn
@anchor{transpose}
@end deftypefn
-
@c ------------------------------------------------------------------
+@external
@node Data filling, File I/O, Data resizing, Data processing
@section Data filling
@cindex Fill
@end deftypefn
@ifclear UDAV
-@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const float *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
+@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const mreal *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{const double *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
-@deftypefnx {C function} @code{void} mgl_data_set_float (@code{HMDT} dat, @code{const float *}A, @code{int} NX, @code{int} NY, @code{int} NZ)
+@deftypefnx {C function} @code{void} mgl_data_set_mreal (@code{HMDT} dat, @code{const mreal *}A, @code{int} NX, @code{int} NY, @code{int} NZ)
@deftypefnx {C function} @code{void} mgl_data_set_double (@code{HMDT} dat, @code{const double *}A, @code{int} NX, @code{int} NY, @code{int} NZ)
-Allocates memory and copies the data from the @strong{flat} @code{float*} or @code{double*} array.
+Allocates memory and copies the data from the @strong{flat} @code{mreal*} or @code{double*} array.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const float **}A, @code{int} N1, @code{int} N2)
+@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const mreal **}A, @code{int} N1, @code{int} N2)
@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{const double **}A, @code{int} N1, @code{int} N2)
-@deftypefnx {C function} @code{void} mgl_data_set_float2 (@code{HMDT} dat, @code{const float **}A, @code{int} N1, @code{int} N2)
+@deftypefnx {C function} @code{void} mgl_data_set_mreal2 (@code{HMDT} dat, @code{const mreal **}A, @code{int} N1, @code{int} N2)
@deftypefnx {C function} @code{void} mgl_data_set_double2 (@code{HMDT} dat, @code{const double **}A, @code{int} N1, @code{int} N2)
-Allocates memory and copies the data from the @code{float**} or @code{double**} array with dimensions @var{N1}, @var{N2}, i.e. from array defined as @code{float a[N1][N2];}.
+Allocates memory and copies the data from the @code{mreal**} or @code{double**} array with dimensions @var{N1}, @var{N2}, i.e. from array defined as @code{mreal a[N1][N2];}.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const float ***}A, @code{int} N1, @code{int} N2)
+@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const mreal ***}A, @code{int} N1, @code{int} N2)
@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{const double ***}A, @code{int} N1, @code{int} N2)
-@deftypefnx {C function} @code{void} mgl_data_set_float3 (@code{HMDT} dat, @code{const float ***}A, @code{int} N1, @code{int} N2)
+@deftypefnx {C function} @code{void} mgl_data_set_mreal3 (@code{HMDT} dat, @code{const mreal ***}A, @code{int} N1, @code{int} N2)
@deftypefnx {C function} @code{void} mgl_data_set_double3 (@code{HMDT} dat, @code{const double ***}A, @code{int} N1, @code{int} N2)
-Allocates memory and copies the data from the @code{float***} or @code{double***} array with dimensions @var{N1}, @var{N2}, @var{N3}, i.e. from array defined as @code{float a[N1][N2][N3];}.
+Allocates memory and copies the data from the @code{mreal***} or @code{double***} array with dimensions @var{N1}, @var{N2}, @var{N3}, i.e. from array defined as @code{mreal a[N1][N2][N3];}.
@end deftypefn
@deftypefn {Method on @code{mglData}} @code{void} Set (@code{gsl_vector *}v)
@end deftypefn
@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const std::vector<int> &}d)
-@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{const std::vector<float> &}d)
+@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{const std::vector<mreal> &}d)
@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{const std::vector<double> &}d)
Allocates memory and copies the data from the @code{std::vector<T>} array.
@end deftypefn
@end deftypefn
@deftypefn {Method on @code{mglData}} @code{void} Link (@code{const mglData &}from)
-@deftypefnx {Method on @code{mglData}} @code{void} Link (@code{const float *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
-@deftypefnx {C function} @code{void} mgl_data_link (@code{HMDT} dat, @code{const float *}A, @code{int} NX, @code{int} NY, @code{int} NZ)
-Links external data array, i.e. don't delete it at exit.
+@deftypefnx {Method on @code{mglData}} @code{void} Link (@code{const mreal *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
+@deftypefnx {C function} @code{void} mgl_data_link (@code{HMDT} dat, @code{const mreal *}A, @code{int} NX, @code{int} NY, @code{int} NZ)
+Links external data array, i.e. don't delete this array at exit.
@end deftypefn
@end ifclear
@anchor{fill}
@deftypefn {MGL command} {} fill dat v1 v2 ['dir'='x']
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Fill (@code{float} v1, @code{float} v2, @code{char} dir=@code{'x'})
-@deftypefnx {C function} @code{void} mgl_data_fill (@code{HMDT} dat, @code{float} v1, @code{float} v2, @code{char} dir)
+@deftypefnx {Method on @code{mglData}} @code{void} Fill (@code{mreal} v1, @code{mreal} v2, @code{char} dir=@code{'x'})
+@deftypefnx {C function} @code{void} mgl_data_fill (@code{HMDT} dat, @code{mreal} v1, @code{mreal} v2, @code{char} dir)
@end ifclear
Equidistantly fills the data values to range [@var{v1}, @var{v2}] in direction @var{dir}=@{@samp{x},@samp{y},@samp{z}@}.
@end deftypefn
@end deftypefn
+@anchor{datagrid}
+@deftypefn {MGL command} {} datagrid dat xdat ydat zdat
+@ifclear UDAV
+@deftypefnx {Method on @code{mglData}} @code{mglData} Grid (@code{HMGL} gr, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{void} mgl_data_grid (@code{HMGL} gr, @code{HMDT} u, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}opt)
+@end ifclear
+Fills the value of array according to the linear interpolation of triangulated surface, found for arbitrary placed points @samp{x}, @samp{y}, @samp{z}. NAN value is used for grid points placed outside of triangulated surface.
+@end deftypefn
+
+
@anchor{put}
@deftypefn {MGL command} {} put dat @code{val [i=: j=: k=:]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Put (@code{float} val, @code{int} i=@code{-1}, @code{int} j=@code{-1}, @code{int} k=@code{-1})
-@deftypefnx mglData @code{void} mgl_data_put_val (@code{HMDT} a, @code{float} val, @code{int} i, @code{int} j, @code{int} k)
+@deftypefnx {Method on @code{mglData}} @code{void} Put (@code{mreal} val, @code{int} i=@code{-1}, @code{int} j=@code{-1}, @code{int} k=@code{-1})
+@deftypefnx mglData @code{void} mgl_data_put_val (@code{HMDT} a, @code{mreal} val, @code{int} i, @code{int} j, @code{int} k)
@end ifclear
Sets value(s) of array a[@var{i}, @var{j}, @var{k}] = @var{val}. Negative indexes @var{i}, @var{j}, @var{k}=-1 set the value @var{val} to whole range in corresponding direction(s). For example, @code{Put(val,-1,0,-1);} sets a[i,0,j]=@var{val} for i=0...(nx-1), j=0...(nz-1).
@end deftypefn
@deftypefnx {Method on @code{mglData}} @code{void} SetColumnId (@code{const char *}ids)
@deftypefnx mglData @code{void} mgl_data_set_id (@code{const char *}ids)
@end ifclear
-Sets the symbol @var{ids} for data columns. The string should contain one symbol 'a'...'z' per column. These ids are used in @ref{column} function.
+Sets the symbol @var{ids} for data columns. The string should contain one symbol 'a'...'z' per column. These ids are used in @ref{column}.
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node File I/O, Make another data, Data filling, Data processing
@section File I/O
@cindex Read
@anchor{readall}
@deftypefn {MGL command} {} readall @sc{dat} 'templ' @code{v1 v2 [dv=1 slice=off]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} ReadRange (@code{const char *}templ, @code{float} from, @code{float} to, @code{float} step=@code{1.f}, @code{bool} as_slice=@code{false})
+@deftypefnx {Method on @code{mglData}} @code{void} ReadRange (@code{const char *}templ, @code{mreal} from, @code{mreal} to, @code{mreal} step=@code{1.f}, @code{bool} as_slice=@code{false})
@end ifclear
Join data arrays from several text files. The file names are determined by function call @code{sprintf(fname,templ,val);}, where @var{val} changes from @var{from} to @var{to} with step @var{step}. The data load one-by-one in the same slice if @var{as_slice}=@code{false} or as slice-by-slice if @var{as_slice}=@code{true}.
@end deftypefn
@anchor{import}
@deftypefn {MGL command} {} import @sc{dat} 'fname' 'sch' [@code{v1=0 v2=1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Import (@code{const char *}fname, @code{const char *}scheme, @code{float} v1=@code{0}, float v2=@code{1})
-@deftypefnx {C function} @code{void} mgl_data_import (@code{HMDT} dat, @code{const char *}fname, @code{const char *}scheme, @code{float} v1, float v2)
+@deftypefnx {Method on @code{mglData}} @code{void} Import (@code{const char *}fname, @code{const char *}scheme, @code{mreal} v1=@code{0}, mreal v2=@code{1})
+@deftypefnx {C function} @code{void} mgl_data_import (@code{HMDT} dat, @code{const char *}fname, @code{const char *}scheme, @code{mreal} v1, mreal v2)
@end ifclear
-Reads data from bitmap file (now support only PNG format). The RGB values of bitmap pixels are transformed to float values in range [@var{v1}, @var{v2}] using color scheme @var{scheme} (@pxref{Color scheme}).
+Reads data from bitmap file (now support only PNG format). The RGB values of bitmap pixels are transformed to mreal values in range [@var{v1}, @var{v2}] using color scheme @var{scheme} (@pxref{Color scheme}).
@end deftypefn
@anchor{export}
@deftypefn {MGL command} {} export dat 'fname' 'sch' [@code{v1=0 v2=0}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Export (@code{const char *}fname, @code{const char *}scheme, @code{float} v1=@code{0}, float v2=@code{0}, @code{int} ns=@code{-1}) const
-@deftypefnx {C function} @code{void} mgl_data_export (@code{HMDT} dat, @code{const char *}fname, @code{const char *}scheme, @code{float} v1, float v2, @code{int} ns) const
+@deftypefnx {Method on @code{mglData}} @code{void} Export (@code{const char *}fname, @code{const char *}scheme, @code{mreal} v1=@code{0}, mreal v2=@code{0}, @code{int} ns=@code{-1}) const
+@deftypefnx {C function} @code{void} mgl_data_export (@code{HMDT} dat, @code{const char *}fname, @code{const char *}scheme, @code{mreal} v1, mreal v2, @code{int} ns) const
@end ifclear
Saves data matrix (or @code{ns}-th slice for 3d data) to bitmap file (now support only PNG format). The data values are transformed from range [@var{v1}, @var{v2}] to RGB pixels of bitmap using color scheme @var{scheme} (@pxref{Color scheme}). If @var{v1}>=@var{v2} then the values of @var{v1}, @var{v2} are automatically determined as minimal and maximal value of the data array.
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Make another data, Data changing, File I/O, Data processing
@section Make another data
@cindex SubData
@anchor{subdata}
@deftypefn {MGL command} {} subdata @sc{res} dat @code{xx [yy=: zz=:]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} SubData (@code{float} xx, @code{float} yy=@code{-1}, @code{float} zz=@code{-1}) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_subdata (@code{HCDT} dat, @code{float} xx, @code{float} yy, @code{float} zz)
+@deftypefnx {Method on @code{mglData}} @code{mglData} SubData (@code{mreal} xx, @code{mreal} yy=@code{-1}, @code{mreal} zz=@code{-1}) @code{const}
+@deftypefnx {C function} @code{HMDT} mgl_data_subdata (@code{HCDT} dat, @code{mreal} xx, @code{mreal} yy, @code{mreal} zz)
@end ifclear
Extracts sub-array data from the original data array keeping fixed positive index. For example @code{SubData(-1,2)} extracts 3d row (indexes are zero based), @code{SubData(4,-1)} extracts 5th column, @code{SubData(-1,-1,3)} extracts 4th slice and so on. If argument(s) are non-integer then linear interpolation between slices is used. In MGL version this command usually is used as inline one @code{dat(xx,yy,zz)}.
@end deftypefn
@anchor{resize}
@deftypefn {MGL command} {} resize @sc{res} dat @code{mx [my=1 mz=1]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Resize (@code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1}, @code{float} x1=@code{0}, @code{float} x2=@code{1}, @code{float} y1=@code{0}, @code{float} y2=@code{1}, @code{float} z1=@code{0}, @code{float} z2=@code{1}) @code{const}
+@deftypefnx {Method on @code{mglData}} @code{mglData} Resize (@code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1}, @code{mreal} x1=@code{0}, @code{mreal} x2=@code{1}, @code{mreal} y1=@code{0}, @code{mreal} y2=@code{1}, @code{mreal} z1=@code{0}, @code{mreal} z2=@code{1}) @code{const}
@deftypefnx {C function} @code{HMDT} mgl_data_resize (@code{HCDT} dat, @code{int} mx, @code{int} my, @code{int} mz)
-@deftypefnx {C function} @code{HMDT} mgl_data_resize_box (@code{HCDT} dat, @code{int} mx, @code{int} my, @code{int} mz, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{float} z1, @code{float} z2)
+@deftypefnx {C function} @code{HMDT} mgl_data_resize_box (@code{HCDT} dat, @code{int} mx, @code{int} my, @code{int} mz, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2, @code{mreal} z1, @code{mreal} z2)
@end ifclear
Resizes the data to new size @var{mx}, @var{my}, @var{mz} from box (part) [@var{x1},@var{x2}] x [@var{y1},@var{y2}] x [@var{z1},@var{z2}] of original array. Initially x,y,z coordinates are supposed to be in [0,1].
@end deftypefn
@deftypefn {MGL command} {} hist @sc{res} dat @code{num v1 v2 [nsub=0]}
@deftypefnx {MGL command} {} hist @sc{res} dat wdat @code{num v1 v2 [nsub=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Hist (@code{int} n, @code{float} v1=@code{0}, @code{float} v2=@code{1}, @code{int} nsub=@code{0}) @code{const}
-@deftypefnx {Method on @code{mglData}} @code{mglData} Hist (@code{const mglData &}w, @code{int} n, @code{float} v1=@code{0}, @code{float} v2=@code{1}, @code{int} nsub=@code{0}) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_hist (@code{HCDT} dat, @code{int} n, @code{float} v1, @code{float} v2, @code{int} nsub)
-@deftypefnx {C function} @code{HMDT} mgl_data_hist_w (@code{HCDT} dat, @code{HCDT} w, @code{int} n, @code{float} v1, @code{float} v2, @code{int} nsub)
+@deftypefnx {Method on @code{mglData}} @code{mglData} Hist (@code{int} n, @code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{int} nsub=@code{0}) @code{const}
+@deftypefnx {Method on @code{mglData}} @code{mglData} Hist (@code{const mglData &}w, @code{int} n, @code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{int} nsub=@code{0}) @code{const}
+@deftypefnx {C function} @code{HMDT} mgl_data_hist (@code{HCDT} dat, @code{int} n, @code{mreal} v1, @code{mreal} v2, @code{int} nsub)
+@deftypefnx {C function} @code{HMDT} mgl_data_hist_w (@code{HCDT} dat, @code{HCDT} w, @code{int} n, @code{mreal} v1, @code{mreal} v2, @code{int} nsub)
@end ifclear
Creates @var{n}-th points distribution of the data values in range [@var{v1}, @var{v2}]. Array @var{w} specifies weights of the data elements (by default is 1). Parameter @var{nsub} define the number of additional interpolated points (for smoothness of histogram). See also @ref{Data manipulation}
@end deftypefn
@deftypefnx {Method on @code{mglData}} @code{mglData} Momentum (@code{char} dir, @code{const char *}how) @code{const}
@deftypefnx {C function} @code{HMDT} mgl_data_momentum (@code{HCDT} dat, @code{char} dir, @code{const char *}how)
@end ifclear
-Gets momentum (1D-array) of the data along direction @var{dir}. String @var{how} contain kind of momentum. The momentum is defined like as
+Gets momentum (1d-array) of the data along direction @var{dir}. String @var{how} contain kind of momentum. The momentum is defined like as
@iftex
@math{res_k = \sum_{ij} how(x_i,y_j,z_k) a_{ij}/\sum_{ij} a_{ij}}
@end iftex
@ifnottex
res_k = \sum_ij how(x_i,y_j,z_k) a_ij/ \sum_ij a_ij
@end ifnottex
-if @var{var}=@samp{z} and so on. Coordinates @samp{x}, @samp{y}, @samp{z} are data indexes normalized in range [0,1].
+if @var{dir}=@samp{z} and so on. Coordinates @samp{x}, @samp{y}, @samp{z} are data indexes normalized in range [0,1].
@end deftypefn
@anchor{sum}
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Data changing, Interpolation, Make another data, Data processing
@section Data changing
@cindex CumSum
@deftypefnx {Method on @code{mglData}} @code{void} Roll (@code{char} dir, @code{num})
@deftypefnx {C function} @code{void} mgl_data_roll (@code{HMDT} dat, @code{char} dir, @code{num})
@end ifclear
-Rolls the data along direction @var{dir}. Resulting array will be out[i] = ini[(i+num)%nx] if @code{dir='x'}.
+Rolls the data along direction @var{dir}. Resulting array will be out[i] = ini[(i+@var{num})%nx] if @code{dir='x'}.
@end deftypefn
@anchor{mirror}
@anchor{sew}
@deftypefn {MGL command} {} sew dat ['dir'='xyz' @code{da=2*pi}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Sew (@code{const char *}dir, @code{float} da=@code{2*M_PI})
-@deftypefnx {C function} @code{void} mgl_data_sew (@code{HMDT} dat, @code{const char *}dir, @code{float} da)
+@deftypefnx {Method on @code{mglData}} @code{void} Sew (@code{const char *}dir, @code{mreal} da=@code{2*M_PI})
+@deftypefnx {C function} @code{void} mgl_data_sew (@code{HMDT} dat, @code{const char *}dir, @code{mreal} da)
@end ifclear
Remove value steps (like phase jumps after inverse trigonometric functions) with period @var{da} in given direction.
@end deftypefn
@anchor{smooth}
@deftypefn {MGL command} {} smooth data @code{type} ['dir'='xyz']
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Smooth (@code{const char *}dir=@code{"xyz"}, @code{float} delta=@code{0})
-@deftypefnx {C function} @code{void} mgl_data_smooth (@code{HMDT} dat, @code{const char *}dir, @code{float} delta)
+@deftypefnx {Method on @code{mglData}} @code{void} Smooth (@code{const char *}dir=@code{"xyz"}, @code{mreal} delta=@code{0})
+@deftypefnx {C function} @code{void} mgl_data_smooth (@code{HMDT} dat, @code{const char *}dir, @code{mreal} delta)
@end ifclear
Smooths the data on specified direction or directions. String @var{dirs} specifies the dimensions which will be smoothed. It may contain characters: @samp{x} for 1st dimension, @samp{y} for 2nd dimension, @samp{z} for 3d dimension. If string @var{dir} contain: @samp{0} then does nothing, @samp{3} -- linear averaging over 3 points, @samp{5} -- linear averaging over 5 points. By default quadratic averaging over 5 points is used.
@end deftypefn
@anchor{norm}
@deftypefn {MGL command} {} norm dat @code{v1 v2 [sym=off dim=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Norm (@code{float} v1=@code{0}, @code{float} v2=@code{1}, @code{bool} sym=@code{false}, @code{int} dim=@code{0})
+@deftypefnx {Method on @code{mglData}} @code{void} Norm (@code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{bool} sym=@code{false}, @code{int} dim=@code{0})
@end ifclear
Normalizes the data to range [@var{v1},@var{v2}]. If flag @var{sym}=@code{true} then symmetrical interval [-max(|v1|,|v2|), max(|v1|,|v2|)] is used. Modification will be applied only for slices >=@var{dim}.
@end deftypefn
@anchor{normsl}
@deftypefn {MGL command} {} normsl dat @code{v1 v2} ['dir'='z' @code{keep=on sym=off}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} NormSl (@code{float} v1=@code{0}, @code{float} v2=@code{1}, @code{char} dir=@code{'z'}, @code{bool} keep_en=@code{true}, @code{bool} sym=@code{false})
-@deftypefnx {C function} @code{void} mgl_data_norm_slice (@code{HMDT} dat, @code{float} v1, @code{float} v2, @code{char} dir, @code{int} keep_en, @code{int} sym)
+@deftypefnx {Method on @code{mglData}} @code{void} NormSl (@code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{char} dir=@code{'z'}, @code{bool} keep_en=@code{true}, @code{bool} sym=@code{false})
+@deftypefnx {C function} @code{void} mgl_data_norm_slice (@code{HMDT} dat, @code{mreal} v1, @code{mreal} v2, @code{char} dir, @code{int} keep_en, @code{int} sym)
@end ifclear
Normalizes data slice-by-slice along direction @var{dir} the data in slices to range [@var{v1},@var{v2}]. If flag @var{sym}=@code{true} then symmetrical interval [-max(|v1|,|v2|), max(|v1|,|v2|)] is used. If @var{keep_en} is set then maximal value of k-th slice will be limited by
@iftex
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Interpolation, Data information, Data changing, Data processing
@section Interpolation
However, there are much special faster functions in other modes (C/C++/Fortran/Python/...).
@cindex Spline
-@deftypefn {Method on @code{mglData}} @code{float} Spline (@code{float} x, @code{float} y=@code{0}, @code{float} z=@code{0}) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_spline (@code{HCDT} dat, @code{float} x, @code{float} y, @code{float} z)
+@deftypefn {Method on @code{mglData}} @code{mreal} Spline (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const}
+@deftypefnx {C function} @code{mreal} mgl_data_spline (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z)
Interpolates data by cubic spline to the given point @var{x} in [0...nx-1], @var{y} in [0...ny-1], @var{z} in [0...nz-1].
@end deftypefn
@cindex Spline1
-@deftypefn {Method on @code{mglData}} @code{float} Spline1 (@code{float} x, @code{float} y=@code{0}, @code{float} z=@code{0}) @code{const}
+@deftypefn {Method on @code{mglData}} @code{mreal} Spline1 (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const}
Interpolates data by cubic spline to the given point @var{x}, @var{y}, @var{z} which assumed to be normalized in range [0, 1].
@end deftypefn
@cindex Linear
-@deftypefn {Method on @code{mglData}} @code{float} Linear (@code{float} x, @code{float} y=@code{0}, @code{float} z=@code{0}) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_linear (@code{HCDT} dat, @code{float} x, @code{float} y, @code{float} z)
+@deftypefn {Method on @code{mglData}} @code{mreal} Linear (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const}
+@deftypefnx {C function} @code{mreal} mgl_data_linear (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z)
Interpolates data by linear function to the given point @var{x} in [0...nx-1], @var{y} in [0...ny-1], @var{z} in [0...nz-1].
@end deftypefn
@cindex Linear1
-@deftypefn {Method on @code{mglData}} @code{float} Linear1 (@code{float} x, @code{float} y=@code{0}, @code{float} z=@code{0}) @code{const}
+@deftypefn {Method on @code{mglData}} @code{mreal} Linear1 (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const}
Interpolates data by linear function to the given point @var{x}, @var{y}, @var{z} which assumed to be normalized in range [0, 1].
@end deftypefn
@end ifclear
@c ------------------------------------------------------------------
+@external
@node Data information, Operators, Interpolation, Data processing
@section Data information
Prints string @var{txt} as message.
@end deftypefn
+@deftypefn {MGL command} {} info val
+Prints value of number @var{val} as message.
+@end deftypefn
+
@cindex GetNx
@cindex GetNy
@cindex GetNz
@anchor{.max}
@deftypefn {MGL suffix} {(dat)} .max
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{float} Maximal () @code{const}
-@deftypefnx {C function} @code{float} mgl_data_max (@code{HCDT} dat)
+@deftypefnx {Method on @code{mglData}} @code{mreal} Maximal () @code{const}
+@deftypefnx {C function} @code{mreal} mgl_data_max (@code{HCDT} dat)
@end ifclear
Gets maximal value of the data.
@end deftypefn
@anchor{.min}
@deftypefn {MGL suffix} {(dat)} .min
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{float} Minimal () @code{const}
-@deftypefnx {C function} @code{float} mgl_data_min (@code{HMDT} dat) @code{const}
+@deftypefnx {Method on @code{mglData}} @code{mreal} Minimal () @code{const}
+@deftypefnx {C function} @code{mreal} mgl_data_min (@code{HMDT} dat) @code{const}
@end ifclear
Gets minimal value of the data.
@end deftypefn
@ifclear UDAV
-@deftypefn {Method on @code{mglData}} @code{float} Minimal (@code{int} &i, @code{int} &j, @code{int} &k) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_min_int (@code{HCDT} dat, @code{int} *i, @code{int} *j, @code{int} *k)
+@deftypefn {Method on @code{mglData}} @code{mreal} Minimal (@code{int} &i, @code{int} &j, @code{int} &k) @code{const}
+@deftypefnx {C function} @code{mreal} mgl_data_min_int (@code{HCDT} dat, @code{int} *i, @code{int} *j, @code{int} *k)
Gets position of minimum to variables @var{i}, @var{j}, @var{k} and returns the minimal value.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{float} Maximal (@code{int} &i, @code{int} &j, @code{int} &k) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_max_int (@code{HCDT} dat, @code{int} *i, @code{int} *j, @code{int} *k)
+@deftypefn {Method on @code{mglData}} @code{mreal} Maximal (@code{int} &i, @code{int} &j, @code{int} &k) @code{const}
+@deftypefnx {C function} @code{mreal} mgl_data_max_int (@code{HCDT} dat, @code{int} *i, @code{int} *j, @code{int} *k)
Gets position of maximum to variables @var{i}, @var{j}, @var{k} and returns the maximal value.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{float} Minimal (@code{float} &x, @code{float} &y, @code{float} &z) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_min_real (@code{HCDT} dat, @code{float} *x, @code{float} *y, @code{float} *z)
+@deftypefn {Method on @code{mglData}} @code{mreal} Minimal (@code{mreal} &x, @code{mreal} &y, @code{mreal} &z) @code{const}
+@deftypefnx {C function} @code{mreal} mgl_data_min_real (@code{HCDT} dat, @code{mreal} *x, @code{mreal} *y, @code{mreal} *z)
Gets approximated (interpolated) position of minimum to variables @var{x}, @var{y}, @var{z} and returns the minimal value.
@end deftypefn
@end ifclear
@deftypefnx {MGL suffix} {(dat)} .my
@deftypefnx {MGL suffix} {(dat)} .mz
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{float} Maximal (@code{float} &x, @code{float} &y, @code{float} &z) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_max_real (@code{HCDT} dat, @code{float} *x, @code{float} *y, @code{float} *z)
+@deftypefnx {Method on @code{mglData}} @code{mreal} Maximal (@code{mreal} &x, @code{mreal} &y, @code{mreal} &z) @code{const}
+@deftypefnx {C function} @code{mreal} mgl_data_max_real (@code{HCDT} dat, @code{mreal} *x, @code{mreal} *y, @code{mreal} *z)
@end ifclear
Gets approximated (interpolated) position of maximum to variables @var{x}, @var{y}, @var{z} and returns the maximal value.
@end deftypefn
@deftypefnx {MGL suffix} {(dat)} .kz
@deftypefnx {MGL suffix} {(dat)} .ka
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{float} Momentum (@code{char} dir, @code{float} &a, @code{float} &w) @code{const}
-@deftypefnx {Method on @code{mglData}} @code{float} Momentum (@code{char} dir, @code{float} &m, @code{float} &w, @code{float} &s, @code{float} &k) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_momentum_val (@code{HCDT} dat, @code{char} dir, @code{float} *a, @code{float} *w, @code{float} *s, @code{float} *k)
+@deftypefnx {Method on @code{mglData}} @code{mreal} Momentum (@code{char} dir, @code{mreal} &a, @code{mreal} &w) @code{const}
+@deftypefnx {Method on @code{mglData}} @code{mreal} Momentum (@code{char} dir, @code{mreal} &m, @code{mreal} &w, @code{mreal} &s, @code{mreal} &k) @code{const}
+@deftypefnx {C function} @code{mreal} mgl_data_momentum_val (@code{HCDT} dat, @code{char} dir, @code{mreal} *a, @code{mreal} *w, @code{mreal} *s, @code{mreal} *k)
@end ifclear
Gets zero-momentum (energy, @math{I=\sum dat_i}) and write first momentum (median, @math{a = \sum \xi_i dat_i/I}), second momentum (width, @math{w^2 = \sum (\xi_i-a)^2 dat_i/I}), third momentum (skewness, @math{s = \sum (\xi_i-a)^3 dat_i/ I w^3}) and fourth momentum (kurtosis, @math{k = \sum (\xi_i-a)^4 dat_i / 3 I w^4}) to variables. Here @math{\xi} is corresponding coordinate if @var{dir} is @samp{'x'}, @samp{'y'} or @samp{'z'}. Otherwise median is @math{a = \sum dat_i/N}, width is @math{w^2 = \sum (dat_i-a)^2/N} and so on.
@end deftypefn
@deftypefn {MGL suffix} {(dat)} .fst
@ifclear UDAV
@cindex Find
-@deftypefnx {Method on @code{mglData}} @code{float} Find (@code{const char *}cond, @code{int} &i, @code{int} &j, @code{int} &k) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_first (@code{HCDT} dat, @code{const char *}cond, @code{int} *i, @code{int} *j, @code{int} *k)
+@deftypefnx {Method on @code{mglData}} @code{mreal} Find (@code{const char *}cond, @code{int} &i, @code{int} &j, @code{int} &k) @code{const}
+@deftypefnx {C function} @code{mreal} mgl_data_first (@code{HCDT} dat, @code{const char *}cond, @code{int} *i, @code{int} *j, @code{int} *k)
@end ifclear
Find position (after specified in @var{i}, @var{j}, @var{k}) of first nonzero value of formula @var{cond}. Function return the data value at found position.
@end deftypefn
@deftypefn {MGL suffix} {(dat)} .lst
@ifclear UDAV
@cindex Last
-@deftypefnx {Method on @code{mglData}} @code{float} Last (@code{const char *}cond, @code{int} &i, @code{int} &j, @code{int} &k) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_last (@code{HCDT} dat, @code{const char *}cond, @code{int} *i, @code{int} *j, @code{int} *k)
+@deftypefnx {Method on @code{mglData}} @code{mreal} Last (@code{const char *}cond, @code{int} &i, @code{int} &j, @code{int} &k) @code{const}
+@deftypefnx {C function} @code{mreal} mgl_data_last (@code{HCDT} dat, @code{const char *}cond, @code{int} *i, @code{int} *j, @code{int} *k)
@end ifclear
Find position (before specified in @var{i}, @var{j}, @var{k}) of last nonzero value of formula @var{cond}. Function return the data value at found position.
@end deftypefn
@ifclear UDAV
@deftypefn {Method on @code{mglData}} @code{int} Find (@code{const char *}cond, @code{char} dir, @code{int} i=@code{0}, @code{int} j=@code{0}, @code{int} k=@code{0}) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_find (@code{HCDT} dat, @code{const char *}cond, @code{int} i, @code{int} j, @code{int} k)
+@deftypefnx {C function} @code{mreal} mgl_data_find (@code{HCDT} dat, @code{const char *}cond, @code{int} i, @code{int} j, @code{int} k)
Return position of first in direction @var{dir} nonzero value of formula @var{cond}. The search is started from point @{i,j,k@}.
@end deftypefn
@cindex FindAny
@deftypefn {Method on @code{mglData}} @code{bool} FindAny (@code{const char *}cond) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_find_any (@code{HCDT} dat, @code{const char *}cond)
+@deftypefnx {C function} @code{mreal} mgl_data_find_any (@code{HCDT} dat, @code{const char *}cond)
Determines if any nonzero value of formula in the data array.
@end deftypefn
@end ifclear
@c ------------------------------------------------------------------
+@external
@node Operators, Global functions, Data information, Data processing
@section Operators
@deftypefn {MGL command} {} copy dat @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{float}} @code{void} operator= (@code{float} val)
+@deftypefnx {Method on @code{mreal}} @code{void} operator= (@code{mreal} val)
@end ifclear
Set all data values equal to @var{val}.
@end deftypefn
@deftypefnx {MGL command} {} multo dat @code{val}
@ifclear UDAV
@deftypefnx {Method on @code{mglData}} @code{void} operator*= (@code{const mglData &}d)
-@deftypefnx {Method on @code{mglData}} @code{void} operator*= (@code{float} d)
+@deftypefnx {Method on @code{mglData}} @code{void} operator*= (@code{mreal} d)
@deftypefnx {C function} @code{void} mgl_data_mul_dat (@code{HMDT} dat, @code{HCDT} d)
-@deftypefnx {C function} @code{void} mgl_data_mul_num (@code{HMDT} dat, @code{float} d)
+@deftypefnx {C function} @code{void} mgl_data_mul_num (@code{HMDT} dat, @code{mreal} d)
@end ifclear
Multiplies data element by the other one or by value.
@end deftypefn
@deftypefnx {MGL command} {} divto dat @code{val}
@ifclear UDAV
@deftypefnx {Method on @code{mglData}} @code{void} operator/= (@code{const mglData &}d)
-@deftypefnx {Method on @code{mglData}} @code{void} operator/= (@code{float} d)
+@deftypefnx {Method on @code{mglData}} @code{void} operator/= (@code{mreal} d)
@deftypefnx {C function} @code{void} mgl_data_div_dat (@code{HMDT} dat, @code{HCDT} d)
-@deftypefnx {C function} @code{void} mgl_data_div_num (@code{HMDT} dat, @code{float} d)
+@deftypefnx {C function} @code{void} mgl_data_div_num (@code{HMDT} dat, @code{mreal} d)
@end ifclear
Divides each data element by the other one or by value.
@end deftypefn
-
@anchor{addto}
@deftypefn {MGL command} {} addto dat dat2
@deftypefnx {MGL command} {} addto dat @code{val}
@ifclear UDAV
@deftypefnx {Method on @code{mglData}} @code{void} operator+= (@code{const mglData &}d)
-@deftypefnx {Method on @code{mglData}} @code{void} operator+= (@code{float} d)
+@deftypefnx {Method on @code{mglData}} @code{void} operator+= (@code{mreal} d)
@deftypefnx {C function} @code{void} mgl_data_add_dat (@code{HMDT} dat, @code{HCDT} d)
-@deftypefnx {C function} @code{void} mgl_data_add_num (@code{HMDT} dat, @code{float} d)
+@deftypefnx {C function} @code{void} mgl_data_add_num (@code{HMDT} dat, @code{mreal} d)
@end ifclear
Adds to each data element the other one or the value.
@end deftypefn
@deftypefnx {MGL command} {} subto dat @code{val}
@ifclear UDAV
@deftypefnx {Method on @code{mglData}} @code{void} operator-= (@code{const mglData &}d)
-@deftypefnx {Method on @code{mglData}} @code{void} operator-= (@code{float} d)
+@deftypefnx {Method on @code{mglData}} @code{void} operator-= (@code{mreal} d)
@deftypefnx {C function} @code{void} mgl_data_sub_dat (@code{HMDT} dat, @code{HCDT} d)
-@deftypefnx {C function} @code{void} mgl_data_sub_num (@code{HMDT} dat, @code{float} d)
+@deftypefnx {C function} @code{void} mgl_data_sub_num (@code{HMDT} dat, @code{mreal} d)
@end ifclear
Subtracts from each data element the other one or the value.
@end deftypefn
-
@ifclear UDAV
@deftypefn {Library Function} mglData operator+ (@code{const mglData &}a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator+ (@code{float} a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator+ (@code{const mglData &}a, @code{float} b)
+@deftypefnx {Library Function} mglData operator+ (@code{mreal} a, @code{const mglData &}b)
+@deftypefnx {Library Function} mglData operator+ (@code{const mglData &}a, @code{mreal} b)
Adds the other data or the number.
@end deftypefn
@deftypefn {Library Function} mglData operator- (@code{const mglData &}a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator- (@code{float} a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator- (@code{const mglData &}a, @code{float} b)
+@deftypefnx {Library Function} mglData operator- (@code{mreal} a, @code{const mglData &}b)
+@deftypefnx {Library Function} mglData operator- (@code{const mglData &}a, @code{mreal} b)
Subtracts the other data or the number.
@end deftypefn
@deftypefn {Library Function} mglData operator* (@code{const mglData &}a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator* (@code{float} a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator* (@code{const mglData &}a, @code{float} b)
+@deftypefnx {Library Function} mglData operator* (@code{mreal} a, @code{const mglData &}b)
+@deftypefnx {Library Function} mglData operator* (@code{const mglData &}a, @code{mreal} b)
Multiplies by the other data or the number.
@end deftypefn
@deftypefn {Library Function} mglData operator/ (@code{const mglData &}a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator/ (@code{const mglData &}a, @code{float} b)
+@deftypefnx {Library Function} mglData operator/ (@code{const mglData &}a, @code{mreal} b)
Divides by the other data or the number.
@end deftypefn
@end ifclear
@c ------------------------------------------------------------------
+@external
@node Global functions, Evaluate expression, Operators, Data processing
@section Global functions
@anchor{pde}
@deftypefn {MGL command} {} pde @sc{res} 'ham' ini_re ini_im [@code{dz=0.1 k0=100}]
@ifclear UDAV
-@deftypefnx {Global function} @code{mglData} mglPDE (@code{HMGL} gr, @code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{float} dz=@code{0.1}, @code{float} k0=@code{100}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{HMDT} mgl_pde_solve (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{float} dz, @code{float} k0, @code{const char *}opt)
+@deftypefnx {Global function} @code{mglData} mglPDE (@code{HMGL} gr, @code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{mreal} dz=@code{0.1}, @code{mreal} k0=@code{100}, @code{const char *}opt=@code{""})
+@deftypefnx {C function} @code{HMDT} mgl_pde_solve (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{mreal} dz, @code{mreal} k0, @code{const char *}opt)
@end ifclear
Solves equation du/dz = i*k0*@var{ham}(p,q,x,y,z,|u|)[u], where p=-i/k0*d/dx, q=-i/k0*d/dy are pseudo-differential operators. Parameters @var{ini_re}, @var{ini_im} specify real and imaginary part of initial field distribution. Parameters @var{Min}, @var{Max} set the bounding box for the solution. Note, that really this ranges are increased by factor 3/2 for purpose of reducing reflection from boundaries. Parameter @var{dz} set the step along evolutionary coordinate z. At this moment, simplified form of function @var{ham} is supported -- all ``mixed'' terms (like @samp{x*p}->x*d/dx) are excluded. For example, in 2D case this function is effectively @math{ham = f(p,z) + g(x,z,u)}. However commutable combinations (like @samp{x*q}->x*d/dy) are allowed. Here variable @samp{u} is used for field amplitude |u|. This allow one solve nonlinear problems -- for example, for nonlinear Shrodinger equation you may set @code{ham="p^2 + q^2 - u^2"}. You may specify imaginary part for wave absorption, like @code{ham = "p^2 + i*x*(x>0)"}, but only if dependence on variable @samp{i} is linear (i.e. @math{ham = hre+i*him}). @sref{PDE solving hints}
@end deftypefn
@anchor{ray}
@deftypefn {MGL command} {} ray @sc{res} 'ham' @code{x0 y0 z0 p0 q0 v0 [dt=0.1 tmax=10]}
@ifclear UDAV
-@deftypefnx {Global function} @code{mglData} mglRay (@code{const char *}ham, @code{mglPoint} r0, @code{mglPoint} p0, @code{float} dt=@code{0.1}, @code{float} tmax=@code{10})
-@deftypefnx {C function} @code{HMDT} mgl_ray_trace (@code{const char *}ham, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} px, @code{float} py, @code{float} pz, @code{float} dt, @code{float} tmax)
+@deftypefnx {Global function} @code{mglData} mglRay (@code{const char *}ham, @code{mglPoint} r0, @code{mglPoint} p0, @code{mreal} dt=@code{0.1}, @code{mreal} tmax=@code{10})
+@deftypefnx {C function} @code{HMDT} mgl_ray_trace (@code{const char *}ham, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} px, @code{mreal} py, @code{mreal} pz, @code{mreal} dt, @code{mreal} tmax)
@end ifclear
Solves GO ray equation like dr/dt = d @var{ham}/dp, dp/dt = -d @var{ham}/dr. This is Hamiltonian equations for particle trajectory in 3D case. Here @var{ham} is Hamiltonian which may depend on coordinates @samp{x}, @samp{y}, @samp{z}, momentums @samp{p}=px, @samp{q}=py, @samp{v}=pz and time @samp{t}: @math{ham = H(x,y,z,p,q,v,t)}. The starting point (at @code{t=0}) is defined by variables @var{r0}, @var{p0}. Parameters @var{dt} and @var{tmax} specify the integration step and maximal time for ray tracing. Result is array of @{x,y,z,p,q,v,t@} with dimensions @{7 * int(@var{tmax}/@var{dt}+1) @}.
@end deftypefn
@anchor{qo2d}
@deftypefn {MGL command} {} qo2d @sc{res} 'ham' ini_re ini_im ray [@code{r=1 k0=100} xx yy]
@ifclear UDAV
-@deftypefnx {Global function} @code{mglData} mglQO2d (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{const mglData &}ray, @code{float} r=@code{1}, @code{float} k0=@code{100}, @code{mglData *}xx=@code{0}, @code{mglData *}yy=@code{0})
-@deftypefnx {Global function} @code{mglData} mglQO2d (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{const mglData &}ray, @code{mglData &}xx, @code{mglData &}yy, @code{float} r=@code{1}, @code{float} k0=@code{100})
-@deftypefnx {C function} @code{HMDT} mgl_qo2d_solve (@code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{float} r, @code{float} k0, @code{HMDT} xx, @code{HMDT} yy)
+@deftypefnx {Global function} @code{mglData} mglQO2d (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{const mglData &}ray, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100}, @code{mglData *}xx=@code{0}, @code{mglData *}yy=@code{0})
+@deftypefnx {Global function} @code{mglData} mglQO2d (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{const mglData &}ray, @code{mglData &}xx, @code{mglData &}yy, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100})
+@deftypefnx {C function} @code{HMDT} mgl_qo2d_solve (@code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{mreal} r, @code{mreal} k0, @code{HMDT} xx, @code{HMDT} yy)
@end ifclear
Solves equation du/dt = i*k0*@var{ham}(p,q,x,y,|u|)[u], where p=-i/k0*d/dx, q=-i/k0*d/dy are pseudo-differential operators (see @code{mglPDE()} for details). Parameters @var{ini_re}, @var{ini_im} specify real and imaginary part of initial field distribution. Parameters @var{ray} set the reference ray, i.e. the ray around which the accompanied coordinate system will be maked. You may use, for example, the array created by @code{mglRay()} function. Note, that the reference ray @strong{must be} smooth enough to make accompanied coodrinates unambiguity. Otherwise errors in the solution may appear. If @var{xx} and @var{yy} are non-zero then Cartesian coordinates for each point will be written into them. See also @code{mglPDE()}. @sref{PDE solving hints}
@end deftypefn
Computes the Jacobian for transformation @{i,j,k@} to @{@var{x},@var{y},@var{z}@} where initial coordinates @{i,j,k@} are data indexes normalized in range [0,1]. The Jacobian is determined by formula det||@math{dr_\alpha/d\xi_\beta}|| where @math{r}=@{@var{x},@var{y},@var{z}@} and @math{\xi}=@{i,j,k@}. All dimensions must be the same for all data arrays. Data must be 3D if all 3 arrays @{@var{x},@var{y},@var{z}@} are specified or 2D if only 2 arrays @{@var{x},@var{y}@} are specified.
@end deftypefn
-
@anchor{triangulation}
-@deftypefn {MGL command} {} triangulation @sc{res} xdat ydat [zdat]
+@deftypefn {MGL command} {} triangulation @sc{res} xdat ydat
+@c @deftypefn {MGL command} {} triangulation @sc{res} xdat ydat [zdat]
@ifclear UDAV
@deftypefnx {Global function} @code{mglData} mglTriangulation (@code{const mglData &}x, @code{const mglData &}y)
-@deftypefnx {Global function} @code{mglData} mglTriangulation (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z)
+@c @deftypefnx {Global function} @code{mglData} mglTriangulation (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z)
@deftypefnx {C function} @code{HMDT} mgl_triangulation_2d (@code{HCDT} x, @code{HCDT} y)
-@deftypefnx {C function} @code{HMDT} mgl_triangulation_3d (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z)
+@c @deftypefnx {C function} @code{HMDT} mgl_triangulation_3d (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z)
@end ifclear
-Computes triangulation for arbitrary placed points with coordinates @{@var{x},@var{y},@var{z}@} (i.e. finds triangles which connect points). The sizes of 1st dimension @strong{must be equal} for all arrays @code{x.nx=y.nx=z.nx}. Resulting array can be used in @ref{triplot} or @ref{tricont} functions for visualization of reconstructed surface.
+Computes triangulation for arbitrary placed points with coordinates @{@var{x},@var{y}@} (i.e. finds triangles which connect points). MathGL use @uref{http://www.s-hull.org/,s-hull} code for triangulation. The sizes of 1st dimension @strong{must be equal} for all arrays @code{x.nx=y.nx}. Resulting array can be used in @ref{triplot} or @ref{tricont} functions for visualization of reconstructed surface.
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Evaluate expression, , Global functions, Data processing
@section Evaluate expression
Deletes the instance of class mglExpr.
@end deftypefn
-@deftypefn {Method on @code{mglExpr}} @code{float} Eval (@code{float} x, @code{float} y, @code{float} z)
-@deftypefnx {C function} @code{float} mgl_expr_eval (@code{HMEX} ex, @code{float} x, @code{float} y, @code{float} z)
+@deftypefn {Method on @code{mglExpr}} @code{mreal} Eval (@code{mreal} x, @code{mreal} y, @code{mreal} z)
+@deftypefnx {C function} @code{mreal} mgl_expr_eval (@code{HMEX} ex, @code{mreal} x, @code{mreal} y, @code{mreal} z)
Evaluates the formula for @code{'x','r'}=@var{x}, @code{'y','n'}=@var{y}, @code{'z','t'}=@var{z}, @code{'a','u'}=@var{u}.
@end deftypefn
-@deftypefn {Method on @code{mglExpr}} @code{float} Eval (@code{float} var[26])
-@deftypefnx {C function} @code{float} mgl_expr_eval_v (@code{HMEX} ex, @code{float *}var)
+@deftypefn {Method on @code{mglExpr}} @code{mreal} Eval (@code{mreal} var[26])
+@deftypefnx {C function} @code{mreal} mgl_expr_eval_v (@code{HMEX} ex, @code{mreal *}var)
Evaluates the formula for variables in array @var{var}[0,...,'z'-'a'].
@end deftypefn
-@deftypefn {Method on @code{mglExpr}} @code{float} Diff (@code{char} dir, @code{float} x, @code{float} y, @code{float} z)
-@deftypefnx {C function} @code{float} mgl_expr_diff (@code{HMEX} ex, @code{char} dir, @code{float} x, @code{float} y, @code{float} z)
+@deftypefn {Method on @code{mglExpr}} @code{mreal} Diff (@code{char} dir, @code{mreal} x, @code{mreal} y, @code{mreal} z)
+@deftypefnx {C function} @code{mreal} mgl_expr_diff (@code{HMEX} ex, @code{char} dir, @code{mreal} x, @code{mreal} y, @code{mreal} z)
Evaluates the formula derivation respect to @var{dir} for @code{'x','r'}=@var{x}, @code{'y','n'}=@var{y}, @code{'z','t'}=@var{z}, @code{'a','u'}=@var{u}.
@end deftypefn
-@deftypefn {Method on @code{mglExpr}} @code{float} Diff (@code{char} dir, @code{float} var[26])
-@deftypefnx {C function} @code{float} mgl_expr_diff_v (@code{HMEX} ex, @code{char} dir, @code{float *}var)
+@deftypefn {Method on @code{mglExpr}} @code{mreal} Diff (@code{char} dir, @code{mreal} var[26])
+@deftypefnx {C function} @code{mreal} mgl_expr_diff_v (@code{HMEX} ex, @code{char} dir, @code{mreal *}var)
Evaluates the formula derivation respect to @var{dir} for variables in array @var{var}[0,...,'z'-'a'].
@end deftypefn
@end ifclear
+
+@external
+
@c ------------------------------------------------------------------
@chapter Обработка данных
-
@ifset UDAV
-Ð\92 данной главе опиÑ\81Ñ\8bваÑ\8eÑ\82Ñ\81Ñ\8f командÑ\8b длÑ\8f Ñ\80абоÑ\82Ñ\8b Ñ\81 маÑ\81Ñ\81ивами даннÑ\8bÑ\85. Ð\9eни вклÑ\8eÑ\87аÑ\8eÑ\82 командÑ\8b длÑ\8f вÑ\8bделениÑ\8f памÑ\8fÑ\82и и изменениÑ\8f Ñ\80азмеÑ\80а даннÑ\8bÑ\85, Ñ\87Ñ\82ениÑ\8f даннÑ\8bÑ\85 из Ñ\84айла, Ñ\87иÑ\81ленного диÑ\84Ñ\84еÑ\80енÑ\86иÑ\80ованиÑ\8f, инÑ\82егÑ\80иÑ\80ованиÑ\8f, инÑ\82еÑ\80полÑ\8fÑ\86ии и пÑ\80., заполнениÑ\8f по Ñ\82екÑ\81Ñ\82овой Ñ\84оÑ\80мÑ\83ле и Ñ\82.д. Ð\9aлаÑ\81Ñ\81 позволÑ\8fеÑ\82 Ñ\80абоÑ\82аÑ\82Ñ\8c Ñ\81 даннÑ\8bми Ñ\80азмеÑ\80ноÑ\81Ñ\82и не более 3 (как Ñ\84Ñ\83нкÑ\86ии оÑ\82 Ñ\82Ñ\80Ñ\91Ñ\85 пеÑ\80еменнÑ\8bÑ\85 -- x,y,z). Ð\9fо Ñ\83молÑ\87аниÑ\8e внÑ\83Ñ\82Ñ\80еннее пÑ\80едÑ\81Ñ\82авление даннÑ\8bÑ\85 -- float, вÑ\8bбÑ\80аннÑ\8bй в Ñ\81илÑ\83 менÑ\8cÑ\88его Ñ\80азмеÑ\80а занимаемой памÑ\8fÑ\82и и доÑ\81Ñ\82аÑ\82оÑ\87ной длÑ\8f поÑ\81Ñ\82Ñ\80оениÑ\8f гÑ\80аÑ\84иков Ñ\82оÑ\87ноÑ\81Ñ\82и. Ð\91азовÑ\8bй Ñ\82ип можно Ñ\81мениÑ\82Ñ\8c на Ñ\8dÑ\82апе Ñ\83Ñ\81Ñ\82ановки (@pxref{Installation and usage}) Ñ\83казав опÑ\86иÑ\8e @code{--enable-double}. Ð\9cаÑ\81Ñ\81ивÑ\8b коÑ\82оÑ\80Ñ\8bе могÑ\83Ñ\82 бÑ\8bÑ\82Ñ\8c Ñ\81озданÑ\8b командами MGL оÑ\82обÑ\80ажаÑ\8eÑ\82Ñ\81Ñ\8f Small Caps Ñ\88Ñ\80иÑ\84Ñ\82ом (напÑ\80имеÑ\80, @sc{dat}).
+В данной главе описываются команды для работы с массивами данных. Они включают команды для выделения памяти и изменения размера данных, чтения данных из файла, численного дифференцирования, интегрирования, интерполяции и пр., заполнения по текстовой формуле и т.д. Класс позволяет работать с данными размерности не более 3 (как функции от трёх переменных -- x,y,z). Массивы которые могут быть созданы командами MGL отображаются Small Caps шрифтом (например, @sc{dat}).
@end ifset
@ifclear UDAV
-В данной главе описывается класс @code{mglData} для работы с массивами данных, определённый в @code{#include <mgl2/mgl_data.h>}. Он содержит функции для выделения памяти и изменения размера данных, чтения данных из файла, численного дифференцирования, интегрирования, интерполяции и пр., заполнения по текстовой формуле и т.д. Класс позволяет работать с данными размерности не более 3 (как функции от трёх переменных -- x,y,z). По умолчанию внутреннее представление данных -- float, выбранный в силу меньшего размера занимаемой памяти и достаточной для построения графиков точности. Базовый тип можно сменить на этапе установки (@pxref{Installation and usage}) указав опцию @code{--enable-double}. Однако, в дальнейшем в документации будет использован тип @code{float}. Массивы которые могут быть созданы командами MGL отображаются Small Caps шрифтом (например, @sc{dat}).
+В данной главе описывается класс @code{mglData} для работы с массивами данных, определённый в @code{#include <mgl2/data.h>}. Он содержит функции для выделения памяти и изменения размера данных, чтения данных из файла, численного дифференцирования, интегрирования, интерполяции и пр., заполнения по текстовой формуле и т.д. Класс позволяет работать с данными размерности не более 3 (как функции от трёх переменных -- x,y,z). По умолчанию внутреннее представление данных -- mreal, выбранный в силу меньшего размера занимаемой памяти и достаточной для построения графиков точности. Базовый тип можно сменить на этапе установки указав опцию @code{--enable-double} (см. @ref{Installation}). Однако, в дальнейшем в документации будет использован тип @code{mreal}. Массивы которые могут быть созданы командами MGL отображаются Small Caps шрифтом (например, @sc{dat}).
@end ifclear
+@menu
* Public variables::
* Data constructor::
* Data resizing::
@end menu
@c ------------------------------------------------------------------
+@external
@node Public variables, Data constructor, , Data processing
@section Переменные
-
@ifset UDAV
MGL не поддерживает прямой доступ к элементам массива. См. раздел @ref{Data filling}
@end ifset
@ifclear UDAV
-@deftypecv {Variable} mglData @code{float *} a
+@deftypecv {Variable} mglData @code{mreal *} a
Указатель на массив данных. Это одномерный массив. Например, матрица [nx x ny x nz] представляется одномерным массивом длиной nx*ny*nz, где элемент с индексами @{i, j, k@} находится как a[i+nx*j+nx*ny*k] (индексы отсчитываются от нуля).
@end deftypecv
@deftypecv {Variable} mglData @code{int} nx
Флаг использования указателя на внешние данные, включает запрет на удаление массива данных.
@end deftypecv
-@deftypefn {Method on @code{mglData}} @code{float} GetVal (@code{long} i)
-@deftypefnx {Method on @code{mglData}} @code{void} SetVal (@code{float} val, @code{long} i)
+@deftypefn {Метод класса @code{mglData}} @code{mreal} GetVal (@code{long} i)
+@deftypefnx {Метод класса @code{mglData}} @code{void} SetVal (@code{mreal} val, @code{long} i)
Присваивает или возвращает значение используя "непрерывную" индексацию без проверки выхода за границы массива. Индекс @var{i} должен быть в диапазоне [0, nx*ny*nz-1].
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{long} GetNx ()
-@deftypefnx {Method on @code{mglData}} @code{long} GetNy ()
-@deftypefnx {Method on @code{mglData}} @code{long} GetNz ()
-@deftypefnx {C function} @code{long} mgl_data_get_nx (@code{HCDT} dat)
-@deftypefnx {C function} @code{long} mgl_data_get_ny (@code{HCDT} dat)
-@deftypefnx {C function} @code{long} mgl_data_get_nz (@code{HCDT} dat)
+@deftypefn {Метод класса @code{mglData}} @code{long} GetNx ()
+@deftypefnx {Метод класса @code{mglData}} @code{long} GetNy ()
+@deftypefnx {Метод класса @code{mglData}} @code{long} GetNz ()
+@deftypefnx {Функция С} @code{long} mgl_data_get_nx (@code{HCDT} dat)
+@deftypefnx {Функция С} @code{long} mgl_data_get_ny (@code{HCDT} dat)
+@deftypefnx {Функция С} @code{long} mgl_data_get_nz (@code{HCDT} dat)
Возвращает размер данных в направлении x, y и z соответственно.
@end deftypefn
-@deftypefn {C function} @code{float} mgl_data_get_value (@code{HCDT} dat, @code{int} i, @code{int} j, @code{int} k)
-@deftypefnx {C function} @code{float *} mgl_data_value (@code{HMDT} dat, @code{int} i, @code{int} j, @code{int} k)
-@deftypefnx {C function} @code{void} mgl_data_set_value (@code{HMDT} dat, @code{float} v, @code{int} i, @code{int} j, @code{int} k)
+@deftypefn {Функция С} @code{mreal} mgl_data_get_value (@code{HCDT} dat, @code{int} i, @code{int} j, @code{int} k)
+@deftypefnx {Функция С} @code{mreal *} mgl_data_value (@code{HMDT} dat, @code{int} i, @code{int} j, @code{int} k)
+@deftypefnx {Функция С} @code{void} mgl_data_set_value (@code{HMDT} dat, @code{mreal} v, @code{int} i, @code{int} j, @code{int} k)
Присваивает или возвращает значение ячейки данных с проверкой выхода за пределы массива.
@end deftypefn
-@deftypefn {C function} @code{const float *} mgl_data_data (@code{HCDT} dat)
+@deftypefn {Функция С} @code{const mreal *} mgl_data_data (@code{HCDT} dat)
Возвращает указатель на внутренний массив данных.
@end deftypefn
@end ifclear
@c ------------------------------------------------------------------
+@external
@node Data constructor, Data resizing, Public variables, Data processing
@section Создание и удаление данных
@cindex mglData
-@cindex Set
-
@ifset UDAV
There are many functions, which can create data for output (see @ref{Data filling}, @ref{File I/O}, @ref{Make another data}, @ref{Global functions}). Here I put most useful of them.
@end ifset
@anchor{new}
-@deftypefn {MGL command} {} new @sc{dat} [@code{nx=1} 'eq']
-@deftypefnx {MGL command} {} new @sc{dat} @code{nx ny} ['eq']
-@deftypefnx {MGL command} {} new @sc{dat} @code{nx ny nz} ['eq']
+@deftypefn {Команда MGL} {} new @sc{dat} [@code{nx=1} 'eq']
+@deftypefnx {Команда MGL} {} new @sc{dat} @code{nx ny} ['eq']
+@deftypefnx {Команда MGL} {} new @sc{dat} @code{nx ny nz} ['eq']
@ifclear UDAV
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{int} mx=@code{1}, @code{int} my=@code{1}, @code{int} mz=@code{1})
-@deftypefnx {C function} @code{HMDT} mgl_create_data ()
-@deftypefnx {C function} @code{HMDT} mgl_create_data_size (@code{int} mx, @code{int} my, @code{int} mz)
+@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{int} mx=@code{1}, @code{int} my=@code{1}, @code{int} mz=@code{1})
+@deftypefnx {Функция С} @code{HMDT} mgl_create_data ()
+@deftypefnx {Функция С} @code{HMDT} mgl_create_data_size (@code{int} mx, @code{int} my, @code{int} mz)
@end ifclear
Выделяет память для массива данных и заполняет её нулями. Если указана формула @var{eq}, то данные заполняются также как при использовании @ref{fill}.
@end deftypefn
@anchor{copy}
-@deftypefn {MGL command} {} copy @sc{dat} dat2 ['eq'='']
-@deftypefnx {MGL command} {} copy @sc{dat} @code{val}
-@ifclear UDAV
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{const mglData &}dat2)
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{const mglDataA *}dat2)
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{int} size, @code{const float *}dat2)
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{int} size, @code{int} cols, @code{const float *}dat2)
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{int} size, @code{const double *}dat2)
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{int} size, @code{int} cols, @code{const double *}dat2)
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{const double *}dat2, @code{int} size)
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{const double *}dat2, @code{int} size, @code{int} cols)
+@deftypefn {Команда MGL} {} copy @sc{dat} dat2 ['eq'='']
+@deftypefnx {Команда MGL} {} copy @sc{dat} @code{val}
+@ifclear UDAV
+@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{const mglData &}dat2)
+@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{const mglDataA *}dat2)
+@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{int} size, @code{const mreal *}dat2)
+@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{int} size, @code{int} cols, @code{const mreal *}dat2)
+@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{int} size, @code{const double *}dat2)
+@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{int} size, @code{int} cols, @code{const double *}dat2)
+@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{const double *}dat2, @code{int} size)
+@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{const double *}dat2, @code{int} size, @code{int} cols)
@end ifclear
Копирует данные из другого экземпляра данных. Если указана формула @var{eq}, то данные заполняются также как при использовании @ref{fill}.
@end deftypefn
-@deftypefn {MGL command} {} read @sc{dat} 'fname'
+@deftypefn {Команда MGL} {} read @sc{dat} 'fname'
@ifclear UDAV
-@deftypefnx {Constructor on @code{mglData}} {} mglData (@code{const char *}fname)
-@deftypefnx {C function} @code{HMDT} mgl_create_data_file (@code{const char *}fname)
+@deftypefnx {Конструктор класса @code{mglData}} {} mglData (@code{const char *}fname)
+@deftypefnx {Функция С} @code{HMDT} mgl_create_data_file (@code{const char *}fname)
@end ifclear
Читает данные из текстового файла с автоматическим определением размеров массива.
@end deftypefn
-@deftypefn {MGL command} {} delete dat
+@deftypefn {Команда MGL} {} delete dat
@ifclear UDAV
@deftypefnx {Destructor on @code{mglData}} {} ~mglData ()
-@deftypefnx {C function} @code{void} mgl_delete_data (@code{HMDT} dat)
+@deftypefnx {Функция С} @code{void} mgl_delete_data (@code{HMDT} dat)
@end ifclear
Удаляет массив данных из памяти.
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Data resizing, Data filling, Data constructor, Data processing
@section Изменение размеров данных
@cindex Create
@cindex Delete
-@deftypefn {MGL command} {} new @sc{dat} [@code{nx=1 ny=1 nz=1}]
+@deftypefn {Команда MGL} {} new @sc{dat} [@code{nx=1 ny=1 nz=1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Create (@code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1})
-@deftypefnx {C function} @code{void} mgl_data_create (@code{HMDT} dat, @code{int} mx, @code{int} my, @code{int} mz)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Create (@code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_data_create (@code{HMDT} dat, @code{int} mx, @code{int} my, @code{int} mz)
@end ifclear
Создает/пересоздает массив данных указанного размера и заполняет его нулями. Ничего не делает при @var{mx}, @var{my}, @var{mz} отрицательных или равных нулю.
@end deftypefn
@anchor{rearrange}
-@deftypefn {MGL command} {} rearrange dat @code{mx [my=0 mz=0]}
+@deftypefn {Команда MGL} {} rearrange dat @code{mx [my=0 mz=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Rearrange (@code{int} mx, @code{int} my=@code{0}, @code{int} mz=@code{0})
-@deftypefnx {C function} @code{void} mgl_data_rearrange (@code{HMDT} dat, @code{int} mx, @code{int} my, @code{int} mz)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Rearrange (@code{int} mx, @code{int} my=@code{0}, @code{int} mz=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_data_rearrange (@code{HMDT} dat, @code{int} mx, @code{int} my, @code{int} mz)
@end ifclear
Изменяет размерность данных без изменения самого массива данных, так что результирующий массив @var{mx}*@var{my}*@var{mz} < nx*ny*nz. Если один из параметров @var{my} или @var{mz} ноль, то он будет выбран оптимальным образом. Например, если @var{my}=0, то будет @var{my}=nx*ny*nz/@var{mx} и @var{mz}=1.
@end deftypefn
@anchor{transpose}
-@deftypefn {MGL command} {} transpose dat ['dim'='yxz']
+@deftypefn {Команда MGL} {} transpose dat ['dim'='yxz']
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Transpose (@code{const char *}dim=@code{"yx"})
-@deftypefnx {C function} @code{void} mgl_data_transpose (@code{const char *}dim)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Transpose (@code{const char *}dim=@code{"yx"})
+@deftypefnx {Функция С} @code{void} mgl_data_transpose (@code{const char *}dim)
@end ifclear
Транспонирует (меняет порядок размерностей) массив данных. Новый порядок размерностей задается строкой @var{dim}. Функция может быть полезна для транспонирования одномерных (или квазиодномерных) массивов после чтения их из файла.
@end deftypefn
@anchor{extend}
-@deftypefn {MGL command} {} extend dat @code{n1 [n2=0]}
+@deftypefn {Команда MGL} {} extend dat @code{n1 [n2=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Extend (@code{int} n1, @code{int} n2=@code{0})
-@deftypefnx {C function} @code{void} mgl_data_extend (@code{HMDT} dat, @code{int} n1, @code{int} n2)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Extend (@code{int} n1, @code{int} n2=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_data_extend (@code{HMDT} dat, @code{int} n1, @code{int} n2)
@end ifclear
Увеличивает размер данных путем вставки (|@var{n1}|+1) новых срезов после (для @var{n1}>0) или перед (для @var{n1}<0) существующими данными. Можно добавить сразу 2 размерности для 1d массива, используя второй параметр @var{n2}. Данные в новые срезы будут скопированы из существующих. Например, для @var{n1}>0 новый массив будет
@iftex
@end deftypefn
@anchor{squeeze}
-@deftypefn {MGL command} {} squeeze dat @code{rx [ry=1 rz=1 sm=off]}
+@deftypefn {Команда MGL} {} squeeze dat @code{rx [ry=1 rz=1 sm=off]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Squeeze (@code{int} rx, @code{int} ry=@code{1}, @code{int} rz=@code{1}, @code{bool} smooth=@code{false})
-@deftypefnx {C function} @code{void} mgl_data_squeeze (@code{HMDT} dat, @code{int} rx, @code{int} ry, @code{int} rz, @code{int} smooth)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Squeeze (@code{int} rx, @code{int} ry=@code{1}, @code{int} rz=@code{1}, @code{bool} smooth=@code{false})
+@deftypefnx {Функция С} @code{void} mgl_data_squeeze (@code{HMDT} dat, @code{int} rx, @code{int} ry, @code{int} rz, @code{int} smooth)
@end ifclear
Уменьшает размер данных путём удаления элементов с индексами не кратными @var{rx}, @var{ry}, @var{rz} соответственно. Параметр @var{smooth} задает использовать сглаживания
@iftex
@end deftypefn
@anchor{crop}
-@deftypefn {MGL command} {} crop dat @code{n1 n2} 'dir'
+@deftypefn {Команда MGL} {} crop dat @code{n1 n2} 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Crop (@code{int} n1, @code{int} n2, @code{char} dir=@code{'x'})
-@deftypefnx {C function} @code{void} mgl_data_crop (@code{HMDT} dat, @code{int} n1, @code{int} n2, @code{char} dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Crop (@code{int} n1, @code{int} n2, @code{char} dir=@code{'x'})
+@deftypefnx {Функция С} @code{void} mgl_data_crop (@code{HMDT} dat, @code{int} n1, @code{int} n2, @code{char} dir)
@end ifclear
Обрезает границы данных при @var{i}<@var{n1} и @var{i}>@var{n2} (при @var{n2}>0) или @var{i}>@code{n[xyz]}-@var{n2} (при @var{n2}<=0) вдоль направления @var{dir}.
@end deftypefn
@anchor{insert}
-@deftypefn {MGL command} {} insert dat 'dir' @code{[pos=off num=0]}
+@deftypefn {Команда MGL} {} insert dat 'dir' @code{[pos=off num=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Insert (@code{char} dir, @code{int} pos=@code{0}, @code{int} num=@code{1})
-@deftypefnx {C function} @code{void} mgl_data_insert (@code{HMDT} dat, @code{char} dir, @code{int} pos, @code{char} num)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Insert (@code{char} dir, @code{int} pos=@code{0}, @code{int} num=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_data_insert (@code{HMDT} dat, @code{char} dir, @code{int} pos, @code{char} num)
@end ifclear
Вставляет @var{num} срезов вдоль направления @var{dir} с позиции @var{pos} и заполняет их нулями.
@end deftypefn
@anchor{delete}
-@deftypefn {MGL command} {} delete dat 'dir' @code{[pos=off num=0]}
+@deftypefn {Команда MGL} {} delete dat 'dir' @code{[pos=off num=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Delete (@code{char} dir, @code{int} pos=@code{0}, @code{int} num=@code{1})
-@deftypefnx {C function} @code{void} mgl_data_delete (@code{HMDT} dat, @code{char} dir, @code{int} pos, @code{char} num)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Delete (@code{char} dir, @code{int} pos=@code{0}, @code{int} num=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_data_delete (@code{HMDT} dat, @code{char} dir, @code{int} pos, @code{char} num)
@end ifclear
Удаляет @var{num} срезов вдоль направления @var{dir} с позиции @var{pos}.
@end deftypefn
@anchor{sort}
-@deftypefn {MGL command} {} sort dat @code{idx [idy=-1]}
+@deftypefn {Команда MGL} {} sort dat @code{idx [idy=-1]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Sort (@code{lond} idx, @code{long} idy=@code{-1})
-@deftypefnx {C function} @code{void} mgl_data_sort (@code{HMDT} dat, @code{lond} idx, @code{long} idy)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Sort (@code{lond} idx, @code{long} idy=@code{-1})
+@deftypefnx {Функция С} @code{void} mgl_data_sort (@code{HMDT} dat, @code{lond} idx, @code{long} idy)
@end ifclear
-Сортирует строки (или срезы в 3D случае) по значениям в указанной колонке @var{idx} (или ячейках @{@var{idx},@var{idy}@} для 3D случая).
+Сортирует строки (или срезы в 3D случае) по значениям в указанной колонке @var{idx} (или ячейках @{@var{idx},@var{idy}@} для 3D случая). Не используйте в многопоточных функциях!
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Data filling, File I/O, Data resizing, Data processing
@section Заполнение данных
@cindex Fill
@cindex Var
@anchor{list}
-@deftypefn {MGL command} {} list @sc{dat} @code{v1 ...}
+@deftypefn {Команда MGL} {} list @sc{dat} @code{v1 ...}
Создает новый массив данных @var{dat} и заполняет его числовыми значениями аргументов @code{v1 ...}. Команда может создавать одно- и двухмерные массивы с произвольными значениями. Для создания 2d массива следует использовать разделитель @samp{|}, который означает начало новой строки данных. Размер массива данных будет [maximal of row sizes * number of rows]. Например, команда @code{list 1 | 2 3} создаст массив [1 0; 2 3]. Замечу, что максимальное число аргументов равно 1000.
@end deftypefn
-@deftypefn {MGL command} {} list @sc{dat} d1 ...
+@deftypefn {Команда MGL} {} list @sc{dat} d1 ...
Создает новый массив данных @var{dat} и заполняет его значениями из массивов @var{d1 ...}. Команда может создавать двух- и трёхмерные (если аргументы -- двумерные массивы) массивы. Меньшая размерность всех массивов в аргументах должна совпадать. В противном случае аргумент (массив) будет пропущен.
@end deftypefn
@ifclear UDAV
-@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const float *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
-@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{const double *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
-@deftypefnx {C function} @code{void} mgl_data_set_float (@code{HMDT} dat, @code{const float *}A, @code{int} NX, @code{int} NY, @code{int} NZ)
-@deftypefnx {C function} @code{void} mgl_data_set_double (@code{HMDT} dat, @code{const double *}A, @code{int} NX, @code{int} NY, @code{int} NZ)
-Выделяет память и копирует данные из массивов типа @code{float*} или @code{double*}, т.е. из массивов определённых как @code{float a[NX*NY*NZ];}.
+@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const mreal *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
+@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const double *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_data_set_mreal (@code{HMDT} dat, @code{const mreal *}A, @code{int} NX, @code{int} NY, @code{int} NZ)
+@deftypefnx {Функция С} @code{void} mgl_data_set_double (@code{HMDT} dat, @code{const double *}A, @code{int} NX, @code{int} NY, @code{int} NZ)
+Выделяет память и копирует данные из массивов типа @code{mreal*} или @code{double*}, т.е. из массивов определённых как @code{mreal a[NX*NY*NZ];}.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const float **}A, @code{int} N1, @code{int} N2)
-@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{const double **}A, @code{int} N1, @code{int} N2)
-@deftypefnx {C function} @code{void} mgl_data_set_float2 (@code{HMDT} dat, @code{const float **}A, @code{int} N1, @code{int} N2)
-@deftypefnx {C function} @code{void} mgl_data_set_double2 (@code{HMDT} dat, @code{const double **}A, @code{int} N1, @code{int} N2)
-Выделяет память и копирует данные из массивов типа @code{float**} или @code{double**} с размерностями @var{N1}, @var{N2}, т.е. из массивов определённых как @code{float a[N1][N2];}.
+@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const mreal **}A, @code{int} N1, @code{int} N2)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const double **}A, @code{int} N1, @code{int} N2)
+@deftypefnx {Функция С} @code{void} mgl_data_set_mreal2 (@code{HMDT} dat, @code{const mreal **}A, @code{int} N1, @code{int} N2)
+@deftypefnx {Функция С} @code{void} mgl_data_set_double2 (@code{HMDT} dat, @code{const double **}A, @code{int} N1, @code{int} N2)
+Выделяет память и копирует данные из массивов типа @code{mreal**} или @code{double**} с размерностями @var{N1}, @var{N2}, т.е. из массивов определённых как @code{mreal a[N1][N2];}.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const float ***}A, @code{int} N1, @code{int} N2)
-@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{const double ***}A, @code{int} N1, @code{int} N2)
-@deftypefnx {C function} @code{void} mgl_data_set_float3 (@code{HMDT} dat, @code{const float ***}A, @code{int} N1, @code{int} N2)
-@deftypefnx {C function} @code{void} mgl_data_set_double3 (@code{HMDT} dat, @code{const double ***}A, @code{int} N1, @code{int} N2)
-Выделяет память и копирует данные из массивов типа @code{float***} или @code{double***} с размерностями @var{N1}, @var{N2}, @var{N3}, т.е. из массивов определённых как @code{float a[N1][N2][N3];}.
+@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const mreal ***}A, @code{int} N1, @code{int} N2)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const double ***}A, @code{int} N1, @code{int} N2)
+@deftypefnx {Функция С} @code{void} mgl_data_set_mreal3 (@code{HMDT} dat, @code{const mreal ***}A, @code{int} N1, @code{int} N2)
+@deftypefnx {Функция С} @code{void} mgl_data_set_double3 (@code{HMDT} dat, @code{const double ***}A, @code{int} N1, @code{int} N2)
+Выделяет память и копирует данные из массивов типа @code{mreal***} или @code{double***} с размерностями @var{N1}, @var{N2}, @var{N3}, т.е. из массивов определённых как @code{mreal a[N1][N2][N3];}.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{void} Set (@code{gsl_vector *}v)
-@deftypefnx {C function} @code{void} mgl_data_set_vector (@code{HMDT} dat, @code{gsl_vector *}v)
+@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{gsl_vector *}v)
+@deftypefnx {Функция С} @code{void} mgl_data_set_vector (@code{HMDT} dat, @code{gsl_vector *}v)
Выделяет память и копирует данные из структуры типа @code{gsl_vector *}.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{void} Set (@code{gsl_matrix *}m)
-@deftypefnx {C function} @code{void} mgl_data_set_matrix (@code{HMDT} dat, @code{gsl_matrix *}m)
+@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{gsl_matrix *}m)
+@deftypefnx {Функция С} @code{void} mgl_data_set_matrix (@code{HMDT} dat, @code{gsl_matrix *}m)
Выделяет память и копирует данные из структуры типа @code{gsl_matrix *}.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const mglData &}from)
-@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{HCDT} from)
-@deftypefnx {C function} @code{void} mgl_data_set (@code{HMDT} dat, @code{HCDT} from)
+@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const mglData &}from)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{HCDT} from)
+@deftypefnx {Функция С} @code{void} mgl_data_set (@code{HMDT} dat, @code{HCDT} from)
Выделяет память и копирует данные из другого экземпляра данных @var{from}.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const std::vector<int> &}d)
-@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{const std::vector<float> &}d)
-@deftypefnx {Method on @code{mglData}} @code{void} Set (@code{const std::vector<double> &}d)
+@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const std::vector<int> &}d)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const std::vector<mreal> &}d)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Set (@code{const std::vector<double> &}d)
Выделяет память и копирует данные из массива типа @code{std::vector<T>}.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{void} Set (@code{const char *}str, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
-@deftypefnx {C function} @code{void} mgl_data_set_values (@code{const char *}str, @code{int} NX, @code{int} NY, @code{int} NZ)
+@deftypefn {Метод класса @code{mglData}} @code{void} Set (@code{const char *}str, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_data_set_values (@code{const char *}str, @code{int} NX, @code{int} NY, @code{int} NZ)
Выделяет память и сканирует массив данных из строки.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{void} Link (@code{const mglData &}from)
-@deftypefnx {Method on @code{mglData}} @code{void} Link (@code{const float *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
-@deftypefnx {C function} @code{void} mgl_data_link (@code{HMDT} dat, @code{const float *}A, @code{int} NX, @code{int} NY, @code{int} NZ)
+@deftypefn {Метод класса @code{mglData}} @code{void} Link (@code{const mglData &}from)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Link (@code{const mreal *}A, @code{int} NX, @code{int} NY=@code{1}, @code{int} NZ=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_data_link (@code{HMDT} dat, @code{const mreal *}A, @code{int} NX, @code{int} NY, @code{int} NZ)
Устанавливает флаг использования внешнего массива данных, которые не будут удалены. Флаг может быть возвращён в исходное состояние и создан новый внутренний массив если использовались функции изменяющие размер данных.
@end deftypefn
@end ifclear
@anchor{var}
-@deftypefn {MGL command} {} var @sc{dat} @code{num v1 [v2=nan]}
+@deftypefn {Команда MGL} {} var @sc{dat} @code{num v1 [v2=nan]}
Создает новый одномерный массив данных @var{dat} размером @var{num}, и заполняет его равномерно в диапазоне [@var{v1}, @var{v2}]. Если @var{v2}=@code{nan}, то используется @var{v2=v1}.
@end deftypefn
@anchor{fill}
-@deftypefn {MGL command} {} fill dat v1 v2 ['dir'='x']
+@deftypefn {Команда MGL} {} fill dat v1 v2 ['dir'='x']
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Fill (@code{float} v1, @code{float} v2, @code{char} dir=@code{'x'})
-@deftypefnx {C function} @code{void} mgl_data_fill (@code{HMDT} dat, @code{float} v1, @code{float} v2, @code{char} dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Fill (@code{mreal} v1, @code{mreal} v2, @code{char} dir=@code{'x'})
+@deftypefnx {Функция С} @code{void} mgl_data_fill (@code{HMDT} dat, @code{mreal} v1, @code{mreal} v2, @code{char} dir)
@end ifclear
Заполняет значениями равно распределёнными в диапазоне [@var{x1}, @var{x2}] в направлении @var{dir}=@{@samp{x},@samp{y},@samp{z}@}.
@end deftypefn
-@deftypefn {MGL command} {} fill dat 'eq'
-@deftypefnx {MGL command} {} fill dat 'eq' vdat
-@deftypefnx {MGL command} {} fill dat 'eq' vdat wdat
+@deftypefn {Команда MGL} {} fill dat 'eq'
+@deftypefnx {Команда MGL} {} fill dat 'eq' vdat
+@deftypefnx {Команда MGL} {} fill dat 'eq' vdat wdat
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglData}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const mglData &}vdat, @code{const char *}opt=@code{""})
-@deftypefnx {Method on @code{mglData}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const mglData &}vdat, @code{const mglData &}wdat, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{void} mgl_data_fill_eq (@code{HMGL} gr, @code{HMDT} dat, @code{const char *}eq, @code{const HMDT *}vdat, @code{const HMDT *}wdat, @code{const char *}opt)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglData}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const mglData &}vdat, @code{const char *}opt=@code{""})
+@deftypefnx {Метод класса @code{mglData}} @code{void} Fill (@code{HMGL} gr, @code{const char *}eq, @code{const mglData &}vdat, @code{const mglData &}wdat, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_data_fill_eq (@code{HMGL} gr, @code{HMDT} dat, @code{const char *}eq, @code{const HMDT *}vdat, @code{const HMDT *}wdat, @code{const char *}opt)
@end ifclear
Заполняет значениями вычисленными по формуле @var{eq}. Формула представляет собой произвольное выражение, зависящее от переменных @samp{x}, @samp{y}, @samp{z}, @samp{u}, @samp{v}, @samp{w}. Координаты @samp{x}, @samp{y}, @samp{z} полагаются меняющимися в диапазоне @var{Min} x @var{Max} (в отличие от функции @code{Modify}). Переменная @samp{u} -- значения исходного массива, переменные @samp{v}, @samp{w} -- значения массивов @var{vdat}, @var{wdat}. Последние могут быть @code{NULL}, т.е. опущены.
@end deftypefn
@anchor{modify}
-@deftypefn {MGL command} {} modify dat 'eq' [@code{dim=0}]
-@deftypefnx {MGL command} {} modify dat 'eq' vdat
-@deftypefnx {MGL command} {} modify dat 'eq' vdat wdat
+@deftypefn {Команда MGL} {} modify dat 'eq' [@code{dim=0}]
+@deftypefnx {Команда MGL} {} modify dat 'eq' vdat
+@deftypefnx {Команда MGL} {} modify dat 'eq' vdat wdat
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Modify (@code{const char *}eq, @code{int} dim=@code{0})
-@deftypefnx {Method on @code{mglData}} @code{void} Modify (@code{const char *}eq, @code{const mglData &}v)
-@deftypefnx {Method on @code{mglData}} @code{void} Modify (@code{const char *}eq, @code{const mglData &}v, @code{const mglData &}w)
-@deftypefnx {C function} @code{void} mgl_data_modify (@code{HMDT} dat, @code{const char *}eq, @code{int} dim)
-@deftypefnx {C function} @code{void} mgl_data_modify_vw (@code{HMDT} dat, @code{const char *}eq, @code{HCDT} v, @code{HCDT} w)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Modify (@code{const char *}eq, @code{int} dim=@code{0})
+@deftypefnx {Метод класса @code{mglData}} @code{void} Modify (@code{const char *}eq, @code{const mglData &}v)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Modify (@code{const char *}eq, @code{const mglData &}v, @code{const mglData &}w)
+@deftypefnx {Функция С} @code{void} mgl_data_modify (@code{HMDT} dat, @code{const char *}eq, @code{int} dim)
+@deftypefnx {Функция С} @code{void} mgl_data_modify_vw (@code{HMDT} dat, @code{const char *}eq, @code{HCDT} v, @code{HCDT} w)
@end ifclear
Аналогично предыдущему с координатами @samp{x}, @samp{y}, @samp{z}, меняющимися в диапазоне [0,1]. Если указан @var{dim}>0, то изменяются только слои >=@var{dim}.
@end deftypefn
@anchor{fillsample}
-@deftypefn {MGL command} {} fillsample dat 'how'
+@deftypefn {Команда MGL} {} fillsample dat 'how'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} FillSample (@code{const char *}how)
+@deftypefnx {Метод класса @code{mglData}} @code{void} FillSample (@code{const char *}how)
@deftypefnx mglData @code{void} mgl_data_fill_sample (@code{HMDT} a, @code{const char *}how)
@end ifclear
Заполняет массив данных 'x' или 'k' значениями для преобразований Ханкеля ('h') или Фурье ('f').
@end deftypefn
+@anchor{datagrid}
+@deftypefn {Команда MGL} {} datagrid dat xdat ydat zdat
+@ifclear UDAV
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Grid (@code{HMGL} gr, @code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{void} mgl_data_grid (@code{HMGL} gr, @code{HMDT} u, @code{HCDT} x, @code{HCDT} y, @code{HCDT} z, @code{const char *}opt)
+@end ifclear
+Заполняет значения массива результатом линейной интерполяции по триангулированной поверхности, найденной по произвольно расположенным точкам @samp{x}, @samp{y}, @samp{z}. NAN значение используется для точек сетки вне триангулированной поверхности.
+@end deftypefn
+
+
@anchor{put}
-@deftypefn {MGL command} {} put dat @code{val [i=: j=: k=:]}
+@deftypefn {Команда MGL} {} put dat @code{val [i=: j=: k=:]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Put (@code{float} val, @code{int} i=@code{-1}, @code{int} j=@code{-1}, @code{int} k=@code{-1})
-@deftypefnx mglData @code{void} mgl_data_put_val (@code{HMDT} a, @code{float} val, @code{int} i, @code{int} j, @code{int} k)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Put (@code{mreal} val, @code{int} i=@code{-1}, @code{int} j=@code{-1}, @code{int} k=@code{-1})
+@deftypefnx mglData @code{void} mgl_data_put_val (@code{HMDT} a, @code{mreal} val, @code{int} i, @code{int} j, @code{int} k)
@end ifclear
Присваивает значения (под-)массива @var{dat}[@var{i}, @var{j}, @var{k}] = @var{val}. Индексы @var{i}, @var{j}, @var{k} равные @samp{-1} задают значения @var{val} для всего диапазона соответствующего направления(ий). Например, @code{Put(val,-1,0,-1);} задает a[i,0,j]=@var{val} для i=0...(nx-1), j=0...(nz-1).
@end deftypefn
-@deftypefn {MGL command} {} put dat vdat [@code{i=: j=: k=:}]
+@deftypefn {Команда MGL} {} put dat vdat [@code{i=: j=: k=:}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Put (@code{const mglData &}v, @code{int} i=@code{-1}, @code{int} j=@code{-1}, @code{int} k=@code{-1})
+@deftypefnx {Метод класса @code{mglData}} @code{void} Put (@code{const mglData &}v, @code{int} i=@code{-1}, @code{int} j=@code{-1}, @code{int} k=@code{-1})
@deftypefnx mglData @code{void} mgl_data_put_dat (@code{HMDT} a, @code{HCDT} v, @code{int} i, @code{int} j, @code{int} k)
@end ifclear
Копирует значения из массива @var{v} в диапазон значений данного массива. Индексы @var{i}, @var{j}, @var{k} равные @samp{-1} задают диапазон изменения значений в соответствующих направление(ях). Младшие размерности массива @var{v} должны быть больше выбранного диапазона массива. Например, @code{Put(v,-1,0,-1);} присвоит a[i,0,j]=@var{v}.ny>nz ? @var{v}.a[i,j] : @var{v}.a[i], где i=0...(nx-1), j=0...(nz-1) и условие v.nx>=nx выполнено.
@end deftypefn
@anchor{idset}
-@deftypefn {MGL command} {} idset dat 'ids'
+@deftypefn {Команда MGL} {} idset dat 'ids'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} SetColumnId (@code{const char *}ids)
+@deftypefnx {Метод класса @code{mglData}} @code{void} SetColumnId (@code{const char *}ids)
@deftypefnx mglData @code{void} mgl_data_set_id (@code{const char *}ids)
@end ifclear
Задает названия @var{ids} для колонок массива данных. Строка должна содержать один символ 'a'...'z' на колонку. Эти названия используются в функции @ref{column}.
@c ------------------------------------------------------------------
+@external
@node File I/O, Make another data, Data filling, Data processing
@section Чтение/сохранение данных
@cindex Read
@cindex Export
@anchor{read}
-@deftypefn {MGL command} {} read @sc{dat} 'fname'
+@deftypefn {Команда MGL} {} read @sc{dat} 'fname'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Read (@code{const char *}fname)
-@deftypefnx {C function} @code{void} mgl_data_read (@code{HMDT} dat, @code{const char *}fname)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Read (@code{const char *}fname)
+@deftypefnx {Функция С} @code{void} mgl_data_read (@code{HMDT} dat, @code{const char *}fname)
@end ifclear
Читает данные из текстового файла с разделителями символом пробела/табуляции с автоматическим определением размера массива. Двойной перевод строки начинает новый срез данных (по направлению z).
@end deftypefn
-@deftypefn {MGL command} {} read @sc{dat} 'fname' @code{mx [my=1 mz=1]}
+@deftypefn {Команда MGL} {} read @sc{dat} 'fname' @code{mx [my=1 mz=1]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Read (@code{const char *}fname, @code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1})
-@deftypefnx {C function} @code{void} mgl_data_read_dim (@code{HMDT} dat, @code{const char *}fname, @code{int} mx, @code{int} my, @code{int} mz)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Read (@code{const char *}fname, @code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_data_read_dim (@code{HMDT} dat, @code{const char *}fname, @code{int} mx, @code{int} my, @code{int} mz)
@end ifclear
Читает данные из текстового файла с заданными размерами. Ничего не делается если параметры @var{mx}, @var{my} или @var{mz} равны нулю или отрицательны.
@end deftypefn
@anchor{readmat}
-@deftypefn {MGL command} {} readmat @sc{dat} 'fname' [@code{dim=2}]
+@deftypefn {Команда MGL} {} readmat @sc{dat} 'fname' [@code{dim=2}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} ReadMat (@code{const char *}fname, @code{int} dim=@code{2})
-@deftypefnx {C function} @code{void} mgl_data_read_mat (@code{HMDT} dat, @code{const char *}fname, @code{int} dim)
+@deftypefnx {Метод класса @code{mglData}} @code{void} ReadMat (@code{const char *}fname, @code{int} dim=@code{2})
+@deftypefnx {Функция С} @code{void} mgl_data_read_mat (@code{HMDT} dat, @code{const char *}fname, @code{int} dim)
@end ifclear
Читает данные из текстового файла с размерами, указанными в первых @var{dim} числах файла. При этом переменная @var{dim} задает размерность (1d, 2d, 3d) данных.
@end deftypefn
@anchor{readall}
-@deftypefn {MGL command} {} readall @sc{dat} 'templ' @code{v1 v2 [dv=1 slice=off]}
+@deftypefn {Команда MGL} {} readall @sc{dat} 'templ' @code{v1 v2 [dv=1 slice=off]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} ReadRange (@code{const char *}templ, @code{float} from, @code{float} to, @code{float} step=@code{1.f}, @code{bool} as_slice=@code{false})
+@deftypefnx {Метод класса @code{mglData}} @code{void} ReadRange (@code{const char *}templ, @code{mreal} from, @code{mreal} to, @code{mreal} step=@code{1.f}, @code{bool} as_slice=@code{false})
@end ifclear
Объединяет данные из нескольких текстовых файлов. Имена файлов определяются вызовом функции @code{sprintf(fname,templ,val);}, где @var{val} меняется от @var{from} до @var{to} с шагом @var{step}. Данные загружаются один за другим в один и тот же срез данных (при @var{as_slice}=@code{false}) или срез-за-срезом (при @var{as_slice}=@code{true}).
@end deftypefn
-@deftypefn {MGL command} {} readall @sc{dat} 'templ' @code{[slice=off]}
+@deftypefn {Команда MGL} {} readall @sc{dat} 'templ' @code{[slice=off]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} ReadAll (@code{const char *}templ, @code{bool} as_slice=@code{false})
+@deftypefnx {Метод класса @code{mglData}} @code{void} ReadAll (@code{const char *}templ, @code{bool} as_slice=@code{false})
@end ifclear
Объединяет данные из нескольких текстовых файлов, чьи имена удовлетворяют шаблону @var{templ} (например, @var{templ}=@code{"t_*.dat"}). Данные загружаются один за другим в один и тот же срез данных (при @var{as_slice}=@code{false}) или срез-за-срезом (при @var{as_slice}=@code{true}).
@end deftypefn
@anchor{save}
-@deftypefn {MGL command} {} save dat 'fname'
+@deftypefn {Команда MGL} {} save dat 'fname'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Save (@code{const char *}fname, @code{int} ns=@code{-1}) @code{const}
-@deftypefnx {C function} @code{void} mgl_data_save (@code{HCDT} dat, @code{const char *}fname, @code{int} ns)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Save (@code{const char *}fname, @code{int} ns=@code{-1}) @code{const}
+@deftypefnx {Функция С} @code{void} mgl_data_save (@code{HCDT} dat, @code{const char *}fname, @code{int} ns)
@end ifclear
Сохраняет весь массив данных при @var{ns}=@code{-1} или только @var{ns}-ый срез в текстовый файл.
@end deftypefn
@anchor{readhdf}
-@deftypefn {MGL command} {} readhdf @sc{dat} 'fname' 'dname'
+@deftypefn {Команда MGL} {} readhdf @sc{dat} 'fname' 'dname'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} ReadHDF (@code{const char *}fname, @code{const char *}dname)
-@deftypefnx {C function} @code{void} mgl_data_read_hdf (@code{HMDT} dat, @code{const char *}fname, @code{const char *}dname)
+@deftypefnx {Метод класса @code{mglData}} @code{void} ReadHDF (@code{const char *}fname, @code{const char *}dname)
+@deftypefnx {Функция С} @code{void} mgl_data_read_hdf (@code{HMDT} dat, @code{const char *}fname, @code{const char *}dname)
@end ifclear
-Читает массив с именем @var{dname} из HDF5 или HDF4 файла @var{fname}. Функция ничего не делает если библиотека была собрана с флагами NO_HDF5|NO_HDF4.
+Читает массив с именем @var{dname} из HDF5 или HDF4 файла @var{fname}. Функция ничего не делает если библиотека была собрана без поддержки HDF5|HDF4.
@end deftypefn
@anchor{savehdf}
-@deftypefn {MGL command} {} savehdf dat 'fname' 'dname'
+@deftypefn {Команда MGL} {} savehdf dat 'fname' 'dname'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} SaveHDF (@code{const char *}fname, @code{const char *}dname, @code{bool} rewrite=@code{false}) @code{const}
-@deftypefnx {C function} @code{void} mgl_data_save_hdf (@code{HCDT} dat, @code{const char *}fname, @code{const char *}dname, @code{int} rewrite)
+@deftypefnx {Метод класса @code{mglData}} @code{void} SaveHDF (@code{const char *}fname, @code{const char *}dname, @code{bool} rewrite=@code{false}) @code{const}
+@deftypefnx {Функция С} @code{void} mgl_data_save_hdf (@code{HCDT} dat, @code{const char *}fname, @code{const char *}dname, @code{int} rewrite)
@end ifclear
-Сохраняет массив под именем @var{dname} в HDF5 или HDF4 файл @var{fname}. Функция ничего не делает если библиотека была собрана с флагами NO_HDF5|NO_HDF4.
+Сохраняет массив под именем @var{dname} в HDF5 или HDF4 файл @var{fname}. Функция ничего не делает если библиотека была собрана без поддержки HDF5|HDF4.
@end deftypefn
@anchor{datas}
-@deftypefn {MGL command} {} datas 'fname'
+@deftypefn {Команда MGL} {} datas 'fname'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} DatasHDF (@code{const char *}fname, @code{char *}buf, @code{long} size) @code{const}
-@deftypefnx {C function} @code{void} mgl_datas_hdf (@code{const char *}fname, @code{char *}buf, @code{long} size)
+@deftypefnx {Метод класса @code{mglData}} @code{void} DatasHDF (@code{const char *}fname, @code{char *}buf, @code{long} size) @code{const}
+@deftypefnx {Функция С} @code{void} mgl_datas_hdf (@code{const char *}fname, @code{char *}buf, @code{long} size)
@end ifclear
-Помещает имена массивов данных в HDF5 файле @var{fname} в строку @var{buf} разделёнными символом табуляции '\t'. В версии MGL имена массивов будут выведены как сообщение. Функция ничего не делает если библиотека была собрана с флагом NO_HDF5.
+Помещает имена массивов данных в HDF5 файле @var{fname} в строку @var{buf} разделёнными символом табуляции '\t'. В версии MGL имена массивов будут выведены как сообщение. Функция ничего не делает если библиотека была собрана без поддержки HDF5.
@end deftypefn
@anchor{import}
-@deftypefn {MGL command} {} import @sc{dat} 'fname' 'sch' [@code{v1=0 v2=1}]
+@deftypefn {Команда MGL} {} import @sc{dat} 'fname' 'sch' [@code{v1=0 v2=1}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Import (@code{const char *}fname, @code{const char *}scheme, @code{float} v1=@code{0}, float v2=@code{1})
-@deftypefnx {C function} @code{void} mgl_data_import (@code{HMDT} dat, @code{const char *}fname, @code{const char *}scheme, @code{float} v1, float v2)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Import (@code{const char *}fname, @code{const char *}scheme, @code{mreal} v1=@code{0}, mreal v2=@code{1})
+@deftypefnx {Функция С} @code{void} mgl_data_import (@code{HMDT} dat, @code{const char *}fname, @code{const char *}scheme, @code{mreal} v1, mreal v2)
@end ifclear
Читает данные из растрового файла. RGB значения пикселов преобразуются в число в диапазоне [@var{v1}, @var{v2}] используя цветовую схему @var{sch} (@pxref{Color scheme}).
@end deftypefn
@anchor{export}
-@deftypefn {MGL command} {} export dat 'fname' 'sch' [@code{v1=0 v2=0}]
+@deftypefn {Команда MGL} {} export dat 'fname' 'sch' [@code{v1=0 v2=0}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Export (@code{const char *}fname, @code{const char *}scheme, @code{float} v1=@code{0}, float v2=@code{0}, @code{int} ns=@code{-1}) const
-@deftypefnx {C function} @code{void} mgl_data_export (@code{HMDT} dat, @code{const char *}fname, @code{const char *}scheme, @code{float} v1, float v2, @code{int} ns) const
+@deftypefnx {Метод класса @code{mglData}} @code{void} Export (@code{const char *}fname, @code{const char *}scheme, @code{mreal} v1=@code{0}, mreal v2=@code{0}, @code{int} ns=@code{-1}) const
+@deftypefnx {Функция С} @code{void} mgl_data_export (@code{HMDT} dat, @code{const char *}fname, @code{const char *}scheme, @code{mreal} v1, mreal v2, @code{int} ns) const
@end ifclear
Сохраняет данные в растровый файл. Числовые значения, нормированные в диапазон [@var{v1}, @var{v2}], преобразуются в RGB значения пикселов, используя цветовую схему @var{sch} (@pxref{Color scheme}). Если @var{v1}>=@var{v2}, то значения @var{v1}, @var{v2} определяются автоматически как минимальное и максимальное значение данных.
@end deftypefn
-
@c ------------------------------------------------------------------
+@external
@node Make another data, Data changing, File I/O, Data processing
@section Make another data
@cindex SubData
@cindex Max
@anchor{subdata}
-@deftypefn {MGL command} {} subdata @sc{res} dat @code{xx [yy=: zz=:]}
+@deftypefn {Команда MGL} {} subdata @sc{res} dat @code{xx [yy=: zz=:]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} SubData (@code{float} xx, @code{float} yy=@code{-1}, @code{float} zz=@code{-1}) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_subdata (@code{HCDT} dat, @code{float} xx, @code{float} yy, @code{float} zz)
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} SubData (@code{mreal} xx, @code{mreal} yy=@code{-1}, @code{mreal} zz=@code{-1}) @code{const}
+@deftypefnx {Функция С} @code{HMDT} mgl_data_subdata (@code{HCDT} dat, @code{mreal} xx, @code{mreal} yy, @code{mreal} zz)
@end ifclear
Возвращает в @var{res} подмассив массива данных @var{dat} с фиксированными значениями индексов с положительными значениями. Например, @code{SubData(-1,2)} выделяет третью строку (индексы начинаются с нуля), @code{SubData(4,-1)} выделяет 5-ую колонку, @code{SubData(-1,-1,3)} выделяет 4-ый срез и т.д. В MGL скриптах обычно используется упрощенная версия @code{dat(xx,yy,zz)}.
@end deftypefn
-@deftypefn {MGL command} {} subdata @sc{res} dat xdat [ydat=: zdat=:]
+@deftypefn {Команда MGL} {} subdata @sc{res} dat xdat [ydat=: zdat=:]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} SubData (@code{const mglData &}xx, @code{const mglData &}yy, @code{const mglData &}zz) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_subdata_ext (@code{HCDT} dat, @code{HCDT} xx, @code{HCDT} yy, @code{HCDT} zz)
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} SubData (@code{const mglData &}xx, @code{const mglData &}yy, @code{const mglData &}zz) @code{const}
+@deftypefnx {Функция С} @code{HMDT} mgl_data_subdata_ext (@code{HCDT} dat, @code{HCDT} xx, @code{HCDT} yy, @code{HCDT} zz)
@end ifclear
Возвращает в @var{res} подмассив массива данных @var{dat} с индексами, заданными в массивах @var{xx}, @var{yy}, @var{zz} (косвенная адресация). Результат будет иметь размерность массивов с индексами. Размеры массивов @var{xx}, @var{yy}, @var{zz} с индексами должна быть одинакова, либо должны быть "скаляром" (т.е. 1*1*1). В MGL скриптах обычно используется упрощенная версия @code{dat(xx,yy,zz)}.
@end deftypefn
@anchor{column}
-@deftypefn {MGL command} {} column @sc{res} dat 'eq'
+@deftypefn {Команда MGL} {} column @sc{res} dat 'eq'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Column (@code{const char *}eq) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_column (@code{HCDT} dat, @code{const char *}eq)
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Column (@code{const char *}eq) @code{const}
+@deftypefnx {Функция С} @code{HMDT} mgl_data_column (@code{HCDT} dat, @code{const char *}eq)
@end ifclear
Возвращает массив данных заполненный по формуле @var{eq}, вычисленной для именованных колонок (или срезов). Например, @code{Column("n*w^2/exp(t)");}. Имена колонок должны быть предварительно заданы функцией @ref{idset} или при чтении файлов данных. В MGL скриптах обычно используется упрощенная версия @code{dat('eq')}.
@end deftypefn
@anchor{resize}
-@deftypefn {MGL command} {} resize @sc{res} dat @code{mx [my=1 mz=1]}
+@deftypefn {Команда MGL} {} resize @sc{res} dat @code{mx [my=1 mz=1]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Resize (@code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1}, @code{float} x1=@code{0}, @code{float} x2=@code{1}, @code{float} y1=@code{0}, @code{float} y2=@code{1}, @code{float} z1=@code{0}, @code{float} z2=@code{1}) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_resize (@code{HCDT} dat, @code{int} mx, @code{int} my, @code{int} mz)
-@deftypefnx {C function} @code{HMDT} mgl_data_resize_box (@code{HCDT} dat, @code{int} mx, @code{int} my, @code{int} mz, @code{float} x1, @code{float} x2, @code{float} y1, @code{float} y2, @code{float} z1, @code{float} z2)
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Resize (@code{int} mx, @code{int} my=@code{1}, @code{int} mz=@code{1}, @code{mreal} x1=@code{0}, @code{mreal} x2=@code{1}, @code{mreal} y1=@code{0}, @code{mreal} y2=@code{1}, @code{mreal} z1=@code{0}, @code{mreal} z2=@code{1}) @code{const}
+@deftypefnx {Функция С} @code{HMDT} mgl_data_resize (@code{HCDT} dat, @code{int} mx, @code{int} my, @code{int} mz)
+@deftypefnx {Функция С} @code{HMDT} mgl_data_resize_box (@code{HCDT} dat, @code{int} mx, @code{int} my, @code{int} mz, @code{mreal} x1, @code{mreal} x2, @code{mreal} y1, @code{mreal} y2, @code{mreal} z1, @code{mreal} z2)
@end ifclear
Возвращает массив данных размером @var{mx}, @var{my}, @var{mz} со значениями полученными интерполяцией значений из части [@var{x1},@var{x2}] x [@var{y1},@var{y2}] x [@var{z1},@var{z2}] исходного массива. Величины x,y,z полагаются нормированными в диапазоне [0,1].
@end deftypefn
@anchor{evaluate}
-@deftypefn {MGL command} {} evaluate @sc{res} dat idat [@code{norm=on}]
-@deftypefnx {MGL command} {} evaluate @sc{res} dat idat jdat [@code{norm=on}]
-@deftypefnx {MGL command} {} evaluate @sc{res} dat idat jdat kdat [@code{norm=on}]
+@deftypefn {Команда MGL} {} evaluate @sc{res} dat idat [@code{norm=on}]
+@deftypefnx {Команда MGL} {} evaluate @sc{res} dat idat jdat [@code{norm=on}]
+@deftypefnx {Команда MGL} {} evaluate @sc{res} dat idat jdat kdat [@code{norm=on}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Evaluate (@code{const mglData &}idat, @code{bool} norm=@code{true}) @code{const}
-@deftypefnx {Method on @code{mglData}} @code{mglData} Evaluate (@code{const mglData &}idat, @code{const mglData &}jdat, @code{bool} norm=@code{true}) @code{const}
-@deftypefnx {Method on @code{mglData}} @code{mglData} Evaluate (@code{const mglData &}idat, @code{const mglData &}jdat, @code{const mglData &}kdat, @code{bool} norm=@code{true}) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_evaluate (@code{HCDT} dat, @code{HCDT} idat, @code{HCDT} jdat, @code{HCDT} kdat, @code{int} norm)
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Evaluate (@code{const mglData &}idat, @code{bool} norm=@code{true}) @code{const}
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Evaluate (@code{const mglData &}idat, @code{const mglData &}jdat, @code{bool} norm=@code{true}) @code{const}
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Evaluate (@code{const mglData &}idat, @code{const mglData &}jdat, @code{const mglData &}kdat, @code{bool} norm=@code{true}) @code{const}
+@deftypefnx {Функция С} @code{HMDT} mgl_data_evaluate (@code{HCDT} dat, @code{HCDT} idat, @code{HCDT} jdat, @code{HCDT} kdat, @code{int} norm)
@end ifclear
Возвращает массив данных, полученный в результате интерполяции исходного массива в точках других массивов (например, res[i,j]=dat[idat[i,j],jdat[i,j]]). Размеры массивов @var{idat}, @var{jdat}, @var{kdat} должны совпадать. Координаты в @var{idat}, @var{jdat}, @var{kdat} полагаются нормированными в диапазон [0,1] (при @var{norm}=@code{true}) или в диапазоны [0,nx], [0,ny], [0,nz] соответственно.
@end deftypefn
@anchor{hist}
-@deftypefn {MGL command} {} hist @sc{res} dat @code{num v1 v2 [nsub=0]}
-@deftypefnx {MGL command} {} hist @sc{res} dat wdat @code{num v1 v2 [nsub=0]}
+@deftypefn {Команда MGL} {} hist @sc{res} dat @code{num v1 v2 [nsub=0]}
+@deftypefnx {Команда MGL} {} hist @sc{res} dat wdat @code{num v1 v2 [nsub=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Hist (@code{int} n, @code{float} v1=@code{0}, @code{float} v2=@code{1}, @code{int} nsub=@code{0}) @code{const}
-@deftypefnx {Method on @code{mglData}} @code{mglData} Hist (@code{const mglData &}w, @code{int} n, @code{float} v1=@code{0}, @code{float} v2=@code{1}, @code{int} nsub=@code{0}) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_hist (@code{HCDT} dat, @code{int} n, @code{float} v1, @code{float} v2, @code{int} nsub)
-@deftypefnx {C function} @code{HMDT} mgl_data_hist_w (@code{HCDT} dat, @code{HCDT} w, @code{int} n, @code{float} v1, @code{float} v2, @code{int} nsub)
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Hist (@code{int} n, @code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{int} nsub=@code{0}) @code{const}
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Hist (@code{const mglData &}w, @code{int} n, @code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{int} nsub=@code{0}) @code{const}
+@deftypefnx {Функция С} @code{HMDT} mgl_data_hist (@code{HCDT} dat, @code{int} n, @code{mreal} v1, @code{mreal} v2, @code{int} nsub)
+@deftypefnx {Функция С} @code{HMDT} mgl_data_hist_w (@code{HCDT} dat, @code{HCDT} w, @code{int} n, @code{mreal} v1, @code{mreal} v2, @code{int} nsub)
@end ifclear
Возвращает распределение (гистограмму) из @var{n} точек от значений массива в диапазоне [@var{v1}, @var{v2}]. Массив @var{w} задает веса элементов (по умолчанию все веса равны 1). Параметр @var{nsub} задает число дополнительных точек интерполяции (для сглаживания получившейся гистограммы). См. также @ref{Data manipulation}
@end deftypefn
@anchor{momentum}
-@deftypefn {MGL command} {} momentum @sc{res} dat 'how' ['dir'='z']
+@deftypefn {Команда MGL} {} momentum @sc{res} dat 'how' ['dir'='z']
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Momentum (@code{char} dir, @code{const char *}how) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_momentum (@code{HCDT} dat, @code{char} dir, @code{const char *}how)
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Momentum (@code{char} dir, @code{const char *}how) @code{const}
+@deftypefnx {Функция С} @code{HMDT} mgl_data_momentum (@code{HCDT} dat, @code{char} dir, @code{const char *}how)
@end ifclear
Возвращает момент (1d массив) данных вдоль направления @var{dir}. Строка @var{how} определяет тип момента. Момент определяется как
@iftex
@end deftypefn
@anchor{sum}
-@deftypefn {MGL command} {} sum @sc{res} dat 'dir'
+@deftypefn {Команда MGL} {} sum @sc{res} dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Sum (@code{const char *}dir) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_sum (@code{HCDT} dat, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Sum (@code{const char *}dir) @code{const}
+@deftypefnx {Функция С} @code{HMDT} mgl_data_sum (@code{HCDT} dat, @code{const char *}dir)
@end ifclear
Возвращает результат суммирования данных вдоль направления(ий) @var{dir}.
@end deftypefn
@anchor{max}
-@deftypefn {MGL command} {} max @sc{res} dat 'dir'
+@deftypefn {Команда MGL} {} max @sc{res} dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Max (@code{const char *}dir) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_max_dir (@code{HCDT} dat, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Max (@code{const char *}dir) @code{const}
+@deftypefnx {Функция С} @code{HMDT} mgl_data_max_dir (@code{HCDT} dat, @code{const char *}dir)
@end ifclear
Возвращает максимальное значение данных вдоль направления(ий) @var{dir}.
@end deftypefn
@anchor{min}
-@deftypefn {MGL command} {} min @sc{res} dat 'dir'
+@deftypefn {Команда MGL} {} min @sc{res} dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Min (@code{const char *}dir) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_min_dir (@code{HCDT} dat, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Min (@code{const char *}dir) @code{const}
+@deftypefnx {Функция С} @code{HMDT} mgl_data_min_dir (@code{HCDT} dat, @code{const char *}dir)
@end ifclear
Возвращает минимальное значение данных вдоль направления(ий) @var{dir}.
@end deftypefn
@anchor{combine}
-@deftypefn {MGL command} {} combine @sc{res} adat bdat
+@deftypefn {Команда MGL} {} combine @sc{res} adat bdat
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Combine (@code{const mglData &}a) @code{const}
-@deftypefnx {C function} @code{HMDT} mgl_data_combine (@code{HCDT} dat, @code{HCDT} a)
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Combine (@code{const mglData &}a) @code{const}
+@deftypefnx {Функция С} @code{HMDT} mgl_data_combine (@code{HCDT} dat, @code{HCDT} a)
@end ifclear
Возвращает прямое произведение массивов (наподобие, res[i,j] = adat[i]*bdat[j] и т.д.).
@end deftypefn
@anchor{trace}
-@deftypefn {MGL command} {} trace @sc{res} dat
+@deftypefn {Команда MGL} {} trace @sc{res} dat
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{mglData} Trace () @code{const}
+@deftypefnx {Метод класса @code{mglData}} @code{mglData} Trace () @code{const}
@end ifclear
Возвращает массив диагональных элементов a[i,i] (для 2D данных) или a[i,i,i] (для 3D данных) где i=0...nx-1. В 1D случае возвращается сам массив данных. Размеры массива данных должен быть ny,nz >= nx или ny,nz = 1.
@end deftypefn
-
@c ------------------------------------------------------------------
+@external
@node Data changing, Interpolation, Make another data, Data processing
@section Изменение данных
@cindex CumSum
These functions change the data in some direction like differentiations, integrations and so on. The direction in which the change will applied is specified by the string parameter, which may contain @samp{x}, @samp{y} or @samp{z} characters for 1-st, 2-nd and 3-d dimension correspondengly.
@anchor{cumsum}
-@deftypefn {MGL command} {} cumsum dat 'dir'
+@deftypefn {Команда MGL} {} cumsum dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} CumSum (@code{const char *}dir)
-@deftypefnx {C function} @code{void} mgl_data_cumsum (@code{HMDT} dat, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} CumSum (@code{const char *}dir)
+@deftypefnx {Функция С} @code{void} mgl_data_cumsum (@code{HMDT} dat, @code{const char *}dir)
@end ifclear
Суммирует с накоплением в выбранном направлении(ях).
@end deftypefn
@anchor{integrate}
-@deftypefn {MGL command} {} integrate dat 'dir'
+@deftypefn {Команда MGL} {} integrate dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Integral (@code{const char *}dir)
-@deftypefnx {C function} @code{void} mgl_data_integral (@code{HMDT} dat, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Integral (@code{const char *}dir)
+@deftypefnx {Функция С} @code{void} mgl_data_integral (@code{HMDT} dat, @code{const char *}dir)
@end ifclear
Выполняет интегрирование (методом трапеций) в выбранном направлении(ях).
@end deftypefn
@anchor{diff}
-@deftypefn {MGL command} {} diff dat 'dir'
+@deftypefn {Команда MGL} {} diff dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Diff (@code{const char *}dir)
-@deftypefnx {C function} @code{void} mgl_data_diff (@code{HMDT} dat, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Diff (@code{const char *}dir)
+@deftypefnx {Функция С} @code{void} mgl_data_diff (@code{HMDT} dat, @code{const char *}dir)
@end ifclear
Выполняет дифференцирование в выбранном направлении(ях).
@end deftypefn
-@deftypefn {MGL command} {} diff dat xdat ydat [zdat=0]
+@deftypefn {Команда MGL} {} diff dat xdat ydat [zdat=0]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Diff (@code{const mglData &}x, @code{const mglData &}y)
-@deftypefnx {Method on @code{mglData}} @code{void} Diff (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z)
-@deftypefnx {C function} @code{void} mgl_data_diff_par (@code{HMDT} dat, @code{HCDT} x, @code{HCDT}y, @code{HCDT}z)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Diff (@code{const mglData &}x, @code{const mglData &}y)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Diff (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z)
+@deftypefnx {Функция С} @code{void} mgl_data_diff_par (@code{HMDT} dat, @code{HCDT} x, @code{HCDT}y, @code{HCDT}z)
@end ifclear
Выполняет дифференцирование данных, параметрически зависящих от координат, в направлении @var{x} с @var{y}, @var{z}=constant. Параметр @var{z} может быть опущен, что соответствует 2D случаю. Используются следующие формулы (2D случай): @math{da/dx = (a_j*y_i-a_i*y_j)/(x_j*y_i-x_i*y_j)}, где @math{a_i=da/di, a_j=da/dj} обозначает дифференцирование вдоль 1-ой и 2-ой размерности. Похожие формулы используются и в 3D случае. Порядок аргументов можно менять -- например, если данные a(i,j) зависят от координат @{x(i,j), y(i,j)@}, то обычная производная по @samp{x} будет равна @code{Diff(x,y);}, а обычная производная по @samp{y} будет равна @code{Diff(y,x);}.
@end deftypefn
@anchor{diff2}
-@deftypefn {MGL command} {} diff2 dat 'dir'
+@deftypefn {Команда MGL} {} diff2 dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Diff2 (@code{const char *}dir)
-@deftypefnx {C function} @code{void} mgl_data_diff2 (@code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Diff2 (@code{const char *}dir)
+@deftypefnx {Функция С} @code{void} mgl_data_diff2 (@code{const char *}dir)
@end ifclear
Выполняет двойное дифференцирование (как в операторе Лапласа) в выбранном направлении(ях).
@end deftypefn
@anchor{sinfft}
-@deftypefn {MGL command} {} sinfft dat 'dir'
+@deftypefn {Команда MGL} {} sinfft dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} SinFFT (@code{const char *}dir)
-@deftypefnx {C function} @code{void} mgl_data_sinfft (@code{HMDT} dat, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} SinFFT (@code{const char *}dir)
+@deftypefnx {Функция С} @code{void} mgl_data_sinfft (@code{HMDT} dat, @code{const char *}dir)
@end ifclear
Выполняет синус преобразование в выбранном направлении(ях). Синус преобразование есть @math{\sum a_i \sin(k i)}.
@end deftypefn
@anchor{cosfft}
-@deftypefn {MGL command} {} cosfft dat 'dir'
+@deftypefn {Команда MGL} {} cosfft dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} CosFFT (@code{const char *}dir)
-@deftypefnx {C function} @code{void} mgl_data_cosfft (@code{HMDT} dat, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} CosFFT (@code{const char *}dir)
+@deftypefnx {Функция С} @code{void} mgl_data_cosfft (@code{HMDT} dat, @code{const char *}dir)
@end ifclear
Выполняет косинус преобразование в выбранном направлении(ях). Синус преобразование есть @math{\sum a_i \cos(k i)}.
@end deftypefn
@anchor{hankel}
-@deftypefn {MGL command} {} hankel dat 'dir'
+@deftypefn {Команда MGL} {} hankel dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Hankel (@code{const char *}dir)
-@deftypefnx {C function} @code{void} mgl_data_hankel (@code{HMDT} dat, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Hankel (@code{const char *}dir)
+@deftypefnx {Функция С} @code{void} mgl_data_hankel (@code{HMDT} dat, @code{const char *}dir)
@end ifclear
Выполняет преобразование Ханкеля в выбранном направлении(ях). Преобразование Ханкеля есть @math{\sum a_i J_0(k i)}.
@end deftypefn
@anchor{swap}
-@deftypefn {MGL command} {} swap dat 'dir'
+@deftypefn {Команда MGL} {} swap dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Swap (@code{const char *}dir)
-@deftypefnx {C function} @code{void} mgl_data_swap (@code{HMDT} dat, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Swap (@code{const char *}dir)
+@deftypefnx {Функция С} @code{void} mgl_data_swap (@code{HMDT} dat, @code{const char *}dir)
@end ifclear
Меняет местами левую и правую части данных в выбранном направлении(ях). Полезно для отображения результата FFT.
@end deftypefn
@anchor{roll}
-@deftypefn {MGL command} {} roll dat 'dir' num
+@deftypefn {Команда MGL} {} roll dat 'dir' num
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Roll (@code{char} dir, @code{num})
-@deftypefnx {C function} @code{void} mgl_data_roll (@code{HMDT} dat, @code{char} dir, @code{num})
-@end ifclearСдвигает данные на @var{num} ячеек в выбранном направлении(ях). Соответствует замене индекса на @var{i}->(@var{i}+@var{num})%@var{n} при @code{dir='x'}.
+@deftypefnx {Метод класса @code{mglData}} @code{void} Roll (@code{char} dir, @code{num})
+@deftypefnx {Функция С} @code{void} mgl_data_roll (@code{HMDT} dat, @code{char} dir, @code{num})
+@end ifclear
+Сдвигает данные на @var{num} ячеек в выбранном направлении(ях). Соответствует замене индекса на @var{i}->(i+@var{num})%nx при @code{dir='x'}.
@end deftypefn
@anchor{mirror}
-@deftypefn {MGL command} {} mirror dat 'dir'
+@deftypefn {Команда MGL} {} mirror dat 'dir'
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Mirror (@code{const char *}dir)
-@deftypefnx {C function} @code{void} mgl_data_mirror (@code{HMDT} dat, @code{const char *}dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Mirror (@code{const char *}dir)
+@deftypefnx {Функция С} @code{void} mgl_data_mirror (@code{HMDT} dat, @code{const char *}dir)
@end ifclear
Отражает данные в выбранном направлении(ях). Соответствует замене индекса на @var{i}->@var{n}-@var{i}. Отмечу, что похожего эффекта на графике можно достичь используя опции (@pxref{Command options}), например, @code{surf dat; xrange 1 -1}.
@end deftypefn
@anchor{sew}
-@deftypefn {MGL command} {} sew dat ['dir'='xyz' @code{da=2*pi}]
+@deftypefn {Команда MGL} {} sew dat ['dir'='xyz' @code{da=2*pi}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Sew (@code{const char *}dir, @code{float} da=@code{2*M_PI})
-@deftypefnx {C function} @code{void} mgl_data_sew (@code{HMDT} dat, @code{const char *}dir, @code{float} da)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Sew (@code{const char *}dir, @code{mreal} da=@code{2*M_PI})
+@deftypefnx {Функция С} @code{void} mgl_data_sew (@code{HMDT} dat, @code{const char *}dir, @code{mreal} da)
@end ifclear
Удаляет скачки данных (например, скачки фазы после обратных тригонометрических функций) с периодом @var{da} в выбранном направлении(ях).
@end deftypefn
@anchor{smooth}
-@deftypefn {MGL command} {} smooth data @code{type} ['dir'='xyz']
+@deftypefn {Команда MGL} {} smooth data @code{type} ['dir'='xyz']
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Smooth (@code{const char *}dir=@code{"xyz"}, @code{float} delta=@code{0})
-@deftypefnx {C function} @code{void} mgl_data_smooth (@code{HMDT} dat, @code{const char *}dir, @code{float} delta)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Smooth (@code{const char *}dir=@code{"xyz"}, @code{mreal} delta=@code{0})
+@deftypefnx {Функция С} @code{void} mgl_data_smooth (@code{HMDT} dat, @code{const char *}dir, @code{mreal} delta)
@end ifclear
Сглаживает данные в выбранном направлении(ях) @var{dir}. Строка @var{dirs} задает направления вдоль которых будет производиться сглаживание. Если @var{dirs} содержит: @samp{0} -- ничего не делает, @samp{3} линейное усреднение по 3 точкам, @samp{5} линейное усреднение по 5 точкам. По умолчанию используется квадратичное усреднение по 5 точкам.
@end deftypefn
@anchor{envelop}
-@deftypefn {MGL command} {} envelop dat ['dir'='x']
+@deftypefn {Команда MGL} {} envelop dat ['dir'='x']
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Envelop (@code{char} dir=@code{'x'})
-@deftypefnx {C function} @code{void} mgl_data_envelop (@code{HMDT} dat, @code{char} dir)
+@deftypefnx {Метод класса @code{mglData}} @code{void} Envelop (@code{char} dir=@code{'x'})
+@deftypefnx {Функция С} @code{void} mgl_data_envelop (@code{HMDT} dat, @code{char} dir)
@end ifclear
Находит огибающую данных в выбранном направлении @var{dir}.
@end deftypefn
@anchor{norm}
-@deftypefn {MGL command} {} norm dat @code{v1 v2 [sym=off dim=0]}
+@deftypefn {Команда MGL} {} norm dat @code{v1 v2 [sym=off dim=0]}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} Norm (@code{float} v1=@code{0}, @code{float} v2=@code{1}, @code{bool} sym=@code{false}, @code{int} dim=@code{0})
+@deftypefnx {Метод класса @code{mglData}} @code{void} Norm (@code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{bool} sym=@code{false}, @code{int} dim=@code{0})
@end ifclear
Нормирует данные в интервал [@var{v1},@var{v2}]. Если @var{sym}=@code{true}, то используется симметричный интервал [-max(|v1|,|v2|), max(|v1|,|v2|)]. Изменения применяются только к срезам >=@var{dim}.
@end deftypefn
@anchor{normsl}
-@deftypefn {MGL command} {} normsl dat @code{v1 v2} ['dir'='z' @code{keep=on sym=off}]
+@deftypefn {Команда MGL} {} normsl dat @code{v1 v2} ['dir'='z' @code{keep=on sym=off}]
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} NormSl (@code{float} v1=@code{0}, @code{float} v2=@code{1}, @code{char} dir=@code{'z'}, @code{bool} keep_en=@code{true}, @code{bool} sym=@code{false})
-@deftypefnx {C function} @code{void} mgl_data_norm_slice (@code{HMDT} dat, @code{float} v1, @code{float} v2, @code{char} dir, @code{int} keep_en, @code{int} sym)
+@deftypefnx {Метод класса @code{mglData}} @code{void} NormSl (@code{mreal} v1=@code{0}, @code{mreal} v2=@code{1}, @code{char} dir=@code{'z'}, @code{bool} keep_en=@code{true}, @code{bool} sym=@code{false})
+@deftypefnx {Функция С} @code{void} mgl_data_norm_slice (@code{HMDT} dat, @code{mreal} v1, @code{mreal} v2, @code{char} dir, @code{int} keep_en, @code{int} sym)
@end ifclear
Нормирует данные срез-за-срезом в выбранном направлении @var{dir} в интервал [@var{v1},@var{v2}]. Если @var{sym}=@code{true}, то используется симметричный интервал [-max(|v1|,|v2|), max(|v1|,|v2|)]. Если @var{keep}=@code{true}, то максимальное значение k-го среза ограничено величиной
@iftex
@end ifnottex
@end deftypefn
-
@c ------------------------------------------------------------------
+@external
@node Interpolation, Data information, Data changing, Data processing
@section Интерполяция
Однако, есть специальные и более быстрые функции при использовании других языков (C/C++/Fortran/Python/...).
@cindex Spline
-@deftypefn {Method on @code{mglData}} @code{float} Spline (@code{float} x, @code{float} y=@code{0}, @code{float} z=@code{0}) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_spline (@code{HCDT} dat, @code{float} x, @code{float} y, @code{float} z)
+@deftypefn {Метод класса @code{mglData}} @code{mreal} Spline (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_spline (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z)
Интерполирует данные кубическим сплайном в точке @var{x} в [0...nx-1], @var{y} в [0...ny-1], @var{z} в [0...nz-1].
@end deftypefn
@cindex Spline1
-@deftypefn {Method on @code{mglData}} @code{float} Spline1 (@code{float} x, @code{float} y=@code{0}, @code{float} z=@code{0}) @code{const}
+@deftypefn {Метод класса @code{mglData}} @code{mreal} Spline1 (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const}
Интерполирует данные кубическим сплайном в точке @var{x}, @var{y}, @var{z}, где координаты полагаются в интервале [0, 1].
@end deftypefn
@cindex Linear
-@deftypefn {Method on @code{mglData}} @code{float} Linear (@code{float} x, @code{float} y=@code{0}, @code{float} z=@code{0}) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_linear (@code{HCDT} dat, @code{float} x, @code{float} y, @code{float} z)
+@deftypefn {Метод класса @code{mglData}} @code{mreal} Linear (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_linear (@code{HCDT} dat, @code{mreal} x, @code{mreal} y, @code{mreal} z)
Интерполирует данные линейной функцией в точке @var{x} в [0...nx-1], @var{y} в [0...ny-1], @var{z} в [0...nz-1].
@end deftypefn
@cindex Linear1
-@deftypefn {Method on @code{mglData}} @code{float} Linear1 (@code{float} x, @code{float} y=@code{0}, @code{float} z=@code{0}) @code{const}
+@deftypefn {Метод класса @code{mglData}} @code{mreal} Linear1 (@code{mreal} x, @code{mreal} y=@code{0}, @code{mreal} z=@code{0}) @code{const}
Интерполирует данные линейной функцией в точке @var{x}, @var{y}, @var{z}, где координаты полагаются в интервале [0, 1].
@end deftypefn
@end ifclear
-
@c ------------------------------------------------------------------
+@external
@node Data information, Operators, Interpolation, Data processing
@section Информационные функции
@cindex PrintInfo
-
@anchor{info}
-@deftypefn {MGL command} {} info dat
+@deftypefn {Команда MGL} {} info dat
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{const char *} PrintInfo () @code{const}
-@deftypefnx {Method on @code{mglData}} @code{void} PrintInfo (@code{FILE *}fp) @code{const}
-@deftypefnx {C function} @code{const char *} mgl_data_info (@code{HCDT} dat)
+@deftypefnx {Метод класса @code{mglData}} @code{const char *} PrintInfo () @code{const}
+@deftypefnx {Метод класса @code{mglData}} @code{void} PrintInfo (@code{FILE *}fp) @code{const}
+@deftypefnx {Функция С} @code{const char *} mgl_data_info (@code{HCDT} dat)
@end ifclear
Возвращает строку с информацией о данных (размеры, моменты и пр.) или пишет её в файл. В MGL скрипте печатает её как сообщение.
@end deftypefn
-@deftypefn {MGL command} {} info 'txt'
+@deftypefn {Команда MGL} {} info 'txt'
Печатает строку @var{txt} как сообщение.
@end deftypefn
+@deftypefn {Команда MGL} {} info val
+Печатает значение числа @var{val} как сообщение.
+@end deftypefn
+
@cindex GetNx
@cindex GetNy
@cindex GetNz
@deftypefnx {MGL suffix} {(dat)} .ny
@deftypefnx {MGL suffix} {(dat)} .nz
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{long} GetNx ()
-@deftypefnx {Method on @code{mglData}} @code{long} GetNy ()
-@deftypefnx {Method on @code{mglData}} @code{long} GetNz ()
-@deftypefnx {C function} @code{long} mgl_data_get_nx (@code{HCDT} dat)
-@deftypefnx {C function} @code{long} mgl_data_get_ny (@code{HCDT} dat)
-@deftypefnx {C function} @code{long} mgl_data_get_nz (@code{HCDT} dat)
+@deftypefnx {Метод класса @code{mglData}} @code{long} GetNx ()
+@deftypefnx {Метод класса @code{mglData}} @code{long} GetNy ()
+@deftypefnx {Метод класса @code{mglData}} @code{long} GetNz ()
+@deftypefnx {Функция С} @code{long} mgl_data_get_nx (@code{HCDT} dat)
+@deftypefnx {Функция С} @code{long} mgl_data_get_ny (@code{HCDT} dat)
+@deftypefnx {Функция С} @code{long} mgl_data_get_nz (@code{HCDT} dat)
@end ifclear
Возвращает размер данных в направлении x, y и z соответственно.
@end deftypefn
@anchor{.max}
@deftypefn {MGL suffix} {(dat)} .max
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{float} Maximal () @code{const}
-@deftypefnx {C function} @code{float} mgl_data_max (@code{HCDT} dat)
+@deftypefnx {Метод класса @code{mglData}} @code{mreal} Maximal () @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_max (@code{HCDT} dat)
@end ifclear
Возвращает максимальное значение массива данных.
@end deftypefn
@anchor{.min}
@deftypefn {MGL suffix} {(dat)} .min
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{float} Minimal () @code{const}
-@deftypefnx {C function} @code{float} mgl_data_min (@code{HMDT} dat) @code{const}
+@deftypefnx {Метод класса @code{mglData}} @code{mreal} Minimal () @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_min (@code{HMDT} dat) @code{const}
@end ifclear
Возвращает минимальное значение массива данных.
@end deftypefn
@ifclear UDAV
-@deftypefn {Method on @code{mglData}} @code{float} Minimal (@code{int} &i, @code{int} &j, @code{int} &k) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_min_int (@code{HCDT} dat, @code{int} *i, @code{int} *j, @code{int} *k)
+@deftypefn {Метод класса @code{mglData}} @code{mreal} Minimal (@code{int} &i, @code{int} &j, @code{int} &k) @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_min_int (@code{HCDT} dat, @code{int} *i, @code{int} *j, @code{int} *k)
Возвращает максимальное значение массива данных и сохраняет его положение в переменные @var{i}, @var{j}, @var{k}.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{float} Maximal (@code{int} &i, @code{int} &j, @code{int} &k) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_max_int (@code{HCDT} dat, @code{int} *i, @code{int} *j, @code{int} *k)
+@deftypefn {Метод класса @code{mglData}} @code{mreal} Maximal (@code{int} &i, @code{int} &j, @code{int} &k) @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_max_int (@code{HCDT} dat, @code{int} *i, @code{int} *j, @code{int} *k)
Возвращает минимальное значение массива данных и сохраняет его положение в переменные @var{i}, @var{j}, @var{k}.
@end deftypefn
-@deftypefn {Method on @code{mglData}} @code{float} Minimal (@code{float} &x, @code{float} &y, @code{float} &z) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_min_real (@code{HCDT} dat, @code{float} *x, @code{float} *y, @code{float} *z)
+@deftypefn {Метод класса @code{mglData}} @code{mreal} Minimal (@code{mreal} &x, @code{mreal} &y, @code{mreal} &z) @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_min_real (@code{HCDT} dat, @code{mreal} *x, @code{mreal} *y, @code{mreal} *z)
Возвращает максимальное значение массива данных и его приближенное (интерполированное) положение в переменные @var{x}, @var{y}, @var{z}.
@end deftypefn
@end ifclear
@deftypefnx {MGL suffix} {(dat)} .my
@deftypefnx {MGL suffix} {(dat)} .mz
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{float} Maximal (@code{float} &x, @code{float} &y, @code{float} &z) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_max_real (@code{HCDT} dat, @code{float} *x, @code{float} *y, @code{float} *z)
+@deftypefnx {Метод класса @code{mglData}} @code{mreal} Maximal (@code{mreal} &x, @code{mreal} &y, @code{mreal} &z) @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_max_real (@code{HCDT} dat, @code{mreal} *x, @code{mreal} *y, @code{mreal} *z)
@end ifclear
Возвращает минимальное значение массива данных и его приближенное (интерполированное) положение в переменные @var{x}, @var{y}, @var{z}.
@end deftypefn
@deftypefnx {MGL suffix} {(dat)} .kz
@deftypefnx {MGL suffix} {(dat)} .ka
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{float} Momentum (@code{char} dir, @code{float} &a, @code{float} &w) @code{const}
-@deftypefnx {Method on @code{mglData}} @code{float} Momentum (@code{char} dir, @code{float} &m, @code{float} &w, @code{float} &s, @code{float} &k) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_momentum_val (@code{HCDT} dat, @code{char} dir, @code{float} *a, @code{float} *w, @code{float} *s, @code{float} *k)
+@deftypefnx {Метод класса @code{mglData}} @code{mreal} Momentum (@code{char} dir, @code{mreal} &a, @code{mreal} &w) @code{const}
+@deftypefnx {Метод класса @code{mglData}} @code{mreal} Momentum (@code{char} dir, @code{mreal} &m, @code{mreal} &w, @code{mreal} &s, @code{mreal} &k) @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_momentum_val (@code{HCDT} dat, @code{char} dir, @code{mreal} *a, @code{mreal} *w, @code{mreal} *s, @code{mreal} *k)
@end ifclear
Возвращает нулевой момент (энергию, @math{I=\sum a_i}) и записывает первый (среднее, @math{m = \sum \xi_i a_i/I}), второй (ширину, @math{w^2 = \sum (\xi_i-m)^2 a_i/I}), третий (асимметрия, @math{s = \sum (\xi_i-m)^3 a_i/ I w^3}) и четвёртый моменты (эксцесс, @math{k = \sum (\xi_i-m)^4 a_i / 3 I w^4})). Здесь @math{\xi} -- соответствующая координата если @var{dir} равно @samp{'x'}, @samp{'y'}, @samp{'z'}. В противном случае среднее, ширина, асимметрия, эксцесс равны @math{m = \sum a_i/N}, @math{w^2 = \sum (a_i-m)^2/N} и т.д.
@end deftypefn
@deftypefn {MGL suffix} {(dat)} .fst
@ifclear UDAV
@cindex Find
-@deftypefnx {Method on @code{mglData}} @code{float} Find (@code{const char *}cond, @code{int} &i, @code{int} &j, @code{int} &k) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_first (@code{HCDT} dat, @code{const char *}cond, @code{int} *i, @code{int} *j, @code{int} *k)
+@deftypefnx {Метод класса @code{mglData}} @code{mreal} Find (@code{const char *}cond, @code{int} &i, @code{int} &j, @code{int} &k) @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_first (@code{HCDT} dat, @code{const char *}cond, @code{int} *i, @code{int} *j, @code{int} *k)
@end ifclear
Находит положение (после заданного в @var{i}, @var{j}, @var{k}) первого не нулевого значения формулы @var{cond}. Функция возвращает найденное значение и записывает его положение в @var{i}, @var{j}, @var{k}.
@end deftypefn
@deftypefn {MGL suffix} {(dat)} .lst
@ifclear UDAV
@cindex Last
-@deftypefnx {Method on @code{mglData}} @code{float} Last (@code{const char *}cond, @code{int} &i, @code{int} &j, @code{int} &k) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_last (@code{HCDT} dat, @code{const char *}cond, @code{int} *i, @code{int} *j, @code{int} *k)
+@deftypefnx {Метод класса @code{mglData}} @code{mreal} Last (@code{const char *}cond, @code{int} &i, @code{int} &j, @code{int} &k) @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_last (@code{HCDT} dat, @code{const char *}cond, @code{int} *i, @code{int} *j, @code{int} *k)
@end ifclear
Находит положение (перед заданного в @var{i}, @var{j}, @var{k}) последнего не нулевого значения формулы @var{cond}. Функция возвращает найденное значение и записывает его положение в @var{i}, @var{j}, @var{k}.
@end deftypefn
@ifclear UDAV
-@deftypefn {Method on @code{mglData}} @code{int} Find (@code{const char *}cond, @code{char} dir, @code{int} i=@code{0}, @code{int} j=@code{0}, @code{int} k=@code{0}) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_find (@code{HCDT} dat, @code{const char *}cond, @code{int} i, @code{int} j, @code{int} k)
+@deftypefn {Метод класса @code{mglData}} @code{int} Find (@code{const char *}cond, @code{char} dir, @code{int} i=@code{0}, @code{int} j=@code{0}, @code{int} k=@code{0}) @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_find (@code{HCDT} dat, @code{const char *}cond, @code{int} i, @code{int} j, @code{int} k)
Возвращает положение первого в направлении @var{dir} не нулевого значения формулы @var{cond}. Поиск начинается с точки @{i,j,k@}.
@end deftypefn
@cindex FindAny
-@deftypefn {Method on @code{mglData}} @code{bool} FindAny (@code{const char *}cond) @code{const}
-@deftypefnx {C function} @code{float} mgl_data_find_any (@code{HCDT} dat, @code{const char *}cond)
+@deftypefn {Метод класса @code{mglData}} @code{bool} FindAny (@code{const char *}cond) @code{const}
+@deftypefnx {Функция С} @code{mreal} mgl_data_find_any (@code{HCDT} dat, @code{const char *}cond)
Определяет есть ли хоть одно значение массива, удовлетворяющее условию @var{cond}.
@end deftypefn
@end ifclear
@end deftypefn
-
@c ------------------------------------------------------------------
+@external
@node Operators, Global functions, Data information, Data processing
@section Операторы
-@deftypefn {MGL command} {} copy @sc{dat} dat2 ['eq'='']
+@deftypefn {Команда MGL} {} copy @sc{dat} dat2 ['eq'='']
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} operator= (@code{const mglData &}d)
+@deftypefnx {Метод класса @code{mglData}} @code{void} operator= (@code{const mglData &}d)
@end ifclear
Копирует данные из другого экземпляра.
@end deftypefn
-@deftypefn {MGL command} {} copy dat @code{val}
+@deftypefn {Команда MGL} {} copy dat @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{float}} @code{void} operator= (@code{float} val)
+@deftypefnx {Метод класса @code{mreal}} @code{void} operator= (@code{mreal} val)
@end ifclear
Устанавливает все значения массива равными @var{val}.
@end deftypefn
@anchor{multo}
-@deftypefn {MGL command} {} multo dat dat2
-@deftypefnx {MGL command} {} multo dat @code{val}
+@deftypefn {Команда MGL} {} multo dat dat2
+@deftypefnx {Команда MGL} {} multo dat @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} operator*= (@code{const mglData &}d)
-@deftypefnx {Method on @code{mglData}} @code{void} operator*= (@code{float} d)
-@deftypefnx {C function} @code{void} mgl_data_mul_dat (@code{HMDT} dat, @code{HCDT} d)
-@deftypefnx {C function} @code{void} mgl_data_mul_num (@code{HMDT} dat, @code{float} d)
+@deftypefnx {Метод класса @code{mglData}} @code{void} operator*= (@code{const mglData &}d)
+@deftypefnx {Метод класса @code{mglData}} @code{void} operator*= (@code{mreal} d)
+@deftypefnx {Функция С} @code{void} mgl_data_mul_dat (@code{HMDT} dat, @code{HCDT} d)
+@deftypefnx {Функция С} @code{void} mgl_data_mul_num (@code{HMDT} dat, @code{mreal} d)
@end ifclear
Поэлементно умножает на массив @var{d} или на число @var{val}.
@end deftypefn
@anchor{divto}
-@deftypefn {MGL command} {} divto dat dat2
-@deftypefnx {MGL command} {} divto dat @code{val}
+@deftypefn {Команда MGL} {} divto dat dat2
+@deftypefnx {Команда MGL} {} divto dat @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} operator/= (@code{const mglData &}d)
-@deftypefnx {Method on @code{mglData}} @code{void} operator/= (@code{float} d)
-@deftypefnx {C function} @code{void} mgl_data_div_dat (@code{HMDT} dat, @code{HCDT} d)
-@deftypefnx {C function} @code{void} mgl_data_div_num (@code{HMDT} dat, @code{float} d)
+@deftypefnx {Метод класса @code{mglData}} @code{void} operator/= (@code{const mglData &}d)
+@deftypefnx {Метод класса @code{mglData}} @code{void} operator/= (@code{mreal} d)
+@deftypefnx {Функция С} @code{void} mgl_data_div_dat (@code{HMDT} dat, @code{HCDT} d)
+@deftypefnx {Функция С} @code{void} mgl_data_div_num (@code{HMDT} dat, @code{mreal} d)
@end ifclear
Поэлементно делит на массив @var{d} или на число @var{val}.
@end deftypefn
@anchor{addto}
-@deftypefn {MGL command} {} addto dat dat2
-@deftypefnx {MGL command} {} addto dat @code{val}
+@deftypefn {Команда MGL} {} addto dat dat2
+@deftypefnx {Команда MGL} {} addto dat @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} operator+= (@code{const mglData &}d)
-@deftypefnx {Method on @code{mglData}} @code{void} operator+= (@code{float} d)
-@deftypefnx {C function} @code{void} mgl_data_add_dat (@code{HMDT} dat, @code{HCDT} d)
-@deftypefnx {C function} @code{void} mgl_data_add_num (@code{HMDT} dat, @code{float} d)
+@deftypefnx {Метод класса @code{mglData}} @code{void} operator+= (@code{const mglData &}d)
+@deftypefnx {Метод класса @code{mglData}} @code{void} operator+= (@code{mreal} d)
+@deftypefnx {Функция С} @code{void} mgl_data_add_dat (@code{HMDT} dat, @code{HCDT} d)
+@deftypefnx {Функция С} @code{void} mgl_data_add_num (@code{HMDT} dat, @code{mreal} d)
@end ifclear
Поэлементно прибавляет @var{d} или число @var{val}.
@end deftypefn
@anchor{subto}
-@deftypefn {MGL command} {} subto dat dat2
-@deftypefnx {MGL command} {} subto dat @code{val}
+@deftypefn {Команда MGL} {} subto dat dat2
+@deftypefnx {Команда MGL} {} subto dat @code{val}
@ifclear UDAV
-@deftypefnx {Method on @code{mglData}} @code{void} operator-= (@code{const mglData &}d)
-@deftypefnx {Method on @code{mglData}} @code{void} operator-= (@code{float} d)
-@deftypefnx {C function} @code{void} mgl_data_sub_dat (@code{HMDT} dat, @code{HCDT} d)
-@deftypefnx {C function} @code{void} mgl_data_sub_num (@code{HMDT} dat, @code{float} d)
+@deftypefnx {Метод класса @code{mglData}} @code{void} operator-= (@code{const mglData &}d)
+@deftypefnx {Метод класса @code{mglData}} @code{void} operator-= (@code{mreal} d)
+@deftypefnx {Функция С} @code{void} mgl_data_sub_dat (@code{HMDT} dat, @code{HCDT} d)
+@deftypefnx {Функция С} @code{void} mgl_data_sub_num (@code{HMDT} dat, @code{mreal} d)
@end ifclear
Поэлементно вычитает @var{d} или число @var{val}.
@end deftypefn
@ifclear UDAV
@deftypefn {Library Function} mglData operator+ (@code{const mglData &}a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator+ (@code{float} a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator+ (@code{const mglData &}a, @code{float} b)
+@deftypefnx {Library Function} mglData operator+ (@code{mreal} a, @code{const mglData &}b)
+@deftypefnx {Library Function} mglData operator+ (@code{const mglData &}a, @code{mreal} b)
Возвращает поэлементную сумму данных.
@end deftypefn
@deftypefn {Library Function} mglData operator- (@code{const mglData &}a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator- (@code{float} a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator- (@code{const mglData &}a, @code{float} b)
+@deftypefnx {Library Function} mglData operator- (@code{mreal} a, @code{const mglData &}b)
+@deftypefnx {Library Function} mglData operator- (@code{const mglData &}a, @code{mreal} b)
Возвращает поэлементную разность данных.
@end deftypefn
@deftypefn {Library Function} mglData operator* (@code{const mglData &}a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator* (@code{float} a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator* (@code{const mglData &}a, @code{float} b)
+@deftypefnx {Library Function} mglData operator* (@code{mreal} a, @code{const mglData &}b)
+@deftypefnx {Library Function} mglData operator* (@code{const mglData &}a, @code{mreal} b)
Возвращает поэлементное произведение данных.
@end deftypefn
@deftypefn {Library Function} mglData operator/ (@code{const mglData &}a, @code{const mglData &}b)
-@deftypefnx {Library Function} mglData operator/ (@code{const mglData &}a, @code{float} b)
+@deftypefnx {Library Function} mglData operator/ (@code{const mglData &}a, @code{mreal} b)
Возвращает поэлементное деление данных.
@end deftypefn
@end ifclear
@c ------------------------------------------------------------------
+@external
@node Global functions, Evaluate expression, Operators, Data processing
@section Глобальные функции
@end ifclear
@anchor{transform}
-@deftypefn {MGL command} {} transform @sc{dat} 'type' real imag
+@deftypefn {Команда MGL} {} transform @sc{dat} 'type' real imag
@ifclear UDAV
@deftypefnx {Global function} @code{mglData} mglTransform (@code{const mglData &}real, @code{const mglData &}imag, @code{const char *}type)
-@deftypefnx {C function} @code{HMDT} mgl_transform (@code{HCDT} real, @code{HCDT} imag, @code{const char *}type)
+@deftypefnx {Функция С} @code{HMDT} mgl_transform (@code{HCDT} real, @code{HCDT} imag, @code{const char *}type)
@end ifclear
Выполняет интегральное преобразование комплексных данных @var{real}, @var{imag} в выбранном направлении и возвращает модуль результата. Порядок и тип преобразований задается строкой @var{type}: первый символ для x-направления, второй для y-направления, третий для z-направления. Возможные символы: @samp{f} -- прямое преобразование Фурье, @samp{i} -- обратное преобразование Фурье, @samp{s} -- синус преобразование, @samp{c} -- косинус преобразование, @samp{h} -- преобразование Ханкеля, @samp{n} или @samp{ } -- нет преобразования.
@end deftypefn
@anchor{transforma}
-@deftypefn {MGL command} {} transforma @sc{dat} 'type' ampl phase
+@deftypefn {Команда MGL} {} transforma @sc{dat} 'type' ampl phase
@ifclear UDAV
@deftypefnx {Global function} @code{mglData} mglTransformA @code{const mglData &}ampl, @code{const mglData &}phase, @code{const char *}type)
-@deftypefnx {C function} @code{HMDT} mgl_transform_a @code{HCDT} ampl, @code{HCDT} phase, @code{const char *}type)
+@deftypefnx {Функция С} @code{HMDT} mgl_transform_a @code{HCDT} ampl, @code{HCDT} phase, @code{const char *}type)
@end ifclear
Аналогично предыдущему с заданными амплитудой @var{ampl} и фазой @var{phase} комплексных чисел.
@end deftypefn
@anchor{fourier}
-@deftypefn {MGL command} {} fourier reDat imDat 'dir'
+@deftypefn {Команда MGL} {} fourier reDat imDat 'dir'
@ifclear UDAV
@deftypefnx {Global function} @code{void} mglFourier @code{const mglData &}re, @code{const mglData &}im, @code{const char *}dir)
-@deftypefnx {C function} @code{void} mgl_data_fourier @code{HCDT} re, @code{HCDT} im, @code{const char *}dir)
+@deftypefnx {Функция С} @code{void} mgl_data_fourier @code{HCDT} re, @code{HCDT} im, @code{const char *}dir)
@end ifclear
Выполняет Фурье преобразование для комплексных данных @var{re}+i*@var{im} в направлениях @var{dir}. Результат помещается обратно в массивы @var{re} и @var{im}.
@end deftypefn
@anchor{stfad}
-@deftypefn {MGL command} {} stfad @sc{res} real imag @code{dn} ['dir'='x']
+@deftypefn {Команда MGL} {} stfad @sc{res} real imag @code{dn} ['dir'='x']
@ifclear UDAV
@deftypefnx {Global function} @code{mglData} mglSTFA (@code{const mglData &}real, @code{const mglData &}imag, @code{int} dn, @code{char} dir=@code{'x'})
-@deftypefnx {C function} @code{HMDT} mgl_data_stfa (@code{HCDT} real, @code{HCDT} imag, @code{int} dn,@code{char} dir)
+@deftypefnx {Функция С} @code{HMDT} mgl_data_stfa (@code{HCDT} real, @code{HCDT} imag, @code{int} dn,@code{char} dir)
@end ifclear
Выполняет оконное преобразование Фурье длиной @var{dn} для комплексных данных @var{real}, @var{imag} и возвращает модуль результата. Например, для @var{dir}=@samp{x} результат будет иметь размер @{int(nx/dn), dn, ny@} и будет равен @math{res[i,j,k]=|\sum_d^dn exp(I*j*d)*(real[i*dn+d,k]+I*imag[i*dn+d,k])|/dn}.
@end deftypefn
@anchor{pde}
-@deftypefn {MGL command} {} pde @sc{res} 'ham' ini_re ini_im [@code{dz=0.1 k0=100}]
+@deftypefn {Команда MGL} {} pde @sc{res} 'ham' ini_re ini_im [@code{dz=0.1 k0=100}]
@ifclear UDAV
-@deftypefnx {Global function} @code{mglData} mglPDE (@code{HMGL} gr, @code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{float} dz=@code{0.1}, @code{float} k0=@code{100}, @code{const char *}opt=@code{""})
-@deftypefnx {C function} @code{HMDT} mgl_pde_solve (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{float} dz, @code{float} k0, @code{const char *}opt)
+@deftypefnx {Global function} @code{mglData} mglPDE (@code{HMGL} gr, @code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{mreal} dz=@code{0.1}, @code{mreal} k0=@code{100}, @code{const char *}opt=@code{""})
+@deftypefnx {Функция С} @code{HMDT} mgl_pde_solve (@code{HMGL} gr, @code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{mreal} dz, @code{mreal} k0, @code{const char *}opt)
@end ifclear
-Решает уравнение в частных производных du/dz = i*k0*@var{ham}(p,q,x,y,z,|u|)[u], где p=-i/k0*d/dx, q=-i/k0*d/dy -- псевдо-дифференциальные операторы. Параметры @var{ini_re}, @var{ini_im} задают начальное распределение поля. Координаты в уравнении и в решении полагаются в диапазоне осей координат. Замечу, что внутри этот диапазон увеличивается в 3/2 раза для уменьшения отражения от границ расчетного интервала. Параметр @var{dz} задает шаг по эволюционной координате z. В данный момент использован упрощенный алгоритм, когда все ``смешанные'' члена (типа @samp{x*p}->x*d/dx) исключаются. Например, в 2D случае это функции типа @math{ham = f(p,z) + g(x,z,u)}. При этом допускаются коммутирующие комбинации (типа @samp{x*q}->x*d/dy). Переменная @samp{u} используется для обозначения амплитуды поля |u|. Это позволяет решать нелинейные задачи -- например, нелинейное уравнение Шредингера @code{ham='p^2+q^2-u^2'}. Также можно указать мнимую часть для поглощения (типа @code{ham = 'p^2+i*x*(x>0)'}), но только если зависимость от @samp{i} линейная, т.е. @math{ham = hre+i*him}. @sref{PDE sample}
+Решает уравнение в частных производных du/dz = i*k0*@var{ham}(p,q,x,y,z,|u|)[u], где p=-i/k0*d/dx, q=-i/k0*d/dy -- псевдо-дифференциальные операторы. Параметры @var{ini_re}, @var{ini_im} задают начальное распределение поля. Координаты в уравнении и в решении полагаются в диапазоне осей координат. Замечу, что внутри этот диапазон увеличивается в 3/2 раза для уменьшения отражения от границ расчетного интервала. Параметр @var{dz} задает шаг по эволюционной координате z. В данный момент использован упрощенный алгоритм, когда все ``смешанные'' члена (типа @samp{x*p}->x*d/dx) исключаются. Например, в 2D случае это функции типа @math{ham = f(p,z) + g(x,z,u)}. При этом допускаются коммутирующие комбинации (типа @samp{x*q}->x*d/dy). Переменная @samp{u} используется для обозначения амплитуды поля |u|. Это позволяет решать нелинейные задачи -- например, нелинейное уравнение Шредингера @code{ham='p^2+q^2-u^2'}. Также можно указать мнимую часть для поглощения (типа @code{ham = 'p^2+i*x*(x>0)'}), но только если зависимость от @samp{i} линейная, т.е. @math{ham = hre+i*him}. @sref{PDE solving hints}
@end deftypefn
@anchor{ray}
-@deftypefn {MGL command} {} ray @sc{res} 'ham' @code{x0 y0 z0 p0 q0 v0 [dt=0.1 tmax=10]}
+@deftypefn {Команда MGL} {} ray @sc{res} 'ham' @code{x0 y0 z0 p0 q0 v0 [dt=0.1 tmax=10]}
@ifclear UDAV
-@deftypefnx {Global function} @code{mglData} mglRay (@code{const char *}ham, @code{mglPoint} r0, @code{mglPoint} p0, @code{float} dt=@code{0.1}, @code{float} tmax=@code{10})
-@deftypefnx {C function} @code{HMDT} mgl_ray_trace (@code{const char *}ham, @code{float} x0, @code{float} y0, @code{float} z0, @code{float} px, @code{float} py, @code{float} pz, @code{float} dt, @code{float} tmax)
+@deftypefnx {Global function} @code{mglData} mglRay (@code{const char *}ham, @code{mglPoint} r0, @code{mglPoint} p0, @code{mreal} dt=@code{0.1}, @code{mreal} tmax=@code{10})
+@deftypefnx {Функция С} @code{HMDT} mgl_ray_trace (@code{const char *}ham, @code{mreal} x0, @code{mreal} y0, @code{mreal} z0, @code{mreal} px, @code{mreal} py, @code{mreal} pz, @code{mreal} dt, @code{mreal} tmax)
@end ifclear
-Решает систему геометрооптических уравнений d@emph{r}/dt = d @var{ham}/d@emph{p}, d@emph{p}/dt = -d @var{ham}/d@emph{r}. Это гамильтоновы уравнения для траектории частицы в 3D случае. Гамильтониан @var{ham} может зависеть от координат @samp{x}, @samp{y}, @samp{z}, импульсов @samp{p}=px, @samp{q}=py, @samp{v}=pz и времени @samp{t}: @math{ham = H(x,y,z,p,q,v,t)}. Начальная точка (при @code{t=0}) задается переменными @{@var{x0}, @var{y0}, @var{z0}, @var{p0}, @var{q0}, @var{v0}@}. Параметры @var{dt} и @var{tmax} задают шаг и максимальное время интегрирования. Результат -- массив @{x,y,z,p,q,v,t@} с размером @{7 * int(@var{tmax}/@var{dt}+1) @}. @sref{Beam tracing sample}
+Решает систему геометрооптических уравнений d@emph{r}/dt = d @var{ham}/d@emph{p}, d@emph{p}/dt = -d @var{ham}/d@emph{r}. Это гамильтоновы уравнения для траектории частицы в 3D случае. Гамильтониан @var{ham} может зависеть от координат @samp{x}, @samp{y}, @samp{z}, импульсов @samp{p}=px, @samp{q}=py, @samp{v}=pz и времени @samp{t}: @math{ham = H(x,y,z,p,q,v,t)}. Начальная точка (при @code{t=0}) задается переменными @{@var{x0}, @var{y0}, @var{z0}, @var{p0}, @var{q0}, @var{v0}@}. Параметры @var{dt} и @var{tmax} задают шаг и максимальное время интегрирования. Результат -- массив @{x,y,z,p,q,v,t@} с размером @{7 * int(@var{tmax}/@var{dt}+1) @}.
@end deftypefn
@anchor{qo2d}
-@deftypefn {MGL command} {} qo2d @sc{res} 'ham' ini_re ini_im ray [@code{r=1 k0=100} xx yy]
+@deftypefn {Команда MGL} {} qo2d @sc{res} 'ham' ini_re ini_im ray [@code{r=1 k0=100} xx yy]
@ifclear UDAV
-@deftypefnx {Global function} @code{mglData} mglQO2d (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{const mglData &}ray, @code{float} r=@code{1}, @code{float} k0=@code{100}, @code{mglData *}xx=@code{0}, @code{mglData *}yy=@code{0})
-@deftypefnx {Global function} @code{mglData} mglQO2d (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{const mglData &}ray, @code{mglData &}xx, @code{mglData &}yy, @code{float} r=@code{1}, @code{float} k0=@code{100})
-@deftypefnx {C function} @code{HMDT} mgl_qo2d_solve (@code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{float} r, @code{float} k0, @code{HMDT} xx, @code{HMDT} yy)
+@deftypefnx {Global function} @code{mglData} mglQO2d (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{const mglData &}ray, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100}, @code{mglData *}xx=@code{0}, @code{mglData *}yy=@code{0})
+@deftypefnx {Global function} @code{mglData} mglQO2d (@code{const char *}ham, @code{const mglData &}ini_re, @code{const mglData &}ini_im, @code{const mglData &}ray, @code{mglData &}xx, @code{mglData &}yy, @code{mreal} r=@code{1}, @code{mreal} k0=@code{100})
+@deftypefnx {Функция С} @code{HMDT} mgl_qo2d_solve (@code{const char *}ham, @code{HCDT} ini_re, @code{HCDT} ini_im, @code{HCDT} ray, @code{mreal} r, @code{mreal} k0, @code{HMDT} xx, @code{HMDT} yy)
@end ifclear
-Решает уравнение в частных производных du/dt = i*k0*@var{ham}(p,q,x,y,|u|)[u] в сопровождающей системе координат, где p=-i/k0*d/dx, q=-i/k0*d/dy -- псевдо-дифференциальные операторы. Параметры @var{ini_re}, @var{ini_im} задают начальное распределение поля. Параметр @var{ray} задает опорный луч для сопровождающей системы координат. Можно использовать луч найденный с помощью @code{mglRay()}. Опорный луч должен быть достаточно гладкий, чтобы система координат была однозначной и для исключения ошибок интегрирования. Если массивы @var{xx} и @var{yy} указаны, то в них записываются декартовы координаты для каждой точки найденного решения. См. также @code{mglPDE()}. @sref{Beam tracing sample}
+Решает уравнение в частных производных du/dt = i*k0*@var{ham}(p,q,x,y,|u|)[u] в сопровождающей системе координат, где p=-i/k0*d/dx, q=-i/k0*d/dy -- псевдо-дифференциальные операторы. Параметры @var{ini_re}, @var{ini_im} задают начальное распределение поля. Параметр @var{ray} задает опорный луч для сопровождающей системы координат. Можно использовать луч найденный с помощью @code{mglRay()}. Опорный луч должен быть достаточно гладкий, чтобы система координат была однозначной и для исключения ошибок интегрирования. Если массивы @var{xx} и @var{yy} указаны, то в них записываются декартовы координаты для каждой точки найденного решения. См. также @code{mglPDE()}. @sref{PDE solving hints}
@end deftypefn
@anchor{jacobian}
-@deftypefn {MGL command} {} jacobian @sc{res} xdat ydat [zdat]
+@deftypefn {Команда MGL} {} jacobian @sc{res} xdat ydat [zdat]
@ifclear UDAV
@deftypefnx {Global function} @code{mglData} mglJacobian (@code{const mglData &}x, @code{const mglData &}y)
@deftypefnx {Global function} @code{mglData} mglJacobian (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z)
-@deftypefnx {C function} @code{HMDT} mgl_jacobian_2d (@code{HCDT} x, @code{HCDT} y)
-@deftypefnx {C function} @code{HMDT} mgl_jacobian_3d (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z)
+@deftypefnx {Функция С} @code{HMDT} mgl_jacobian_2d (@code{HCDT} x, @code{HCDT} y)
+@deftypefnx {Функция С} @code{HMDT} mgl_jacobian_3d (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z)
@end ifclear
Вычисляет якобиан преобразования @{i,j,k@} в @{@var{x},@var{y},@var{z}@}, где координаты @{i,j,k@} полагаются нормированными в интервал [0,1]. Якобиан находится по формуле det||@math{dr_\alpha/d\xi_\beta}||, где @math{r}=@{@var{x},@var{y},@var{z}@} и @math{\xi}=@{i,j,k@}. Все размерности всех массивов должны быть одинаковы. Данные должны быть трехмерными если указаны все 3 массива @{@var{x},@var{y},@var{z}@} или двумерными если только 2 массива @{@var{x},@var{y}@}.
@end deftypefn
@anchor{triangulation}
-@deftypefn {MGL command} {} triangulation @sc{res} xdat ydat [zdat]
+@deftypefn {Команда MGL} {} triangulation @sc{res} xdat ydat [zdat]
+@c @deftypefn {Команда MGL} {} triangulation @sc{res} xdat ydat [zdat]
@ifclear UDAV
@deftypefnx {Global function} @code{mglData} mglTriangulation (@code{const mglData &}x, @code{const mglData &}y)
@deftypefnx {Global function} @code{mglData} mglTriangulation (@code{const mglData &}x, @code{const mglData &}y, @code{const mglData &}z)
-@deftypefnx {C function} @code{HMDT} mgl_triangulation_2d (@code{HCDT} x, @code{HCDT} y)
-@deftypefnx {C function} @code{HMDT} mgl_triangulation_3d (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z)
+@deftypefnx {Функция С} @code{HMDT} mgl_triangulation_2d (@code{HCDT} x, @code{HCDT} y)
+@deftypefnx {Функция С} @code{HMDT} mgl_triangulation_3d (@code{HCDT} x, @code{HCDT} y, @code{HCDT} z)
@end ifclear
Выполняет триангуляцию для произвольно расположенных точек с координатами @{@var{x},@var{y},@var{z}@} (т.е. находит треугольники, соединяющие точки). Первая размерность всех массивов должна быть одинакова @code{x.nx=y.nx=z.nx}. Получившийся массив можно использовать в @ref{triplot} или @ref{tricont} для визуализации реконструированной поверхности.
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Evaluate expression, , Global functions, Data processing
@section Вычисление выражений
@ifclear UDAV
В MathGL есть специальный класс @code{mglExpr} для вычисления формул заданных строкой. Класс определён в @code{#include <mgl2/mgl.h>}. При создании класса происходит разбор формулы в древовидную структуру. А при вычислении только выполняется достаточно быстрый обход по дереву. В данный момент нет различия между верхним и нижним регистром. Если аргумент какой-либо функции лежит вне её области определения, то возвращается NaN. @xref{Textual formulas}.
-@deftypefn {Constructor on @code{mglExpr}} @code{} mglExpr (@code{const char *}expr)
-@deftypefnx {C function} @code{HMEX} mgl_create_expr (@code{const char *}expr)
+@deftypefn {Конструктор класса @code{mglExpr}} @code{} mglExpr (@code{const char *}expr)
+@deftypefnx {Функция С} @code{HMEX} mgl_create_expr (@code{const char *}expr)
Разбирает формулу @var{expr} и создает древовидную структуру, содержащую последовательность вызова функций и операторов для последующего быстрого вычисления формулы с помощью функций @code{Calc()} и/или @code{CalcD()}.
@end deftypefn
@deftypefn {Destructor on @code{mglExpr}} @code{} ~mglExpr ()
-@deftypefnx {C function} @code{HMEX} mgl_delete_expr (@code{HMEX} ex)
+@deftypefnx {Функция С} @code{HMEX} mgl_delete_expr (@code{HMEX} ex)
Удаляет объект типа @code{mglExpr}.
@end deftypefn
-@deftypefn {Method on @code{mglExpr}} @code{float} Eval (@code{float} x, @code{float} y, @code{float} z)
-@deftypefnx {C function} @code{float} mgl_expr_eval (@code{HMEX} ex, @code{float} x, @code{float} y, @code{float} z)
+@deftypefn {Метод класса @code{mglExpr}} @code{mreal} Eval (@code{mreal} x, @code{mreal} y, @code{mreal} z)
+@deftypefnx {Функция С} @code{mreal} mgl_expr_eval (@code{HMEX} ex, @code{mreal} x, @code{mreal} y, @code{mreal} z)
Вычисляет значение формулы для @code{'x','r'}=@var{x}, @code{'y','n'}=@var{y}, @code{'z','t'}=@var{z}, @code{'a','u'}=@var{u}.
@end deftypefn
-@deftypefn {Method on @code{mglExpr}} @code{float} Eval (@code{float} var[26])
-@deftypefnx {C function} @code{float} mgl_expr_eval_v (@code{HMEX} ex, @code{float *}var)
+@deftypefn {Метод класса @code{mglExpr}} @code{mreal} Eval (@code{mreal} var[26])
+@deftypefnx {Функция С} @code{mreal} mgl_expr_eval_v (@code{HMEX} ex, @code{mreal *}var)
Вычисляет значение формулы для переменных в массиве @var{var}[0,...,'z'-'a'].
@end deftypefn
-@deftypefn {Method on @code{mglExpr}} @code{float} Diff (@code{char} dir, @code{float} x, @code{float} y, @code{float} z)
-@deftypefnx {C function} @code{float} mgl_expr_diff (@code{HMEX} ex, @code{char} dir, @code{float} x, @code{float} y, @code{float} z)
+@deftypefn {Метод класса @code{mglExpr}} @code{mreal} Diff (@code{char} dir, @code{mreal} x, @code{mreal} y, @code{mreal} z)
+@deftypefnx {Функция С} @code{mreal} mgl_expr_diff (@code{HMEX} ex, @code{char} dir, @code{mreal} x, @code{mreal} y, @code{mreal} z)
Вычисляет производную от формулы по переменной @var{dir} для @code{'x','r'}=@var{x}, @code{'y','n'}=@var{y}, @code{'z','t'}=@var{z}, @code{'a','u'}=@var{u}.
@end deftypefn
-@deftypefn {Method on @code{mglExpr}} @code{float} Diff (@code{char} dir, @code{float} var[26])
-@deftypefnx {C function} @code{float} mgl_expr_diff_v (@code{HMEX} ex, @code{char} dir, @code{float *}var)
+@deftypefn {Метод класса @code{mglExpr}} @code{mreal} Diff (@code{char} dir, @code{mreal} var[26])
+@deftypefnx {Функция С} @code{mreal} mgl_expr_diff_v (@code{HMEX} ex, @code{char} dir, @code{mreal *}var)
Вычисляет производную от формулы по переменной @var{dir} для переменных в массиве @var{var}[0,...,'z'-'a'].
@end deftypefn
@end ifclear
+
+@external
+
\input texinfo
@setfilename mathgl_en.info
-@set VERSION 2.0
+@set VERSION 2.0.3
@settitle MathGL @value{VERSION}
@syncodeindex pg cp
@comment %**end of header
* Index::
@end menu
+@ifhtml
+@macro external {}
+@html
+<!--LiveInternet counter--><script type="text/javascript"><!--
+document.write("<a href='http://www.liveinternet.ru/click' "+
+"target=_blank><img src='http://counter.yadro.ru/hit?t12.2;r"+
+escape(document.referrer)+((typeof(screen)=="undefined")?"":
+";s"+screen.width+"*"+screen.height+"*"+(screen.colorDepth?
+screen.colorDepth:screen.pixelDepth))+";u"+escape(document.URL)+
+";"+Math.random()+
+"' alt='' title='LiveInternet: number of views during 24"+
+" hours, number of visitors during 24 hours and during today' "+
+"border=0 width=88 height=31><\/a>")//--></script><!--/LiveInternet-->
+
+<a target=_blank href="http://sourceforge.net"><img src="http://sflogo.sourceforge.net/sflogo.php?group_id=152187&type=2" alt="SourceForge.net Logo" border="0" height="37" width="125"></a>
+
+<a target=_blank href="http://www.thefreecountry.com/"> <img src="http://www.thefreecountry.com/images/tfc88x31green.gif" alt="thefreecountry.com: Free Programmers' Resources, Free Webmasters' Resources, Free Security Resources, Free Software" border="0" height="31" width="88"></a>
+
+<a target=_blank href="http://sourceforge.net/donate/index.php?group_id=152187"><img src="http://images.sourceforge.net/images/project-support.jpg" width="88" height="32" border="0" alt="Support This Project" /> </a>
+@end html
+@end macro
+
@macro fig {fname,text}
@center @image{../\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@center @image{../png/\fname\, 11cm, , \text\, .png}
+@c @center @image{../png/\fname\, 11cm, , \text\. See also @uref{../pdf/\fname\.pdf, U3D PDF} sample, .png}
+@end macro
+@end ifhtml
+
+@ifnothtml
+@macro external {}
+@end macro
+
+@iftex
+@macro fig {fname,text}
+@center @image{\fname\, 11cm, , \text\, .png}
+@end macro
+@macro pfig {fname,text}
+@center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
+@end iftex
-@macro reklama
+@ifnottex
+@macro fig {fname,text}
+@c @center @image{\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@c @center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
+@end ifnottex
+@end ifnothtml
+
@rmacro sref {arg}
@xref{\arg\}, for sample code and picture.
\input texinfo
-@setfilename mathgl_ru.info
-@c @documentlanguage ru
-@documentencoding UTF-8
-@set VERSION 2.0
+@setfilename mathgl_en.info
+@set VERSION 2.0.3
@settitle MathGL @value{VERSION}
@syncodeindex pg cp
@comment %**end of header
@copying
-Это документация для MathGL (версии @value{VERSION}) -- библиотеки классов и функций для построения научной графики. Пожалуйста сообщайте о любых ошибках в этом руководстве на @email{mathgl.abalakin@@gmail.org}.
+This manual is for MathGL (version @value{VERSION}), a collection of classes and routines for scientific plotting. Please report any errors in this manual to @email{mathgl.abalakin@@gmail.org}.
-Copyright @copyright{} 2009 Алексей Балакин.
+Copyright @copyright{} 2008 Alexey Balakin.
@quotation
Permission is granted to copy, distribute and/or modify this document
@titlepage
@title MathGL
-@subtitle версия @value{VERSION}
-@author А.А. Балакин (@uref{http://mathgl.sourceforge.net/})
+@subtitle for version @value{VERSION}
+@author A.A. Balakin (@uref{http://mathgl.sourceforge.net/})
@page
@vskip 0pt plus 1filll
@insertcopying
@node Top
@top MathGL
-Это документация для MathGL (версии @value{VERSION}) -- библиотеки классов и функций для построения научной графики. Пожалуйста сообщайте о любых ошибках в этом руководстве на @email{mathgl.abalakin@@gmail.org}. Дополнительную информацию о MathGL можно найти на домашней странице проекта @uref{http://mathgl.sourceforge.net/}.
+This file documents the Mathematical Graphic Library (MathGL), a collection of classes and routines for scientific plotting. It corresponds to release @value{VERSION} of the library. Please report any errors in this manual to @email{mathgl.abalakin@@gmail.org}. More information about MathGL can be found at the project homepage, @uref{http://mathgl.sourceforge.net/}.
-Copyright @copyright{} 2009 Алексей Балакин.
+Copyright @copyright{} 2008 Alexey A. Balakin.
@quotation
Permission is granted to copy, distribute and/or modify this document
@end menu
@ifhtml
+@macro external {}
+@html
+<!--LiveInternet counter--><script type="text/javascript"><!--
+document.write("<a href='http://www.liveinternet.ru/click' "+
+"target=_blank><img src='http://counter.yadro.ru/hit?t12.2;r"+
+escape(document.referrer)+((typeof(screen)=="undefined")?"":
+";s"+screen.width+"*"+screen.height+"*"+(screen.colorDepth?
+screen.colorDepth:screen.pixelDepth))+";u"+escape(document.URL)+
+";"+Math.random()+
+"' alt='' title='LiveInternet: number of views during 24"+
+" hours, number of visitors during 24 hours and during today' "+
+"border=0 width=88 height=31><\/a>")//--></script><!--/LiveInternet-->
+
+<a target=_blank href="http://sourceforge.net"><img src="http://sflogo.sourceforge.net/sflogo.php?group_id=152187&type=2" alt="SourceForge.net Logo" border="0" height="37" width="125"></a>
+
+<a target=_blank href="http://www.thefreecountry.com/"> <img src="http://www.thefreecountry.com/images/tfc88x31green.gif" alt="thefreecountry.com: Free Programmers' Resources, Free Webmasters' Resources, Free Security Resources, Free Software" border="0" height="31" width="88"></a>
+
+<a target=_blank href="http://sourceforge.net/donate/index.php?group_id=152187"><img src="http://images.sourceforge.net/images/project-support.jpg" width="88" height="32" border="0" alt="Support This Project" /> </a>
+@end html
+@end macro
+
@macro fig {fname,text}
@center @image{../\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@center @image{../png/\fname\, 11cm, , \text\, .png}
+@c @center @image{../png/\fname\, 11cm, , \text\. See also @uref{../pdf/\fname\.pdf, U3D PDF} sample, .png}
+@end macro
@end ifhtml
@ifnothtml
+@macro external {}
+@end macro
+
@iftex
@macro fig {fname,text}
@center @image{\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
@end iftex
@ifnottex
@macro fig {fname,text}
@c @center @image{\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@c @center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
@end ifnottex
@end ifnothtml
@include other_ru.texi
@node TeX-like symbols, Copying This Manual, Other classes, Top
-@appendix Символы TeX
+@appendix TeX-like symbols
@include appendix_ru.texi
@node Copying This Manual, Index, TeX-like symbols, Top
@include fdl.texi
@node Index, , Copying This Manual, Top
-@unnumbered Индекс
+@unnumbered Index
@printindex cp
@end menu
@c ------------------------------------------------------------------
+@external
@node Basic usage, Advanced usage, , Examples
@section Basic usage
Just type it in UDAV and press F5. Also you can save it in text file @samp{test.mgl} and type in the console @code{mgl2png test.mgl} what produce file @samp{test.mgl.png} with resulting picture.
@c ------------------------------------------------------------------
+@external
@node Advanced usage, Data handling, Basic usage, Examples
@section Advanced usage
@end menu
@c ------------------------------------------------------------------
+@external
@node Subplots, Axis and grids, , Advanced usage
@subsection Subplots
Note that several commands can be placed in a string if they are separated by @samp{:} symbol.
-@float
+@mreal
@image{../png/sample1, 7cm}
@caption{Example of several subplots on the single picture.}
-@end float
+@end mreal
@c ------------------------------------------------------------------
+@external
@node Axis and grids, Curvilinear coordinates, Subplots, Advanced usage
@subsection Axis and grids
This example shows the importance of the correct choosing of the number of ticks on axis. If tick step is too small then its text may overlap and becomes unreadable. This code has the example of @code{Label} function. It draws label for axis in specified direction. The text position on axis is specified by third argument of @code{Label} function. If it is positive then then text is drawn near the axis maximum, if negative then the same takes place near the minimum of axis, if zero - then at the center of axis.
-@float
+@mreal
@image{../png/sample2, 7cm}
@caption{Example of setting up axis range and axis ticks.}
-@end float
+@end mreal
@c ------------------------------------------------------------------
+@external
@node Curvilinear coordinates, Text printing example, Axis and grids, Advanced usage
@subsection Curvilinear coordinates
text 0 1.3 1 'spiral'
@end verbatim
-@float
+@mreal
@image{../png/sample3, 7cm}
@caption{Example of curvilinear coordinates}
-@end float
+@end mreal
@c ------------------------------------------------------------------
+@external
@node Text printing example, , Curvilinear coordinates, Advanced usage
@subsection Text printing example
text 0 -1 'It parse TeX: \int \alpha \cdot \sqrt3{sin(\pi x)^2 + \gamma_{i_k}} dx'
@end verbatim
-@float
+@mreal
@image{../png/sample4, 7cm}
@caption{Example of text printing with different font effects}
-@end float
+@end mreal
Another example demonstrate the features of TeX formula parsing.
@verbatim
text 0 0 '\sqrt{\frac{\alpha^{\gamma^2}+\overset 1{\big\infty}}{\sqrt3{2+b}}}', 0, -4
@end verbatim
-@float
+@mreal
@image{../png/samplee, 7cm}
@caption{Example of TeX formula parsing}
-@end float
+@end mreal
@c ------------------------------------------------------------------
+@external
@node Data handling, Data plotting, Advanced usage, Examples
@section Data handling
-@c Class @code{mglData} contains all functions for the data handling in MathGL (@pxref{mglData class}). There are several matters why I use class @code{mglData} but not a single array: it does not depend on type of data (float or double), sizes of data arrays are kept with data, memory working is simpler and safer.
+@c Class @code{mglData} contains all functions for the data handling in MathGL (@pxref{mglData class}). There are several matters why I use class @code{mglData} but not a single array: it does not depend on type of data (mreal or double), sizes of data arrays are kept with data, memory working is simpler and safer.
@menu
* Array creation::
@end menu
@c ------------------------------------------------------------------
+@external
@node Array creation, Change data, , Data handling
@subsection Array creation
@end verbatim
or loaded from file.
-The only non-obvious thing here is using multidimensional arrays in C/C++, i.e. arrays defined like @code{float dat[40][30];}. Since, formaly this arrays element @code{dat[i]} can address the memory in arbitrary place you should use the proper function to convert such arrays to @code{mglData} object. For C++ this is functions like @code{mglData::Set(float **dat, int N1, int N2}. For C this is functions like @code{mgl_data_set_float2(HMDT d, const float **dat, int N1, int N2}. At this, you should keep in mind that @code{nx=N2} and @code{ny=N1} after conversion.
+The only non-obvious thing here is using multidimensional arrays in C/C++, i.e. arrays defined like @code{mreal dat[40][30];}. Since, formaly this arrays element @code{dat[i]} can address the memory in arbitrary place you should use the proper function to convert such arrays to @code{mglData} object. For C++ this is functions like @code{mglData::Set(mreal **dat, int N1, int N2}. For C this is functions like @code{mgl_data_set_mreal2(HMDT d, const mreal **dat, int N1, int N2}. At this, you should keep in mind that @code{nx=N2} and @code{ny=N1} after conversion.
@c ------------------------------------------------------------------
+@external
@node Change data, , Array creation, Data handling
@subsection Change data
text 0.7 1 1.2 '\int {d^2}a/dxdy dx'
@end verbatim
-@float
+@mreal
@image{../png/sample6, 7cm}
@caption{Example of data differentiation and integration}
-@end float
+@end mreal
Data smoothing (function @code{Smooth}) is more interesting and important. This function has 2 main arguments: type of smoothing and its direction. Now 4 methods are supported: @code{0} does nothing for delta=0 or approaches data to zero with the step delta, @code{1} linear averaging by 3 points, @code{2} linear averaging by 5 points, @code{3} quadratic averaging by 5 points. Let me demonstrate it for 1d case:
@verbatim
legend: box
@end verbatim
-@float
+@mreal
@image{../png/sample7, 7cm}
@caption{Example of data smoothing}
-@end float
+@end mreal
Finally one can create new data arrays on base of the existing one: extract slice, row or column of data (@code{SubData}), summarize along some of direction(s) (@code{Sum}), find distribution of data elements (@code{Hist}). Note, that all these functions are not thread-safe because they use static internal variable for output array. In particular, the using of several of them in arguments of the same function will lead to unpredictable result.
@c ------------------------------------------------------------------
+@external
@node Data plotting, Hints, Data handling, Examples
@section Data plotting
@end menu
@c ------------------------------------------------------------------
+@external
@node Plots for 1D data, Plots for 2D data, , Data plotting
@subsection Plots for 1D data
bars x y0 z 'r':box
@end verbatim
-@float
+@mreal
@image{../png/sample8, 7cm}
@caption{Example of 1D data plot}
-@end float
+@end mreal
@c ------------------------------------------------------------------
+@external
@node Plots for 2D data, Plots for 3D data, Plots for 1D data, Data plotting
@subsection Plots for 2D data
@end verbatim
Note, that the previous color scheme is used in last plots because there are no direct specification of the one.
-@float
+@mreal
@image{../png/sample9, 7cm}
@caption{Example of surface plot for 2D data}
-@end float
+@end mreal
Drawing of other 2D plots is analogous. The only peculiarity is the usage of flag @samp{#}. By default this flag switches on the drawing of a grid on plot (@code{grid} or @code{mesh} for plots in plain or in volume). However, for isosurfaces (including surfaces of rotation @code{axial}) this flag switches the face drawing off. Figure becomes wired. The following code gives example of flag @samp{#} using (compare with normal function drawing as in its description):
@verbatim
axial a 'bbcyrr#': box
@end verbatim
-@float
+@mreal
@image{../png/samplea, 7cm}
@caption{Example of 2D data plot with color scheme contained @samp{#} symbol}
-@end float
+@end mreal
@c ------------------------------------------------------------------
+@external
@node Plots for 3D data, Surface transparency, Plots for 2D data, Data plotting
@subsection Plots for 3D data
surf3a b a 'q': box
@end verbatim
-@float
+@mreal
@image{../png/sampleb, 7cm}
@caption{Example of Gaussian beam diffraction (3D data)}
-@end float
+@end mreal
@c ------------------------------------------------------------------
+@external
@node Surface transparency, , Plots for 3D data, Data plotting
@subsection Surface transparency
A ``neon-like'' transparency (@code{transptype 2}) has more interesting look. In this case a surface is the light source (like a lamp on the dark background) and just adds some intensity to the color. At this, the library sets automatically the black color for the background and changes the default line color to white.
As example I shall show the variant of plot from @ref{Plots for 2D data} (grid drawing is disabled) for different types of transparency.
-@float
+@mreal
@image{../png/type0, 7cm}
@caption{Example of @code{TranspType=0}.}
-@end float
-@float
+@end mreal
+@mreal
@image{../png/type1, 7cm}
@caption{Example of @code{TranspType=1}.}
-@end float
-@float
+@end mreal
+@mreal
@image{../png/type2, 7cm}
@caption{Example of @code{TranspType=2}.}
-@end float
+@end mreal
@c ------------------------------------------------------------------
+@external
@node Hints, , Data plotting, Examples
@section Hints
@end menu
@c ------------------------------------------------------------------
+@external
@node ``Compound'' graphics, Two axes in one plot, , Hints
@subsection ``Compound'' graphics
Similarly, one can plot flow thread over density plot of vector field amplitude (this is another amusing plot from Matlab) and so on. The list of compound graphics can be prolonged but I hope that the general idea is clear.
@c ------------------------------------------------------------------
+@external
@node Two axes in one plot, Titles for the plot, ``Compound'' graphics, Hints
@subsection Two axes in one plot
Note, that the first and the second axes look better if being placed in different corners. In the code presented above the first axis is placed in the left-bottom corner, and the second one is placed in the right-top corner.
@c ------------------------------------------------------------------
+@external
@node Titles for the plot, Changing of the color range, Two axes in one plot, Hints
@subsection Titles for the plot
The printing of nice titles for the plot is not so trivial task in general case. The problem is that the rotation and aspect change lead to different looks for titles of different subplots. So, the resulting look is not so good as it could be. The solution is simple -- to print titles exactly after @code{subplot} call and before any rotation, aspect change and so on! Analogously, the title for the whole picture looks better if it is printed first (before any @code{subplot} calls). Alternatively you can use function @code{title} for plotting title for the picture at any time.
@c ------------------------------------------------------------------
+@external
@node Changing of the color range, Management of a point cutting, Titles for the plot, Hints
@subsection Changing of the color range
@end verbatim
@c ------------------------------------------------------------------
+@external
@node Management of a point cutting, Vector field visualization, Changing of the color range, Hints
@subsection Management of a point cutting
It is an interesting result, is not it?
@c ------------------------------------------------------------------
+@external
@node Vector field visualization, Several light sources, Management of a point cutting, Hints
@subsection Vector field visualization
Vector field visualization (especially in 3d case @code{vect3} or @code{vectc}) may look tangly -- there are too many overlapping lines. I may suggest 2 ways to solve this problem. The first one is to change @code{meshnum} for decreasing the number of hachures. The second way is to use the flow thread chart @code{Flow}. Unfortunately, I don't know any other methods to visualize 3d vector field. If you know any, e-mail me and I shall add it to MathGL.
@c ------------------------------------------------------------------
+@external
@node Several light sources, CutMin and CutMax features, Vector field visualization, Hints
@subsection Several light sources
In contrast to the most of other programs, MathGL supports several (up to 10) light sources. Moreover, the color each of them can be different: white (this is usual), yellow, red, cyan, green and so on. The use of several light sources may be interesting for the highlighting of some peculiarities of the plot or just to make an amusing picture. Note, each light source can be switched on/off individually (@pxref{Several light sample}).
@c ------------------------------------------------------------------
+@external
@node CutMin and CutMax features, Mapping visualization, Several light sources, Hints
@subsection CutMin and CutMax features
One can also exclude points from arbitrary area in space. This area defined by textual formula @code{cut} (@pxref{Cutting}). The algorithm is the same as shown for ``rectangular cutting''.
@c ------------------------------------------------------------------
+@external
@node Mapping visualization, Log-scaled plot, CutMin and CutMax features, Hints
@subsection Mapping visualization
I tried to make such plot in @code{map}. It shows the set of points or set of faces, which final position is the result of mapping. At this, the color gives information about their initial position and the height describes Jacobian value of the transformation. Unfortunately, it looks good only for the simplest mapping but for the real multivalent quasi-chaotic mapping it produces a confusion. So, use it if you like :).
@c ------------------------------------------------------------------
+@external
@node Log-scaled plot, Nonlinear fitting hints, Mapping visualization, Hints
@subsection Log-scaled plot
Log-scaled plot can be drawn by 2 steps. First, one should change the scale of axis by call @code{axis 'lg(x)' 'lg(y)'} (in this example, x- and y-axis will be log-scaled). Second, one should set logarithmic scale for axis ticks by changing variables: @code{xtick 0: yticks 0}. Finally, one should check (or change) the axis ranges and origin so that their values to be positive. For example of log-log plot @pxref{Log-log sample}.
@c ------------------------------------------------------------------
+@external
@node Nonlinear fitting hints, PDE solving hints, Log-scaled plot, Hints
@subsection Nonlinear fitting hints
NOTE! the fitting results may have strong dependence on initial values for coefficients due to algorithm features. The problem is that in general case there are several local 'optimums' for coefficients and the program returns only first found one! There are no guaranties that it will be the best. Try for example to set @code{ini = [0, 0, 0]} in the code above.
@c ------------------------------------------------------------------
+@external
@node PDE solving hints, Stereo image, Nonlinear fitting hints, Hints
@subsection PDE solving hints
@c ------------------------------------------------------------------
+@external
@node Stereo image, , PDE solving hints, Hints
@subsection Stereo image
# draw the same here
@end verbatim
+@external
+
Note that several commands can be placed in a string if they are separated by @samp{:} symbol.
-@float
+@mreal
@image{../png/sample1, 7cm}
@caption{Example of several subplots on the single picture.}
-@end float
+@end mreal
@c ------------------------------------------------------------------
@node Axis and grids, Curvilinear coordinates, Subplots, Advanced usage
This example shows the importance of the correct choosing of the number of ticks on axis. If tick step is too small then its text may overlap and becomes unreadable. This code has the example of @code{Label} function. It draws label for axis in specified direction. The text position on axis is specified by third argument of @code{Label} function. If it is positive then then text is drawn near the axis maximum, if negative then the same takes place near the minimum of axis, if zero - then at the center of axis.
-@float
+@mreal
@image{../png/sample2, 7cm}
@caption{Example of setting up axis range and axis ticks.}
-@end float
+@end mreal
@c ------------------------------------------------------------------
@node Curvilinear coordinates, Text printing example, Axis and grids, Advanced usage
text 0 1.3 1 'spiral'
@end verbatim
-@float
+@mreal
@image{../png/sample3, 7cm}
@caption{Example of curvilinear coordinates}
-@end float
+@end mreal
@c ------------------------------------------------------------------
text 0 -1 'It parse TeX: \int \alpha \cdot \sqrt3{sin(\pi x)^2 + \gamma_{i_k}} dx'
@end verbatim
-@float
+@mreal
@image{../png/sample4, 7cm}
@caption{Example of text printing with different font effects}
-@end float
+@end mreal
Another example demonstrate the features of TeX formula parsing.
@verbatim
text 0 0 '\sqrt{\frac{\alpha^{\gamma^2}+\overset 1{\big\infty}}{\sqrt3{2+b}}}', 0, -4
@end verbatim
-@float
+@mreal
@image{../png/samplee, 7cm}
@caption{Example of TeX formula parsing}
-@end float
+@end mreal
@c ------------------------------------------------------------------
@node Data handling, Data plotting, Advanced usage, Examples
@section Data handling
-@c Class @code{mglData} contains all functions for the data handling in MathGL (@pxref{mglData class}). There are several matters why I use class @code{mglData} but not a single array: it does not depend on type of data (float or double), sizes of data arrays are kept with data, memory working is simpler and safer.
+@c Class @code{mglData} contains all functions for the data handling in MathGL (@pxref{mglData class}). There are several matters why I use class @code{mglData} but not a single array: it does not depend on type of data (mreal or double), sizes of data arrays are kept with data, memory working is simpler and safer.
@menu
* Array creation::
@end verbatim
or loaded from file.
-The only non-obvious thing here is using multidimensional arrays in C/C++, i.e. arrays defined like @code{float dat[40][30];}. Since, formaly this arrays element @code{dat[i]} can address the memory in arbitrary place you should use the proper function to convert such arrays to @code{mglData} object. For C++ this is functions like @code{mglData::Set(float **dat, int N1, int N2}. For C this is functions like @code{mgl_data_set_float2(HMDT d, const float **dat, int N1, int N2}. At this, you should keep in mind that @code{nx=N2} and @code{ny=N1} after conversion.
+The only non-obvious thing here is using multidimensional arrays in C/C++, i.e. arrays defined like @code{mreal dat[40][30];}. Since, formaly this arrays element @code{dat[i]} can address the memory in arbitrary place you should use the proper function to convert such arrays to @code{mglData} object. For C++ this is functions like @code{mglData::Set(mreal **dat, int N1, int N2}. For C this is functions like @code{mgl_data_set_mreal2(HMDT d, const mreal **dat, int N1, int N2}. At this, you should keep in mind that @code{nx=N2} and @code{ny=N1} after conversion.
@c ------------------------------------------------------------------
@node Data changing, , Array creation, Data handling
text 0.7 1 1.2 '\int {d^2}a/dxdy dx'
@end verbatim
-@float
+@mreal
@image{../png/sample6, 7cm}
@caption{Example of data differentiation and integration}
-@end float
+@end mreal
Data smoothing (function @code{Smooth}) is more interesting and important. This function has 2 main arguments: type of smoothing and its direction. Now 4 methods are supported: @code{0} does nothing for delta=0 or approaches data to zero with the step delta, @code{1} linear averaging by 3 points, @code{2} linear averaging by 5 points, @code{3} quadratic averaging by 5 points. Let me demonstrate it for 1d case:
@verbatim
legend: box
@end verbatim
-@float
+@mreal
@image{../png/sample7, 7cm}
@caption{Example of data smoothing}
-@end float
+@end mreal
Finally one can create new data arrays on base of the existing one: extract slice, row or column of data (@code{SubData}), summarize along some of direction(s) (@code{Sum}), find distribution of data elements (@code{Hist}). Note, that all these functions are not thread-safe because they use static internal variable for output array. In particular, the using of several of them in arguments of the same function will lead to unpredictable result.
bars x y0 z 'r':box
@end verbatim
-@float
+@mreal
@image{../png/sample8, 7cm}
@caption{Example of 1D data plot}
-@end float
+@end mreal
@c ------------------------------------------------------------------
@node Plots for 2D data, Plots for 3D data, Plots for 1D data, Data plotting
@end verbatim
Note, that the previous color scheme is used in last plots because there are no direct specification of the one.
-@float
+@mreal
@image{../png/sample9, 7cm}
@caption{Example of surface plot for 2D data}
-@end float
+@end mreal
Drawing of other 2D plots is analogous. The only peculiarity is the usage of flag @samp{#}. By default this flag switches on the drawing of a grid on plot (@code{grid} or @code{mesh} for plots in plain or in volume). However, for isosurfaces (including surfaces of rotation @code{axial}) this flag switches the face drawing off. Figure becomes wired. The following code gives example of flag @samp{#} using (compare with normal function drawing as in its description):
@verbatim
axial a 'bbcyrr#': box
@end verbatim
-@float
+@mreal
@image{../png/samplea, 7cm}
@caption{Example of 2D data plot with color scheme contained @samp{#} symbol}
-@end float
+@end mreal
@c ------------------------------------------------------------------
@node Plots for 3D data, Surface transparency, Plots for 2D data, Data plotting
surf3a b a 'q': box
@end verbatim
-@float
+@mreal
@image{../png/sampleb, 7cm}
@caption{Example of Gaussian beam diffraction (3D data)}
-@end float
+@end mreal
@c ------------------------------------------------------------------
A ``neon-like'' transparency (@code{transptype 2}) has more interesting look. In this case a surface is the light source (like a lamp on the dark background) and just adds some intensity to the color. At this, the library sets automatically the black color for the background and changes the default line color to white.
As example I shall show the variant of plot from @ref{Plots for 2D data} (grid drawing is disabled) for different types of transparency.
-@float
+@mreal
@image{../png/type0, 7cm}
@caption{Example of @code{TranspType=0}.}
-@end float
-@float
+@end mreal
+@mreal
@image{../png/type1, 7cm}
@caption{Example of @code{TranspType=1}.}
-@end float
-@float
+@end mreal
+@mreal
@image{../png/type2, 7cm}
@caption{Example of @code{TranspType=2}.}
-@end float
+@end mreal
@end menu
@c ------------------------------------------------------------------
+@external
@node Basic usage, Advanced usage, , Examples
@section Basic usage
@c ------------------------------------------------------------------
+@external
@node Using MathGL window, Drawing to file, , Basic usage
@subsection Using MathGL window
@cindex window
In this example function @code{sample} rotates axes (@code{Rotate()}, @pxref{Subplots and rotation}) and draws the bounding box (@code{Box()}). Drawing is placed in separate function since it will be used on demand when window canvas needs to be redrawn.
@c ------------------------------------------------------------------
+@external
@node Drawing to file, Animation, Using MathGL window, Basic usage
@subsection Drawing to file
The difference from the previous one is using other function @code{WriteEPS()} for EPS format instead of function @code{WritePNG()}. Also, there is no switching on of the plot transparency @code{Alpha} since EPS format does not support it.
@c ------------------------------------------------------------------
+@external
@node Animation, Drawing in memory, Drawing to file, Basic usage
@subsection Animation
pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);
gr.Clf(); // make new drawing
gr.Line(mglPoint(),pnt,"Ar2");
- char str[10] = "i=0"; str[3] = '0'+i;
+ char str[10] = "i=0"; str[2] = '0'+i;
gr.Puts(mglPoint(),"");
gr.Update(); // update window when you need it
}
Finally, you can use @code{mglconv} tool for doing the same with MGL scripts (@pxref{Utilities}).
@c ------------------------------------------------------------------
+@external
@node Drawing in memory, Using QMathGL, Animation, Basic usage
@subsection Drawing in memory
gr.Light(true);
sample(&gr,NULL);
- wxImage img(w,h,gr.GetBits(),true);
+ wxImage img(w,h,gr.GetRGB(),true);
ToolBar->GetSize(&x,&y); // gets a height of the toolbar if any
wxPaintDC dc(this); // and draws it
dc.DrawBitmap(wxBitmap(img),0,y);
gr.Alpha(true); // draws something using MathGL
gr.Light(true);
sample(&gr,NULL);
- fl_draw_image(gr.GetBits(), x(), y(), gr.GetWidth(), gr.GetHeight(), 3);
+ fl_draw_image(gr.GetRGB(), x(), y(), gr.GetWidth(), gr.GetHeight(), 3);
}
@end verbatim
Qt code will look like
@end verbatim
@c ------------------------------------------------------------------
+@external
@node Using QMathGL, MathGL and PyQt, Drawing in memory, Basic usage
@subsection Using QMathGL
@end verbatim
@c ------------------------------------------------------------------
+@external
@node MathGL and PyQt, , Using QMathGL, Basic usage
@subsection MathGL and PyQt
@c ------------------------------------------------------------------
+@external
@node Advanced usage, Data handling, Basic usage, Examples
@section Advanced usage
@end menu
@c ------------------------------------------------------------------
+@external
@node Subplots, Axis and ticks, , Advanced usage
@subsection Subplots
@end verbatim
Here I used function @code{Puts} for printing the text in arbitrary position of picture (see @ref{Text printing}). Text coordinates and size are connected with axes. However, text coordinates may be everywhere, including the outside the bounding box. I'll show its features later in @ref{Text features}.
-@fig{png/aspect, Example of several subplots on the single picture.}
+@pfig{aspect, Example of several subplots on the single picture.}
More complicated sample show how to use most of positioning functions:
@verbatim
}
@end verbatim
-@fig{png/inplot, Example for most of positioning functions.}
+@pfig{inplot, Example for most of positioning functions.}
@c ------------------------------------------------------------------
+@external
@node Axis and ticks, Curvilinear coordinates, Subplots, Advanced usage
@subsection Axis and ticks
Note, that MathGL can draw not only single axis (which is default). But also several axis on the plot (see right plots). The idea is that the change of settings does not influence on the already drawn graphics. So, for 2-axes I setup the first axis and draw everything concerning it. Then I setup the second axis and draw things for the second axis. Generally, the similar idea allows one to draw rather complicated plot of 4 axis with different ranges (see bottom left plot).
-@fig{png/axis, Example of axis.}
+@pfig{axis, Example of axis.}
Another MathGL feature is fine ticks tunning. By default (if it is not changed by @code{SetTicks} function), MathGL try to adjust ticks positioning, so that they looks most human readable. At this, MathGL try to extract common factor for too large or too small axis ranges, as well as for too narrow ranges. Last one is non-common notation and can be disabled by @code{SetTuneTicks} function.
gr->SetTuneTicks(0); gr->Axis();
gr->SubPlot(3,2,2); gr->Title("Manual ticks"); gr->SetRanges(-M_PI,M_PI, 0, 2);
- float val[]={-M_PI, -M_PI/2, 0, 0.886, M_PI/2, M_PI};
+ mreal val[]={-M_PI, -M_PI/2, 0, 0.886, M_PI/2, M_PI};
gr->SetTicksVal('x', mglData(6,val), "-\\pi\n-\\pi/2\n0\nx^*\n\\pi/2\n\\pi");
gr->Axis(); gr->Grid(); gr->FPlot("2*cos(x^2)^2", "r2");
}
@end verbatim
-@fig{png/ticks, Features of axis ticks.}
+@pfig{ticks, Features of axis ticks.}
The last sample I want to show in this subsection is Log-axis. From MathGL's point of vew, the log-axis is particular case of general curvilinear coordinates. So, we need first define new coordinates (see also @ref{Curvilinear coordinates}) by help of @code{SetFunc} or @code{SetCoor} functions. At this one should wary about proper axis range. So the code looks as following:
@verbatim
}
@end verbatim
-@fig{png/loglog, Features of axis ticks.}
+@pfig{loglog, Features of axis ticks.}
You can see that MathGL automatically switch to log-ticks as we define log-axis formula (in difference from v.1.*). Moreover, it switch to log-ticks for any formula if axis range will be large enough (see right bottom plot). Another interesting feature is that you not necessary define usual log-axis (i.e. when coordinates are positive), but you can define ``minus-log'' axis when coordinate is negative (see left bottom plot).
@c ------------------------------------------------------------------
+@external
@node Curvilinear coordinates, Colorbars, Axis and ticks, Advanced usage
@subsection Curvilinear coordinates
}
@end verbatim
-@fig{png/curvcoor, Example of curvilinear coordinates}
+@pfig{curvcoor, Example of curvilinear coordinates}
@c ------------------------------------------------------------------
+@external
@node Colorbars, Bounding box, Curvilinear coordinates, Advanced usage
@subsection Colorbars
}
@end verbatim
-@fig{png/colorbar, Example of colorbars}
+@pfig{colorbar, Example of colorbars}
@c ------------------------------------------------------------------
+@external
@node Bounding box, Ternary axis, Colorbars, Advanced usage
@subsection Bounding box
}
@end verbatim
-@fig{png/box, Example of Box()}
+@pfig{box, Example of Box()}
@c ------------------------------------------------------------------
+@external
@node Ternary axis, Text features, Bounding box, Advanced usage
@subsection Ternary axis
}
@end verbatim
-@fig{png/ternary, Example of colorbars}
+@pfig{ternary, Example of colorbars}
@c ------------------------------------------------------------------
+@external
@node Text features, Legend sample, Ternary axis, Advanced usage
@subsection Text features
}
@end verbatim
-@fig{png/text, Example of text printing}
+@pfig{text, Example of text printing}
@c ------------------------------------------------------------------
+@external
@node Legend sample, Cutting sample, Text features, Advanced usage
@subsection Legend sample
}
@end verbatim
-@fig{png/legend, Example of legend}
+@pfig{legend, Example of legend}
@c ------------------------------------------------------------------
+@external
@node Cutting sample, , Legend sample, Advanced usage
@subsection Cutting sample
}
@end verbatim
-@fig{png/cut, Example of point cutting}
+@pfig{cut, Example of point cutting}
@c ------------------------------------------------------------------
+@external
@node Data handling, Data plotting, Advanced usage, Examples
@section Data handling
-Class @code{mglData} contains all functions for the data handling in MathGL (@pxref{Data processing}). There are several matters why I use class @code{mglData} but not a single array: it does not depend on type of data (float or double), sizes of data arrays are kept with data, memory working is simpler and safer.
+Class @code{mglData} contains all functions for the data handling in MathGL (@pxref{Data processing}). There are several matters why I use class @code{mglData} but not a single array: it does not depend on type of data (mreal or double), sizes of data arrays are kept with data, memory working is simpler and safer.
@menu
* Array creation::
@end menu
@c ------------------------------------------------------------------
+@external
@node Array creation, Change data, , Data handling
@subsection Array creation
z.Modify("sin(pi*x)*cos(pi*y)");
@end verbatim
-The only non-obvious thing here is using multidimensional arrays in C/C++, i.e. arrays defined like @code{float dat[40][30];}. Since, formally these elements @code{dat[i]} can address the memory in arbitrary place you should use the proper function to convert such arrays to @code{mglData} object. For C++ this is functions like @code{mglData::Set(float **dat, int N1, int N2);}. For C this is functions like @code{mgl_data_set_float2(HMDT d, const float **dat, int N1, int N2);}. At this, you should keep in mind that @code{nx=N2} and @code{ny=N1} after conversion.
+The only non-obvious thing here is using multidimensional arrays in C/C++, i.e. arrays defined like @code{mreal dat[40][30];}. Since, formally these elements @code{dat[i]} can address the memory in arbitrary place you should use the proper function to convert such arrays to @code{mglData} object. For C++ this is functions like @code{mglData::Set(mreal **dat, int N1, int N2);}. For C this is functions like @code{mgl_data_set_mreal2(HMDT d, const mreal **dat, int N1, int N2);}. At this, you should keep in mind that @code{nx=N2} and @code{ny=N1} after conversion.
@c ------------------------------------------------------------------
+@external
@node Linking array, Change data, Array creation, Data handling
@subsection Linking array
@end verbatim
@c ------------------------------------------------------------------
+@external
@node Change data, , Linking array, Data handling
@subsection Change data
}
@end verbatim
-@fig{png/dat_diff, Example of data differentiation and integration}
+@pfig{dat_diff, Example of data differentiation and integration}
Data smoothing (function @code{Smooth()}) is more interesting and important. This function has single argument which define type of smoothing and its direction. Now 3 methods are supported: @samp{3} -- linear averaging by 3 points, @samp{5} -- linear averaging by 5 points, and default one -- quadratic averaging by 5 points.
}
@end verbatim
-@fig{png/dat_extra, Example of data smoothing}
+@pfig{dat_extra, Example of data smoothing}
Finally one can create new data arrays on base of the existing one: extract slice, row or column of data (@code{SubData()}), summarize along a direction(s) (@code{Sum()}), find distribution of data elements (@code{Hist()}) and so on.
@c ------------------------------------------------------------------
+@external
@node Data plotting, 1D samples, Data handling, Examples
@section Data plotting
@end verbatim
@c ------------------------------------------------------------------
+@external
@node 1D samples, 2D samples, Data plotting, Examples
@section 1D samples
if(y) y->Create(n,3);
if(x1) x1->Create(n); if(x2) x2->Create(n);
if(y1) y1->Create(n); if(y2) y2->Create(n);
- float xx;
+ mreal xx;
for(i=0;i<n;i++)
{
xx = i/(n-1.);
if(x2) mgl_data_create(x2,n,1,1);
if(y1) mgl_data_create(y1,n,1,1);
if(y2) mgl_data_create(y2,n,1,1);
- float xx;
+ mreal xx;
for(i=0;i<n;i++)
{
xx = i/(n-1.);
@c ------------------------------------------------------------------
+@external
@node Plot sample, Radar sample, , 1D samples
@subsection Plot sample
}
@end verbatim
-@fig{png/plot, Example of Plot()}
+@pfig{plot, Example of Plot()}
@c ------------------------------------------------------------------
+@external
@node Radar sample, Step sample, Plot sample, 1D samples
@subsection Radar sample
}
@end verbatim
-@fig{png/radar, Example of Radar()}
+@pfig{radar, Example of Radar()}
@c ------------------------------------------------------------------
+@external
@node Step sample, Tens sample, Radar sample, 1D samples
@subsection Step sample
}
@end verbatim
-@fig{png/step, Example of Step()}
+@pfig{step, Example of Step()}
@c ------------------------------------------------------------------
+@external
@node Tens sample, Area sample, Step sample, 1D samples
@subsection Tens sample
}
@end verbatim
-@fig{png/tens, Example of Tens()}
+@pfig{tens, Example of Tens()}
@c ------------------------------------------------------------------
+@external
@node Area sample, Region sample, Tens sample, 1D samples
@subsection Area sample
}
@end verbatim
-@fig{png/area, Example of Area()}
+@pfig{area, Example of Area()}
@c ------------------------------------------------------------------
+@external
@node Region sample, Stem sample, Area sample, 1D samples
@subsection Region sample
}
@end verbatim
-@fig{png/region, Example of Region()}
+@pfig{region, Example of Region()}
@c ------------------------------------------------------------------
+@external
@node Stem sample, Bars sample, Region sample, 1D samples
@subsection Stem sample
}
@end verbatim
-@fig{png/stem, Example of Stem()}
+@pfig{stem, Example of Stem()}
@c ------------------------------------------------------------------
+@external
@node Bars sample, Barh sample, Stem sample, 1D samples
@subsection Bars sample
}
@end verbatim
-@fig{png/bars, Example of Bars()}
+@pfig{bars, Example of Bars()}
@c ------------------------------------------------------------------
+@external
@node Barh sample, Cones sample, Bars sample, 1D samples
@subsection Barh sample
}
@end verbatim
-@fig{png/barh, Example of Barh()}
+@pfig{barh, Example of Barh()}
@c ------------------------------------------------------------------
+@external
@node Cones sample, Chart sample, Bars sample, 1D samples
@subsection Cones sample
}
@end verbatim
-@fig{png/cones, Example of Cones()}
+@pfig{cones, Example of Cones()}
@c ------------------------------------------------------------------
+@external
@node Chart sample, BoxPlot sample, Cones sample, 1D samples
@subsection Chart sample
}
@end verbatim
-@fig{png/chart, Example of Chart()}
+@pfig{chart, Example of Chart()}
@c ------------------------------------------------------------------
+@external
@node BoxPlot sample, Candle sample, Chart sample, 1D samples
@subsection BoxPlot sample
}
@end verbatim
-@fig{png/boxplot, Example of BoxPlot()}
+@pfig{boxplot, Example of BoxPlot()}
@c ------------------------------------------------------------------
+@external
@node Candle sample, Error sample, BoxPlot sample, 1D samples
@subsection Candle sample
}
@end verbatim
-@fig{png/candle, Example of Candle()}
+@pfig{candle, Example of Candle()}
@c ------------------------------------------------------------------
+@external
@node Error sample, Mark sample, Candle sample, 1D samples
@subsection Error sample
{
mglData y; mgls_prepare1d(&y);
mglData x0(10), y0(10), ex0(10), ey0(10);
- float x;
+ mreal x;
for(int i=0;i<10;i++)
{
x = i/9.;
}
@end verbatim
-@fig{png/error, Example of Error()}
+@pfig{error, Example of Error()}
@c ------------------------------------------------------------------
+@external
@node Mark sample, TextMark sample, Error sample, 1D samples
@subsection Mark sample
}
@end verbatim
-@fig{png/mark, Example of Mark()}
+@pfig{mark, Example of Mark()}
@c ------------------------------------------------------------------
+@external
@node TextMark sample, Label sample, Mark sample, 1D samples
@subsection TextMark sample
}
@end verbatim
-@fig{png/textmark, Example of TextMark()}
+@pfig{textmark, Example of TextMark()}
@c ------------------------------------------------------------------
+@external
@node Label sample, Tube sample, TextMark sample, 1D samples
@subsection Label sample
}
@end verbatim
-@fig{png/label, Example of Label()}
+@pfig{label, Example of Label()}
@c ------------------------------------------------------------------
+@external
@node Tube sample, Tape sample, Label sample, 1D samples
@subsection Tube sample
}
@end verbatim
-@fig{png/tube, Example of Tube()}
+@pfig{tube, Example of Tube()}
@c ------------------------------------------------------------------
+@external
@node Tape sample, Torus sample, Tube sample, 1D samples
@subsection Tape sample
}
@end verbatim
-@fig{png/tape, Example of Tape()}
+@pfig{tape, Example of Tape()}
@c ------------------------------------------------------------------
+@external
@node Torus sample, , Tape sample, 1D samples
@subsection Torus sample
}
@end verbatim
-@fig{png/torus, Example of Torus()}
+@pfig{torus, Example of Torus()}
@c ------------------------------------------------------------------
+@external
@node 2D samples, 3D samples, 1D samples, Examples
@section 2D samples
register long i,j,n=50,m=40,i0;
if(a) a->Create(n,m); if(b) b->Create(n,m);
if(v) { v->Create(9); v->Fill(-1,1); }
- float x,y;
+ mreal x,y;
for(i=0;i<n;i++) for(j=0;j<m;j++)
{
x = i/(n-1.); y = j/(m-1.); i0 = i+n*j;
if(a) mgl_data_create(a,n,m,1);
if(b) mgl_data_create(b,n,m,1);
if(v) { mgl_data_create(v,9,1,1); mgl_data_fill(v,-1,1,'x'); }
- float x,y;
+ mreal x,y;
for(i=0;i<n;i++) for(j=0;j<m;j++)
{
x = i/(n-1.); y = j/(m-1.); i0 = i+n*j;
@end menu
@c ------------------------------------------------------------------
+@external
@node Surf sample, SurfC sample, , 2D samples
@subsection Surf sample
}
@end verbatim
-@fig{png/surf, Example of Surf()}
+@pfig{surf, Example of Surf()}
@c ------------------------------------------------------------------
+@external
@node SurfC sample, SurfA sample, Surf sample, 2D samples
@subsection SurfC sample
}
@end verbatim
-@fig{png/surfc, Example of SurfC()}
+@pfig{surfc, Example of SurfC()}
@c ------------------------------------------------------------------
+@external
@node SurfA sample, Mesh sample, SurfC sample, 2D samples
@subsection SurfA sample
}
@end verbatim
-@fig{png/surfa, Example of SurfA()}
+@pfig{surfa, Example of SurfA()}
@c ------------------------------------------------------------------
+@external
@node Mesh sample, Fall sample, SurfA sample, 2D samples
@subsection Mesh sample
}
@end verbatim
-@fig{png/mesh, Example of Mesh()}
+@pfig{mesh, Example of Mesh()}
@c ------------------------------------------------------------------
+@external
@node Fall sample, Belt sample, Mesh sample, 2D samples
@subsection Fall sample
}
@end verbatim
-@fig{png/fall, Example of Fall()}
+@pfig{fall, Example of Fall()}
@c ------------------------------------------------------------------
+@external
@node Belt sample, Boxs sample, Fall sample, 2D samples
@subsection Belt sample
}
@end verbatim
-@fig{png/belt, Example of Belt()}
+@pfig{belt, Example of Belt()}
@c ------------------------------------------------------------------
+@external
@node Boxs sample, Tile sample, Fall sample, 2D samples
@subsection Boxs sample
}
@end verbatim
-@fig{png/boxs, Example of Boxs()}
+@pfig{boxs, Example of Boxs()}
@c ------------------------------------------------------------------
+@external
@node Tile sample, TileS sample, Boxs sample, 2D samples
@subsection Tile sample
}
@end verbatim
-@fig{png/tile, Example of Tile()}
+@pfig{tile, Example of Tile()}
@c ------------------------------------------------------------------
+@external
@node TileS sample, Dens sample, Tile sample, 2D samples
@subsection TileS sample
}
@end verbatim
-@fig{png/tiles, Example of TileS()}
+@pfig{tiles, Example of TileS()}
@c ------------------------------------------------------------------
+@external
@node Dens sample, Cont sample, TileS sample, 2D samples
@subsection Dens sample
}
@end verbatim
-@fig{png/dens, Example of Dens()}
+@pfig{dens, Example of Dens()}
@c ------------------------------------------------------------------
+@external
@node Cont sample, ContF sample, Dens sample, 2D samples
@subsection Cont sample
}
@end verbatim
-@fig{png/cont, Example of Cont()}
+@pfig{cont, Example of Cont()}
@c ------------------------------------------------------------------
+@external
@node ContF sample, ContD sample, Cont sample, 2D samples
@subsection ContF sample
}
@end verbatim
-@fig{png/contf, Example of ContF()}
+@pfig{contf, Example of ContF()}
@c ------------------------------------------------------------------
+@external
@node ContD sample, ContV sample, ContF sample, 2D samples
@subsection ContD sample
}
@end verbatim
-@fig{png/contd, Example of ContD()}
+@pfig{contd, Example of ContD()}
@c ------------------------------------------------------------------
+@external
@node ContV sample, Axial sample, ContD sample, 2D samples
@subsection ContV sample
}
@end verbatim
-@fig{png/contv, Example of ContV()}
+@pfig{contv, Example of ContV()}
@c ------------------------------------------------------------------
+@external
@node Axial sample, Grad sample, ContV sample, 2D samples
@subsection Axial sample
}
@end verbatim
-@fig{png/axial, Example of Axial()}
+@pfig{axial, Example of Axial()}
@c ------------------------------------------------------------------
+@external
@node Grad sample, , Axial sample, 2D samples
@subsection Grad sample
}
@end verbatim
-@fig{png/grad, Example of Grad()}
+@pfig{grad, Example of Grad()}
@c ------------------------------------------------------------------
+@external
@node 3D samples, Vector field samples, 2D samples, Examples
@section 3D samples
{
register long i,j,k,n=61,m=50,l=40,i0;
if(a) a->Create(n,m,l); if(b) b->Create(n,m,l);
- float x,y,z;
+ mreal x,y,z;
for(i=0;i<n;i++) for(j=0;j<m;j++) for(k=0;k<l;k++)
{
x=2*i/(n-1.)-1; y=2*j/(m-1.)-1; z=2*k/(l-1.)-1; i0 = i+n*(j+m*k);
register long i,j,k,n=61,m=50,l=40,i0;
if(a) mgl_data_create(a,n,m,l);
if(b) mgl_data_create(b,n,m,l);
- float x,y,z;
+ mreal x,y,z;
for(i=0;i<n;i++) for(j=0;j<m;j++) for(k=0;k<l;k++)
{
x=2*i/(n-1.)-1; y=2*j/(m-1.)-1; z=2*k/(l-1.)-1; i0 = i+n*(j+m*k);
@end menu
@c ------------------------------------------------------------------
+@external
@node Surf3 sample, Surf3C sample, , 3D samples
@subsection Surf3 sample
}
@end verbatim
-@fig{png/surf3, Example of Surf3()}
+@pfig{surf3, Example of Surf3()}
@c ------------------------------------------------------------------
+@external
@node Surf3C sample, Surf3A sample, Surf3 sample, 3D samples
@subsection Surf3C sample
}
@end verbatim
-@fig{png/surf3c, Example of Surf3C()}
+@pfig{surf3c, Example of Surf3C()}
@c ------------------------------------------------------------------
+@external
@node Surf3A sample, Cloud sample, Surf3C sample, 3D samples
@subsection Surf3A sample
}
@end verbatim
-@fig{png/surf3a, Example of Surf3A()}
+@pfig{surf3a, Example of Surf3A()}
@c ------------------------------------------------------------------
+@external
@node Cloud sample, Dens3 sample, Surf3A sample, 3D samples
@subsection Cloud sample
}
@end verbatim
-@fig{png/cloud, Example of Cloud()}
+@pfig{cloud, Example of Cloud()}
@c ------------------------------------------------------------------
+@external
@node Dens3 sample, Cont3 sample, Cloud sample, 3D samples
@subsection Dens3 sample
}
@end verbatim
-@fig{png/densa, Example of Dens3()}
+@pfig{densa, Example of Dens3()}
@c ------------------------------------------------------------------
+@external
@node Cont3 sample, ContF3 sample, Dens3 sample, 3D samples
@subsection Cont3 sample
}
@end verbatim
-@fig{png/conta, Example of Cont3()}
+@pfig{conta, Example of Cont3()}
@c ------------------------------------------------------------------
+@external
@node ContF3 sample, Dens projection sample, Cont3 sample, 3D samples
@subsection ContF3 sample
}
@end verbatim
-@fig{png/contfa, Example of ContF3()}
+@pfig{contfa, Example of ContF3()}
@c ------------------------------------------------------------------
+@external
@node Dens projection sample, Cont projection sample, ContF3 sample, 3D samples
@subsection Dens projection sample
}
@end verbatim
-@fig{png/dens_xyz, {Example of DensX(), DensY(), DensZ()}}
+@pfig{dens_xyz, {Example of DensX(), DensY(), DensZ()}}
@c ------------------------------------------------------------------
+@external
@node Cont projection sample, ContF projection sample, Dens projection sample, 3D samples
@subsection Cont projection sample
}
@end verbatim
-@fig{png/cont_xyz, {Example of ContX(), ContY(), ContZ()}}
+@pfig{cont_xyz, {Example of ContX(), ContY(), ContZ()}}
@c ------------------------------------------------------------------
+@external
@node ContF projection sample, TriPlot and QuadPlot, Cont projection sample, 3D samples
@subsection ContF projection sample
}
@end verbatim
-@fig{png/contf_xyz, {Example of ContFX(), ContFY(), ContFZ()}}
+@pfig{contf_xyz, {Example of ContFX(), ContFY(), ContFZ()}}
@c ------------------------------------------------------------------
+@external
@node TriPlot and QuadPlot, Axial sample, ContF projection sample, 3D samples
@subsection TriPlot and QuadPlot
@verbatim
int sample(mglGraph *gr)
{
- float q[] = {0,1,2,3, 4,5,6,7, 0,2,4,6, 1,3,5,7, 0,4,1,5, 2,6,3,7};
- float xc[] = {-1,1,-1,1,-1,1,-1,1}, yc[] = {-1,-1,1,1,-1,-1,1,1}, zc[] = {-1,-1,-1,-1,1,1,1,1};
+ mreal q[] = {0,1,2,3, 4,5,6,7, 0,2,4,6, 1,3,5,7, 0,4,1,5, 2,6,3,7};
+ mreal xc[] = {-1,1,-1,1,-1,1,-1,1}, yc[] = {-1,-1,1,1,-1,-1,1,1}, zc[] = {-1,-1,-1,-1,1,1,1,1};
mglData qq(6,4,q), xx(8,xc), yy(8,yc), zz(8,zc);
gr->Light(true); //gr->Alpha(true);
gr->SubPlot(2,1,0); gr->Title("QuadPlot sample"); gr->Rotate(50,60);
gr->QuadPlot(qq,xx,yy,zz,"yr");
gr->QuadPlot(qq,xx,yy,zz,"k#");
- float t[] = {0,1,2, 0,1,3, 0,2,3, 1,2,3};
- float xt[] = {-1,1,0,0}, yt[] = {-1,-1,1,0}, zt[] = {-1,-1,-1,1};
+ mreal t[] = {0,1,2, 0,1,3, 0,2,3, 1,2,3};
+ mreal xt[] = {-1,1,0,0}, yt[] = {-1,-1,1,0}, zt[] = {-1,-1,-1,1};
mglData tt(4,3,t), uu(4,xt), vv(4,yt), ww(4,zt);
gr->SubPlot(2,1,1); gr->Title("TriPlot sample"); gr->Rotate(50,60);
gr->TriPlot(tt,uu,vv,ww,"b");
}
@end verbatim
-@fig{png/triplot, Example of TriPlot() and QuadPlot()}
+@pfig{triplot, Example of TriPlot() and QuadPlot()}
@c ------------------------------------------------------------------
+@external
@node Dots sample, , TriPlot and QuadPlot, 3D samples
@subsection Dots sample
mglData x(n),y(n),z(n);
for(i=0;i<n;i++)
{
- float t=M_PI*(mgl_rnd()-0.5), f=2*M_PI*mgl_rnd();
+ mreal t=M_PI*(mgl_rnd()-0.5), f=2*M_PI*mgl_rnd();
x.a[i] = 0.9*cos(t)*cos(f);
y.a[i] = 0.9*cos(t)*sin(f);
z.a[i] = 0.6*sin(t);
}
@end verbatim
-@fig{png/dots, Example of Dots()}
+@pfig{dots, Example of Dots()}
@c ------------------------------------------------------------------
+@external
@node Vector field samples, Hints, 3D samples, Examples
@section Vector field samples
{
register long i,j,n=20,m=30,i0;
if(a) a->Create(n,m); if(b) b->Create(n,m);
- float x,y;
+ mreal x,y;
for(i=0;i<n;i++) for(j=0;j<m;j++)
{
x=i/(n-1.); y=j/(m-1.); i0 = i+n*j;
register long i,j,k,n=10,i0;
if(!ex || !ey || !ez) return;
ex->Create(n,n,n); ey->Create(n,n,n); ez->Create(n,n,n);
- float x,y,z, r1,r2;
+ mreal x,y,z, r1,r2;
for(i=0;i<n;i++) for(j=0;j<n;j++) for(k=0;k<n;k++)
{
x=2*i/(n-1.)-1; y=2*j/(n-1.)-1; z=2*k/(n-1.)-1; i0 = i+n*(j+k*n);
register long i,j,n=20,m=30,i0;
if(a) mgl_data_create(a,n,m,1);
if(b) mgl_data_create(b,n,m,1);
- float x,y;
+ mreal x,y;
for(i=0;i<n;i++) for(j=0;j<m;j++)
{
x=i/(n-1.); y=j/(m-1.); i0 = i+n*j;
mgl_data_create(ex,n,n,n);
mgl_data_create(ey,n,n,n);
mgl_data_create(ez,n,n,n);
- float x,y,z, r1,r2;
+ mreal x,y,z, r1,r2;
for(i=0;i<n;i++) for(j=0;j<n;j++) for(k=0;k<n;k++)
{
x=2*i/(n-1.)-1; y=2*j/(n-1.)-1; z=2*k/(n-1.)-1; i0 = i+n*(j+k*n);
@c ------------------------------------------------------------------
+@external
@node Vect sample, Traj sample, , Vector field samples
@subsection Vect sample
}
@end verbatim
-@fig{png/vect, Example of Vect()}
+@pfig{vect, Example of Vect()}
@c ------------------------------------------------------------------
+@external
@node Traj sample, Flow sample, Vect sample, Vector field samples
@subsection Traj sample
}
@end verbatim
-@fig{png/traj, Example of Traj()}
+@pfig{traj, Example of Traj()}
@c ------------------------------------------------------------------
+@external
@node Flow sample, Pipe sample, Traj sample, Vector field samples
@subsection Flow sample
}
@end verbatim
-@fig{png/flow, Example of Flow()}
+@pfig{flow, Example of Flow()}
@c ------------------------------------------------------------------
+@external
@node Pipe sample, Dew sample, Flow sample, Vector field samples
@subsection Pipe sample
}
@end verbatim
-@fig{png/pipe, Example of Pipe()}
+@pfig{pipe, Example of Pipe()}
@c ------------------------------------------------------------------
+@external
@node Dew sample, , Pipe sample, Vector field samples
@subsection Dew sample
}
@end verbatim
-@fig{png/dew, Example of Dew()}
+@pfig{dew, Example of Dew()}
@c ------------------------------------------------------------------
+@external
@node Hints, FAQ, Vector field samples, Examples
@section Hints
@end menu
@c ------------------------------------------------------------------
+@external
@node ``Compound'' graphics, Transparency and lighting, , Hints
@subsection ``Compound'' graphics
}
@end verbatim
-@fig{png/combined, Example of ``combined'' plots}
+@pfig{combined, Example of ``combined'' plots}
@c ------------------------------------------------------------------
+@external
@node Transparency and lighting, Types of transparency, ``Compound'' graphics, Hints
@subsection Transparency and lighting
}
@end verbatim
-@fig{png/alpha, Example of transparency and lightings}
+@pfig{alpha, Example of transparency and lightings}
@c ------------------------------------------------------------------
+@external
@node Types of transparency, Adding fog, Transparency and lighting, Hints
@subsection Types of transparency
}
@end verbatim
-@fig{png/type0, Example of @code{SetTranspType(0)}.}
-@fig{png/type1, Example of @code{SetTranspType(1)}.}
-@fig{png/type2, Example of @code{SetTranspType(2)}.}
+@pfig{type0, Example of @code{SetTranspType(0)}.}
+@pfig{type1, Example of @code{SetTranspType(1)}.}
+@pfig{type2, Example of @code{SetTranspType(2)}.}
@c ------------------------------------------------------------------
+@external
@node Adding fog, Several light sources, Types of transparency, Hints
@subsection Adding fog
}
@end verbatim
-@fig{png/fog, Example of @code{Fog()}.}
+@pfig{fog, Example of @code{Fog()}.}
@c ------------------------------------------------------------------
+@external
@node Several light sources, Using primitives, Adding fog, Hints
@subsection Several light sources
}
@end verbatim
-@fig{png/several_light, Example of several light sources.}
+@pfig{several_light, Example of several light sources.}
@c ------------------------------------------------------------------
+@external
@node Using primitives, STFA sample, Several light sources, Hints
@subsection Using primitives
MathGL provide a set of functions for drawing primitives (see @ref{Primitives}). Primitives are low level object, which used by most of plotting functions. Picture below demonstrate some of commonly used primitives.
-@fig{png/primitives, Primitives in MathGL.}
+@pfig{primitives, Primitives in MathGL.}
Generally, you can create arbitrary new kind of plot using primitives. For example, MathGL don't provide any special functions for drawing molecules. However, you can do it using only one type of primitives @code{Drop}. The sample code is:
@verbatim
}
@end verbatim
-@fig{png/molecule, Example of molecules drawing.}
+@pfig{molecule, Example of molecules drawing.}
Moreover, some of special plots can be more easily produced by primitives rather than by specialized function. For example, Venn diagram can be produced by @code{Error} plot:
@verbatim
@end verbatim
Of course, the first variant is more suitable if you need to plot a lot of circles. But for few ones the usage of primitives looks easy.
-@fig{png/venn, Example of Venn diagram.}
+@pfig{venn, Example of Venn diagram.}
@c ------------------------------------------------------------------
+@external
@node STFA sample, Mapping visualization, Using primitives, Hints
@subsection STFA sample
}
@end verbatim
-@fig{png/stfa, Example of STFA().}
+@pfig{stfa, Example of STFA().}
@c ------------------------------------------------------------------
+@external
@node Mapping visualization, Making histogram, STFA sample, Hints
@subsection Mapping visualization
}
@end verbatim
-@fig{png/map, Example of Map().}
+@pfig{map, Example of Map().}
@c ------------------------------------------------------------------
+@external
@node Making histogram, Nonlinear fitting sample, Mapping visualization, Hints
@subsection Making histogram
@verbatim
int sample(mglGraph *gr)
{
- mglData a(50, 40), b(50, 40);
- gr->Puts(mglPoint(0, 0), "\\to", ":C", -1.4);
- gr->SetRanges(-1,1,-1,1,-2,2);
-
- gr->SubPlot(2, 1, 0);
- gr->Fill(a,"x"); gr->Fill(b,"y");
- gr->Puts(mglPoint(0, 1.1), "\\{x, y\\}", ":C", -2); gr->Box();
- gr->Map(a, b, "brgk");
-
- gr->SubPlot(2, 1, 1);
- gr->Fill(a,"(x^3+y^3)/2"); gr->Fill(b,"(x-y)/2");
- gr->Puts(mglPoint(0, 1.1), "\\{\\frac{x^3+y^3}{2}, \\frac{x-y}{2}\\}", ":C", -2);
- gr->Box();
- gr->Map(a, b, "brgk");
+ mglData x(10000), y(10000), z(10000); gr->Fill(x,"2*rnd-1");
+ gr->Fill(y,"2*rnd-1"); gr->Fill(z,"exp(-6*(v^2+w^2))",x,y);
+ mglData xx=gr->Hist(x,z), yy=gr->Hist(y,z); xx.Norm(0,1);
+ yy.Norm(0,1);
+ gr->MultiPlot(3,3,3,2,2,""); gr->SetRanges(-1,1,-1,1,0,1);
+ gr->Box(); gr->Dots(x,y,z,"wyrRk");
+ gr->MultiPlot(3,3,0,2,1,""); gr->SetRanges(-1,1,0,1);
+ gr->Box(); gr->Bars(xx);
+ gr->MultiPlot(3,3,5,1,2,""); gr->SetRanges(0,1,-1,1);
+ gr->Box(); gr->Barh(yy);
+ gr->SubPlot(3,3,2);
+ gr->Puts(mglPoint(0.5,0.5),"Hist and\nMultiPlot\nsample","a",-6);
return 0;
}
@end verbatim
-@fig{png/hist, Example of Hist().}
+@pfig{hist, Example of Hist().}
@c ------------------------------------------------------------------
+@external
@node Nonlinear fitting sample, PDE solving hints, Making histogram, Hints
@subsection Nonlinear fitting hints
The next step is the fitting itself. For that let me specify an initial values @var{ini} for coefficients @samp{abc} and do the fitting for approximation formula @samp{a+b*sin(c*x)}
@verbatim
- float ini[3] = {1,1,3};
+ mreal ini[3] = {1,1,3};
mglData Ini(3,ini);
mglData res = gr->Fit(rnd, "a+b*sin(c*x)", "abc", Ini);
@end verbatim
mglData rnd(100), in(100);
gr->Fill(rnd,"0.4*rnd+0.1+sin(2*pi*x)");
gr->Fill(in,"0.3+sin(2*pi*x)");
- float ini[3] = {1,1,3};
+ mreal ini[3] = {1,1,3};
mglData Ini(3,ini);
mglData res = gr->Fit(rnd, "a+b*sin(c*x)", "abc", Ini);
}
@end verbatim
-@fig{png/fit, Example of nonlinear fitting.}
+@pfig{fit, Example of nonlinear fitting.}
@c ------------------------------------------------------------------
+@external
@node PDE solving hints, MGL parser using, Nonlinear fitting sample, Hints
@subsection PDE solving hints
}
@end verbatim
-@fig{png/pde, Example of PDE solving.}
+@pfig{pde, Example of PDE solving.}
The last example is example of beam tracing. Beam tracing equation is special kind of PDE equation written in coordinates accompanied to a ray. Generally this is the same parameters and limitation as for PDE solving but the coordinates are defined by the ray and by parameter of grid width @var{w} in direction transverse the ray. So, you don't need to specify the range of coordinates. @strong{BUT} there is limitation. The accompanied coordinates are well defined only for smooth enough rays, i.e. then the ray curvature @math{K} (which is defined as @math{1/K^2 = (|\ddot r|^2 |\dot r|^2 - (\ddot r, \dot r)^2)/|\dot r|^6}) is much large then the grid width: @math{K>>w}. So, you may receive incorrect results if this condition will be broken.
}
@end verbatim
-@fig{png/qo2d, Example of beam tracing.}
+@pfig{qo2d, Example of beam tracing.}
@c ------------------------------------------------------------------
+@external
@node MGL parser using, ``Templates'', PDE solving hints, Hints
@subsection MGL parser using
int sample(mglGraph *gr)
{
gr->Title("MGL parser sample");
- float a[100]; // let a_i = sin(4*pi*x), x=0...1
+ mreal a[100]; // let a_i = sin(4*pi*x), x=0...1
for(int i=0;i<100;i++)a[i]=sin(4*M_PI*i/99);
mglParse *parser = new mglParse;
mglData *d = parser->AddVar("dat");
int sample(HMGL gr)
{
mgl_title(gr, "MGL parser sample")
- float a[100]; // let a_i = sin(4*pi*x), x=0...1
+ mreal a[100]; // let a_i = sin(4*pi*x), x=0...1
int i;
for(i=0;i<100;i++) a[i]=sin(4*M_PI*i/99);
HMPR parser = mgl_create_parser();
HMDT d = mgl_add_var(parser, "dat");
- mgl_data_set_float(d,a,100,1,1); // set data to variable
+ mgl_data_set_mreal(d,a,100,1,1); // set data to variable
mgl_parse_text(gr, parser, "plot dat; xrange 0 1\nbox\naxis");
// you may break script at any line do something
// and continue after that
}
@end verbatim
-@fig{png/parser, Example of MGL script parsing.}
+@pfig{parser, Example of MGL script parsing.}
@c ------------------------------------------------------------------
+@external
@node ``Templates'', Nonlinear fitting sample, MGL parser using, Hints
@subsection ``Templates''
I understand that this is obvious thing for any professional programmer, but I several times receive suggestion about ``templates'' ... So, I decide to point out it here.
@c ------------------------------------------------------------------
+@external
@node Stereo image, , ``Templates'', Hints
@subsection Stereo image
}
@end verbatim
-@fig{png/stereo, Example of stereo image.}
+@pfig{stereo, Example of stereo image.}
+@external
@node FAQ, , Hints, Examples
@section FAQ
@table @strong
@item The plot does not appear
-Check that points of the plot lie inside the bounding box and resize the bounding box using @code{Axis()} function. Check that the data have correct dimensions for selected type of plot. Be sure that @code{Finish()} is called after the plotting functions (or be sure that the plot is saved to a file). Sometimes the light reflection from flat surfaces (like, @code{Dens()}) can look as if the plot were absent.
+Check that points of the plot are located inside the bounding box and resize the bounding box using @code{SetRange()}/@code{SetRanges()} function. Check that the data have correct dimensions for selected type of plot. Be sure that @code{Finish()} is called after the plotting functions (or be sure that the plot is saved to a file). Sometimes the light reflection from flat surfaces (like, @code{Dens()}) can look as if the plot were absent.
@item I can not find some special kind of plot.
Most ``new'' types of plots can be created by using the existing drawing functions. For example, the surface of curve rotation can be created by a special function @code{Torus()}, or as a parametrically specified surface by @code{Surf()}. See also, @ref{Hints}. If you can not find a specific type of plot, please e-mail me and this plot will appear in the next version of MathGL library.
No. The MathGL library is self-contained and does not require the knowledge of external libraries.
@item In which language is the library written? For which languages does it have an interface?
-The core of the MathGL library is written in C++. But there are interfaces for: pure C, Fortran, Pascal, Forth, and its own command language MGL. Also there is a large set of interpreted languages, which are supported (Python, Java, ALLEGROCL, CHICKEN, Lisp, CFFI, C#, Guile, Lua, Modula 3, Mzscheme, Ocaml, Octave, Perl, PHP, Pike, R, Ruby, Tcl). These interfaces are written using SWIG (both pure C functions and classes) but only the interface for Python and Octave is included in the autoconf/automake script. The reason is that I don't know any other interpreted languages :(. Note that most other languages can use (link to) the pure C functions.
+The core of the MathGL library is written in C++. But there are interfaces for: pure C, Fortran, Pascal, Forth, and its own command language MGL. Also there is a large set of interpreted languages, which are supported (Python, Java, ALLEGROCL, CHICKEN, Lisp, CFFI, C#, Guile, Lua, Modula 3, Mzscheme, Ocaml, Octave, Perl, PHP, Pike, R, Ruby, Tcl). These interfaces are written using SWIG (both pure C functions and classes) but only the interface for Python and Octave is included in the build system. The reason is that I don't know any other interpreted languages :(. Note that most other languages can use (link to) the pure C functions.
@item How can I use MathGL with Fortran?
You can use MathGL as is with @code{gfortran} because it uses by default the AT&T notation for external functions. For other compilers (like Visual Fortran) you have to switch on the AT&T notation manually. The AT&T notation requires that the symbol @samp{_} is added at the end of each function name, function argument(s) is passed by pointers and the string length(s) is passed at the end of the argument list. For example:
The standard way is to use Unicode encoding for the text output. But the MathGL library also has interface for 8-bit (char *) strings with internal conversion to Unicode. This conversion depends on the current locale OS. You may change it by @code{setlocale()} function. For example, for Russian text in CP1251 encoding you may use @code{setlocale(LC_CTYPE, "ru_RU.cp1251");} (under MS Windows the name of locale may differ -- @code{setlocale(LC_CTYPE, "russian_russia.1251")}). I strongly recommend not to use the constant @code{LC_ALL} in the conversion. Since it also changes the number format, it may lead to mistakes in formula writing and reading of the text in data files. For example, the program will await a @samp{,} as a decimal point but the user will enter @samp{.}.
@item How can I exclude a point or a region of plot from the drawing?
-There are 3 general ways. First, the point with @code{NAN} value as one of the coordinates will never be plotted. Second, special variables @var{CutMin}, @var{CutMax} or function @code{CutOff}() define the condition when the points should be omitted (see @ref{Cutting}). Last, you may change the transparency of a part of the plot by the help of functions @code{SurfA()}, @code{Surf3A()} (see @ref{Dual plotting}). In this last case the transparency is switched on smoothly.
+There are 3 general ways. First, the point with @code{NAN} value as one of the coordinates (including color/alpha range) will never be plotted. Second, special functions @code{SetCutBox}() and @code{CutOff}() define the condition when the points should be omitted (see @ref{Cutting}). Last, you may change the transparency of a part of the plot by the help of functions @code{SurfA()}, @code{Surf3A()} (see @ref{Dual plotting}). In last case the transparency is switched on smoothly.
@item I use VisualStudio, CBuilder or some other compiler (not MinGW/gcc). How can I link the MathGL library?
-In version 2.0, the recommended class @code{mglGraph} (header file @code{#include <mgl2/mgl.h>}) contains only @code{inline} functions and is acceptable for any compiler with the same binary files. However, if you plan to access low-level features (i.e. classes mglBase, mglCanvas and so on) then you have to recompile MathGL by yours compiler.
-
-@c @strong{Finally!} Please @emph{do not} ask me Windows-specific questions. I do not use Windows. I know nothing about Visual Basic, Visual C++, CBuiled or .NET. Please find the appropriate Usenet discussion group and ask your question there.
+In version 2.0, main classes (@code{mglGraph} and @code{mglData}) contains only @code{inline} functions and are acceptable for any compiler with the same binary files. However, if you plan to use widget classes (QMathGL, Fl_MathGL, ...) or to access low-level features (mglBase, mglCanvas, ...) then you have to recompile MathGL by yours compiler.
@item How I can build MathGL under Windows?
-The simplest way is using the combination CMake+MinGW. Also you need some extra libraries like GSL, PNG, JPEG and so on. All of them can be found at @url{http://gnuwin32.sourceforge.net/packages.html}. After installing all components, just run CMake configurator and make the MathGL itself.
+Generally, it is the same procedure as for Linux or MacOS -- see section @ref{Installation}. The simplest way is using the combination CMake+MinGW. Also you may need some extra libraries like GSL, PNG, JPEG and so on. All of them can be found at @url{http://gnuwin32.sourceforge.net/packages.html}. After installing all components, just run @uref{http://www.cmake.org/cmake/help/runningcmake.html, cmake-gui} configurator and build the MathGL itself.
@item How many people write this library?
-Most of the library was written by one person. This is a result of nearly a year of work (mostly in the evening and on holidays): I spent half a year to write the kernel and half a year to a year on extending, improving the library and writing documentation. This process continues now :). The autoconf/automake script was written mostly by D.Kulagin, and the export to IDTF was written mostly by M.Vidassov.
+Most of the library was written by one person. This is a result of nearly a year of work (mostly in the evening and on holidays): I spent half a year to write the kernel and half a year to a year on extending, improving the library and writing documentation. This process continues now :). The build system (cmake files) was written mostly by D.Kulagin, and the export to PRC/IDTF was written mostly by M.Vidassov.
@item How can I display a bitmap on the figure?
You can import data into a @code{mglData} instance and display it by @code{Dens()} function. For example, for black-and-white bitmap you can use the code: @code{mglData bmp; bmp.Import("fname.png","wk"); gr->Dens(bmp,"wk");}.
@item How can I use MathGL in Qt, FLTK, wxWidgets etc.?
-There are special classes (widgets) for these libraries: QMathGL for Qt, Fl_MathGL for FLTK and so on. If you don't find the appropriate class then you can create your own widget that displays a bitmap using mglCanvas::GetBits().
+There are special classes (widgets) for these libraries: QMathGL for Qt, Fl_MathGL for FLTK and so on. If you don't find the appropriate class then you can create your own widget that displays a bitmap using mglCanvas::GetRGB().
@item How can I create U3D file (make 3D in PDF)?
There are 2 steps: first you should create IDTF file, and later convert it to U3D. You can use @uref{http://sourceforge.net/project/showfiles.php?group_id=152187&package_id=300628, U3D tools} for converting IDTF file to U3D. It needs @uref{http://libharu.org, libharu} 2.1.0 or later. For installation use @code{./bootstrap, ./configure, make, sudo make install}. It provides IDTFConverter program for converting text files *.idtf to binary files *.u3d. The latter can be included into PDF.
Just use @code{SetRotatedText(false)}.
@item What is @code{*.so}? What is @code{gcc}? How I can use @code{make}?
-This standard GNU tool. There is special FAQ about its usage under Windows -- @uref{http://www.mingw.org/wiki/FAQ}.
+They are standard GNU tools. There is special FAQ about its usage under Windows -- @uref{http://www.mingw.org/wiki/FAQ}.
@end table
+@external
+
@end menu
@c ------------------------------------------------------------------
+@external
@node Basic usage, Advanced usage, , Examples
@section Basic usage
@item
@emph{Drawing in memory with the following displaying by other graphical program.}
-In this case the programmer has more freedom in selecting the window libraries (not only FLTK, Qt or GLUT), in positioning and surroundings control and so on. I recommend to use such way for ``settled'' programs.
+In this case the programmer has more freedom in selecting the window libraries (not only FLTK, Qt or GLUT), in positioning and surroundings control and so on. I recommend to use such way for ``stand alone'' programs.
@item
@emph{Using FLTK or Qt widgets provided by MathGL}
@c ------------------------------------------------------------------
+@external
@node Using MathGL window, Drawing to file, , Basic usage
@subsection Using MathGL window
@cindex window
return gr.Run();
}
@end verbatim
-Here function @code{sample} is defined. This function does all drawing. Other function @code{main} is entry point function for console program. For compilation, just execute the command
+Here callback function @code{sample} is defined. This function does all drawing. Other function @code{main} is entry point function for console program. For compilation, just execute the command
@verbatim
gcc test.cpp -lmgl-wnd -lmgl
@end verbatim
Or use pure C-functions:
@verbatim
#include <mgl2/mgl_cf.h>
-int sample(HMGL gr)
+int sample(HMGL gr, void *)
{
mgl_rotate(gr,60,40,0);
mgl_box(gr);
In this example function @code{sample} rotates axes (@code{Rotate()}, @pxref{Subplots and rotation}) and draws the bounding box (@code{Box()}). Drawing is placed in separate function since it will be used on demand when window canvas needs to be redrawn.
@c ------------------------------------------------------------------
+@external
@node Drawing to file, Animation, Using MathGL window, Basic usage
@subsection Drawing to file
The only difference from the previous variant (using windows) is manual switching on the transparency @code{Alpha} and lightning @code{Light}, if you need it. The usage of frames (see @ref{Animation}) is not advisable since the whole image is prepared each time. If function @code{sample} contains frames then only last one will be saved to the file. In principle, one does not need to separate drawing functions in case of direct file writing in consequence of the single calling of this function for each picture. However, one may use the same drawing procedure to create a plot with changeable parameters, to export in different file types, to emphasize the drawing code and so on. So, in future I will put the drawing in the separate function.
-The code for export in vector EPS file looks the same:
+The code for export into other formats (for example, into vector EPS file) looks the same:
@verbatim
#include <mgl2/mgl.h>
int main(int ,char **)
The difference from the previous one is using other function @code{WriteEPS()} for EPS format instead of function @code{WritePNG()}. Also, there is no switching on of the plot transparency @code{Alpha} since EPS format does not support it.
@c ------------------------------------------------------------------
+@external
@node Animation, Drawing in memory, Drawing to file, Basic usage
@subsection Animation
return gr->GetNumFrame(); // returns the frame number
}
@end verbatim
-First, the function creates a frame @code{NewFrame()} for rotated axes and draws the bounding box. After the frame drawing the function @code{EndFrame()} @strong{must be} called! The second frame contains the bounding box and axes @code{Axis("xy")} in the initial (unrotated) coordinates. Function @code{sample} returns the number of created frames @code{GetNumFrame()}.
+First, the function creates a frame by calling @code{NewFrame()} for rotated axes and draws the bounding box. The function @code{EndFrame()} @strong{must be} called after the frame drawing! The second frame contains the bounding box and axes @code{Axis("xy")} in the initial (unrotated) coordinates. Function @code{sample} returns the number of created frames @code{GetNumFrame()}.
Note, that such kind of animation is rather slow and not well suitable for visualization of running calculations. For the last case one can use @code{Update()} function. The most simple case for doing this is to use @code{mglDraw} class and reimplement its @code{Calc()} method.
@verbatim
{
for(int i=0;i<30;i++) // do calculation
{
- sleep(2); // which can be very long
+ sleep(2); // which can be very long
pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);
- Gr->Update(); // update window
+ Gr->Update(); // update window
}
}
//-----------------------------------------------------
pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);
gr.Clf(); // make new drawing
gr.Line(mglPoint(),pnt,"Ar2");
- char str[10] = "i=0"; str[3] = '0'+i;
+ char str[10] = "i=0"; str[2] = '0'+i;
gr.Puts(mglPoint(),"");
gr.Update(); // update window when you need it
}
Pictures with @strong{animation can be saved in file(s)} as well. You can: export in animated GIF, or save each frame in separate file (usually JPEG) and convert these files into the movie (for example, by help of ImageMagic). Let me show both methods.
+@anchor{GIF}
The simplest methods is making animated GIF. There are 3 steps: (1) open GIF file by @code{StartGIF()} function; (2) create the frames by calling @code{NewFrame()} before and @code{EndFrame()} after plotting; (3) close GIF by @code{CloseGIF()} function. So the simplest code for ``running'' sinusoid will look like this:
@verbatim
#include <mgl2/mgl.h>
}
@end verbatim
+@anchor{MPEG}
The second way is saving each frame in separate file (usually JPEG) and later make the movie from them. MathGL have special function for saving frames -- it is @code{WriteFrame()}. This function save each frame with automatic name @samp{frame0001.jpg, frame0002.jpg} and so on. Here prefix @samp{frame} is defined by @var{PlotId} variable of @code{mglGraph} class. So the similar code will look like this:
@verbatim
#include <mgl2/mgl.h>
Finally, you can use @code{mglconv} tool for doing the same with MGL scripts (@pxref{Utilities}).
@c ------------------------------------------------------------------
+@external
@node Drawing in memory, Using QMathGL, Animation, Basic usage
@subsection Drawing in memory
gr.Light(true);
sample(&gr,NULL);
- wxImage img(w,h,gr.GetBits(),true);
+ wxImage img(w,h,gr.GetRGB(),true);
ToolBar->GetSize(&x,&y); // gets a height of the toolbar if any
wxPaintDC dc(this); // and draws it
dc.DrawBitmap(wxBitmap(img),0,y);
gr.Alpha(true); // draws something using MathGL
gr.Light(true);
sample(&gr,NULL);
- fl_draw_image(gr.GetBits(), x(), y(), gr.GetWidth(), gr.GetHeight(), 3);
+ fl_draw_image(gr.GetRGB(), x(), y(), gr.GetWidth(), gr.GetHeight(), 3);
}
@end verbatim
Qt code will look like
@end verbatim
@c ------------------------------------------------------------------
+@external
@node Using QMathGL, MathGL and PyQt, Drawing in memory, Basic usage
@subsection Using QMathGL
@end verbatim
@c ------------------------------------------------------------------
+@external
@node MathGL and PyQt, , Using QMathGL, Basic usage
@subsection MathGL and PyQt
@c ------------------------------------------------------------------
+@external
@node Advanced usage, Data handling, Basic usage, Examples
@section Advanced usage
@end menu
@c ------------------------------------------------------------------
+@external
@node Subplots, Axis and ticks, , Advanced usage
@subsection Subplots
@end verbatim
Here I used function @code{Puts} for printing the text in arbitrary position of picture (see @ref{Text printing}). Text coordinates and size are connected with axes. However, text coordinates may be everywhere, including the outside the bounding box. I'll show its features later in @ref{Text features}.
-@fig{png/aspect, Example of several subplots on the single picture.}
+@pfig{aspect, Example of several subplots on the single picture.}
More complicated sample show how to use most of positioning functions:
@verbatim
}
@end verbatim
-@fig{png/inplot, Example for most of positioning functions.}
+@pfig{inplot, Example for most of positioning functions.}
@c ------------------------------------------------------------------
+@external
@node Axis and ticks, Curvilinear coordinates, Subplots, Advanced usage
@subsection Axis and ticks
Note, that MathGL can draw not only single axis (which is default). But also several axis on the plot (see right plots). The idea is that the change of settings does not influence on the already drawn graphics. So, for 2-axes I setup the first axis and draw everything concerning it. Then I setup the second axis and draw things for the second axis. Generally, the similar idea allows one to draw rather complicated plot of 4 axis with different ranges (see bottom left plot).
-@fig{png/axis, Example of axis.}
+@pfig{axis, Example of axis.}
Another MathGL feature is fine ticks tunning. By default (if it is not changed by @code{SetTicks} function), MathGL try to adjust ticks positioning, so that they looks most human readable. At this, MathGL try to extract common factor for too large or too small axis ranges, as well as for too narrow ranges. Last one is non-common notation and can be disabled by @code{SetTuneTicks} function.
gr->SetTuneTicks(0); gr->Axis();
gr->SubPlot(3,2,2); gr->Title("Manual ticks"); gr->SetRanges(-M_PI,M_PI, 0, 2);
- float val[]={-M_PI, -M_PI/2, 0, 0.886, M_PI/2, M_PI};
+ mreal val[]={-M_PI, -M_PI/2, 0, 0.886, M_PI/2, M_PI};
gr->SetTicksVal('x', mglData(6,val), "-\\pi\n-\\pi/2\n0\nx^*\n\\pi/2\n\\pi");
gr->Axis(); gr->Grid(); gr->FPlot("2*cos(x^2)^2", "r2");
}
@end verbatim
-@fig{png/ticks, Features of axis ticks.}
+@pfig{ticks, Features of axis ticks.}
The last sample I want to show in this subsection is Log-axis. From MathGL's point of vew, the log-axis is particular case of general curvilinear coordinates. So, we need first define new coordinates (see also @ref{Curvilinear coordinates}) by help of @code{SetFunc} or @code{SetCoor} functions. At this one should wary about proper axis range. So the code looks as following:
@verbatim
}
@end verbatim
-@fig{png/loglog, Features of axis ticks.}
+@pfig{loglog, Features of axis ticks.}
You can see that MathGL automatically switch to log-ticks as we define log-axis formula (in difference from v.1.*). Moreover, it switch to log-ticks for any formula if axis range will be large enough (see right bottom plot). Another interesting feature is that you not necessary define usual log-axis (i.e. when coordinates are positive), but you can define ``minus-log'' axis when coordinate is negative (see left bottom plot).
@c ------------------------------------------------------------------
+@external
@node Curvilinear coordinates, Colorbars, Axis and ticks, Advanced usage
@subsection Curvilinear coordinates
}
@end verbatim
-@fig{png/curvcoor, Example of curvilinear coordinates}
+@pfig{curvcoor, Example of curvilinear coordinates}
@c ------------------------------------------------------------------
+@external
@node Colorbars, Bounding box, Curvilinear coordinates, Advanced usage
@subsection Colorbars
}
@end verbatim
-@fig{png/colorbar, Example of colorbars}
+@pfig{colorbar, Example of colorbars}
@c ------------------------------------------------------------------
+@external
@node Bounding box, Ternary axis, Colorbars, Advanced usage
@subsection Bounding box
}
@end verbatim
-@fig{png/box, Example of Box()}
+@pfig{box, Example of Box()}
@c ------------------------------------------------------------------
+@external
@node Ternary axis, Text features, Bounding box, Advanced usage
@subsection Ternary axis
}
@end verbatim
-@fig{png/ternary, Example of colorbars}
+@pfig{ternary, Example of colorbars}
@c ------------------------------------------------------------------
+@external
@node Text features, Legend sample, Ternary axis, Advanced usage
@subsection Text features
}
@end verbatim
-@fig{png/text, Example of text printing}
+@pfig{text, Example of text printing}
@c ------------------------------------------------------------------
+@external
@node Legend sample, Cutting sample, Text features, Advanced usage
@subsection Legend sample
}
@end verbatim
-@fig{png/legend, Example of legend}
+@pfig{legend, Example of legend}
@c ------------------------------------------------------------------
+@external
@node Cutting sample, , Legend sample, Advanced usage
@subsection Cutting sample
}
@end verbatim
-@fig{png/cut, Example of point cutting}
+@pfig{cut, Example of point cutting}
@c ------------------------------------------------------------------
+@external
@node Data handling, Data plotting, Advanced usage, Examples
@section Data handling
-Class @code{mglData} contains all functions for the data handling in MathGL (@pxref{Data processing}). There are several matters why I use class @code{mglData} but not a single array: it does not depend on type of data (float or double), sizes of data arrays are kept with data, memory working is simpler and safer.
+Class @code{mglData} contains all functions for the data handling in MathGL (@pxref{Data processing}). There are several matters why I use class @code{mglData} but not a single array: it does not depend on type of data (mreal or double), sizes of data arrays are kept with data, memory working is simpler and safer.
@menu
* Array creation::
@end menu
@c ------------------------------------------------------------------
+@external
@node Array creation, Change data, , Data handling
@subsection Array creation
z.Modify("sin(pi*x)*cos(pi*y)");
@end verbatim
-The only non-obvious thing here is using multidimensional arrays in C/C++, i.e. arrays defined like @code{float dat[40][30];}. Since, formally these elements @code{dat[i]} can address the memory in arbitrary place you should use the proper function to convert such arrays to @code{mglData} object. For C++ this is functions like @code{mglData::Set(float **dat, int N1, int N2);}. For C this is functions like @code{mgl_data_set_float2(HMDT d, const float **dat, int N1, int N2);}. At this, you should keep in mind that @code{nx=N2} and @code{ny=N1} after conversion.
+The only non-obvious thing here is using multidimensional arrays in C/C++, i.e. arrays defined like @code{mreal dat[40][30];}. Since, formally these elements @code{dat[i]} can address the memory in arbitrary place you should use the proper function to convert such arrays to @code{mglData} object. For C++ this is functions like @code{mglData::Set(mreal **dat, int N1, int N2);}. For C this is functions like @code{mgl_data_set_mreal2(HMDT d, const mreal **dat, int N1, int N2);}. At this, you should keep in mind that @code{nx=N2} and @code{ny=N1} after conversion.
@c ------------------------------------------------------------------
+@external
@node Linking array, Change data, Array creation, Data handling
@subsection Linking array
@end verbatim
@c ------------------------------------------------------------------
+@external
@node Change data, , Linking array, Data handling
@subsection Change data
}
@end verbatim
-@fig{png/dat_diff, Example of data differentiation and integration}
+@pfig{dat_diff, Example of data differentiation and integration}
Data smoothing (function @code{Smooth()}) is more interesting and important. This function has single argument which define type of smoothing and its direction. Now 3 methods are supported: @samp{3} -- linear averaging by 3 points, @samp{5} -- linear averaging by 5 points, and default one -- quadratic averaging by 5 points.
}
@end verbatim
-@fig{png/dat_extra, Example of data smoothing}
+@pfig{dat_extra, Example of data smoothing}
Finally one can create new data arrays on base of the existing one: extract slice, row or column of data (@code{SubData()}), summarize along a direction(s) (@code{Sum()}), find distribution of data elements (@code{Hist()}) and so on.
@c ------------------------------------------------------------------
+@external
@node Data plotting, 1D samples, Data handling, Examples
@section Data plotting
@end verbatim
@c ------------------------------------------------------------------
+@external
@node 1D samples, 2D samples, Data plotting, Examples
@section 1D samples
if(y) y->Create(n,3);
if(x1) x1->Create(n); if(x2) x2->Create(n);
if(y1) y1->Create(n); if(y2) y2->Create(n);
- float xx;
+ mreal xx;
for(i=0;i<n;i++)
{
xx = i/(n-1.);
if(x2) mgl_data_create(x2,n,1,1);
if(y1) mgl_data_create(y1,n,1,1);
if(y2) mgl_data_create(y2,n,1,1);
- float xx;
+ mreal xx;
for(i=0;i<n;i++)
{
xx = i/(n-1.);
@c ------------------------------------------------------------------
+@external
@node Plot sample, Radar sample, , 1D samples
@subsection Plot sample
}
@end verbatim
-@fig{png/plot, Example of Plot()}
+@pfig{plot, Example of Plot()}
@c ------------------------------------------------------------------
+@external
@node Radar sample, Step sample, Plot sample, 1D samples
@subsection Radar sample
}
@end verbatim
-@fig{png/radar, Example of Radar()}
+@pfig{radar, Example of Radar()}
@c ------------------------------------------------------------------
+@external
@node Step sample, Tens sample, Radar sample, 1D samples
@subsection Step sample
}
@end verbatim
-@fig{png/step, Example of Step()}
+@pfig{step, Example of Step()}
@c ------------------------------------------------------------------
+@external
@node Tens sample, Area sample, Step sample, 1D samples
@subsection Tens sample
}
@end verbatim
-@fig{png/tens, Example of Tens()}
+@pfig{tens, Example of Tens()}
@c ------------------------------------------------------------------
+@external
@node Area sample, Region sample, Tens sample, 1D samples
@subsection Area sample
}
@end verbatim
-@fig{png/area, Example of Area()}
+@pfig{area, Example of Area()}
@c ------------------------------------------------------------------
+@external
@node Region sample, Stem sample, Area sample, 1D samples
@subsection Region sample
}
@end verbatim
-@fig{png/region, Example of Region()}
+@pfig{region, Example of Region()}
@c ------------------------------------------------------------------
+@external
@node Stem sample, Bars sample, Region sample, 1D samples
@subsection Stem sample
}
@end verbatim
-@fig{png/stem, Example of Stem()}
+@pfig{stem, Example of Stem()}
@c ------------------------------------------------------------------
+@external
@node Bars sample, Barh sample, Stem sample, 1D samples
@subsection Bars sample
}
@end verbatim
-@fig{png/bars, Example of Bars()}
+@pfig{bars, Example of Bars()}
@c ------------------------------------------------------------------
+@external
@node Barh sample, Cones sample, Bars sample, 1D samples
@subsection Barh sample
}
@end verbatim
-@fig{png/barh, Example of Barh()}
+@pfig{barh, Example of Barh()}
@c ------------------------------------------------------------------
+@external
@node Cones sample, Chart sample, Bars sample, 1D samples
@subsection Cones sample
}
@end verbatim
-@fig{png/cones, Example of Cones()}
+@pfig{cones, Example of Cones()}
@c ------------------------------------------------------------------
+@external
@node Chart sample, BoxPlot sample, Cones sample, 1D samples
@subsection Chart sample
}
@end verbatim
-@fig{png/chart, Example of Chart()}
+@pfig{chart, Example of Chart()}
@c ------------------------------------------------------------------
+@external
@node BoxPlot sample, Candle sample, Chart sample, 1D samples
@subsection BoxPlot sample
}
@end verbatim
-@fig{png/boxplot, Example of BoxPlot()}
+@pfig{boxplot, Example of BoxPlot()}
@c ------------------------------------------------------------------
+@external
@node Candle sample, Error sample, BoxPlot sample, 1D samples
@subsection Candle sample
}
@end verbatim
-@fig{png/candle, Example of Candle()}
+@pfig{candle, Example of Candle()}
@c ------------------------------------------------------------------
+@external
@node Error sample, Mark sample, Candle sample, 1D samples
@subsection Error sample
{
mglData y; mgls_prepare1d(&y);
mglData x0(10), y0(10), ex0(10), ey0(10);
- float x;
+ mreal x;
for(int i=0;i<10;i++)
{
x = i/9.;
}
@end verbatim
-@fig{png/error, Example of Error()}
+@pfig{error, Example of Error()}
@c ------------------------------------------------------------------
+@external
@node Mark sample, TextMark sample, Error sample, 1D samples
@subsection Mark sample
}
@end verbatim
-@fig{png/mark, Example of Mark()}
+@pfig{mark, Example of Mark()}
@c ------------------------------------------------------------------
+@external
@node TextMark sample, Label sample, Mark sample, 1D samples
@subsection TextMark sample
}
@end verbatim
-@fig{png/textmark, Example of TextMark()}
+@pfig{textmark, Example of TextMark()}
@c ------------------------------------------------------------------
+@external
@node Label sample, Tube sample, TextMark sample, 1D samples
@subsection Label sample
}
@end verbatim
-@fig{png/label, Example of Label()}
+@pfig{label, Example of Label()}
@c ------------------------------------------------------------------
+@external
@node Tube sample, Tape sample, Label sample, 1D samples
@subsection Tube sample
}
@end verbatim
-@fig{png/tube, Example of Tube()}
+@pfig{tube, Example of Tube()}
@c ------------------------------------------------------------------
+@external
@node Tape sample, Torus sample, Tube sample, 1D samples
@subsection Tape sample
}
@end verbatim
-@fig{png/tape, Example of Tape()}
+@pfig{tape, Example of Tape()}
@c ------------------------------------------------------------------
+@external
@node Torus sample, , Tape sample, 1D samples
@subsection Torus sample
}
@end verbatim
-@fig{png/torus, Example of Torus()}
+@pfig{torus, Example of Torus()}
@c ------------------------------------------------------------------
+@external
@node 2D samples, 3D samples, 1D samples, Examples
@section 2D samples
register long i,j,n=50,m=40,i0;
if(a) a->Create(n,m); if(b) b->Create(n,m);
if(v) { v->Create(9); v->Fill(-1,1); }
- float x,y;
+ mreal x,y;
for(i=0;i<n;i++) for(j=0;j<m;j++)
{
x = i/(n-1.); y = j/(m-1.); i0 = i+n*j;
if(a) mgl_data_create(a,n,m,1);
if(b) mgl_data_create(b,n,m,1);
if(v) { mgl_data_create(v,9,1,1); mgl_data_fill(v,-1,1,'x'); }
- float x,y;
+ mreal x,y;
for(i=0;i<n;i++) for(j=0;j<m;j++)
{
x = i/(n-1.); y = j/(m-1.); i0 = i+n*j;
@end menu
@c ------------------------------------------------------------------
+@external
@node Surf sample, SurfC sample, , 2D samples
@subsection Surf sample
}
@end verbatim
-@fig{png/surf, Example of Surf()}
+@pfig{surf, Example of Surf()}
@c ------------------------------------------------------------------
+@external
@node SurfC sample, SurfA sample, Surf sample, 2D samples
@subsection SurfC sample
}
@end verbatim
-@fig{png/surfc, Example of SurfC()}
+@pfig{surfc, Example of SurfC()}
@c ------------------------------------------------------------------
+@external
@node SurfA sample, Mesh sample, SurfC sample, 2D samples
@subsection SurfA sample
}
@end verbatim
-@fig{png/surfa, Example of SurfA()}
+@pfig{surfa, Example of SurfA()}
@c ------------------------------------------------------------------
+@external
@node Mesh sample, Fall sample, SurfA sample, 2D samples
@subsection Mesh sample
}
@end verbatim
-@fig{png/mesh, Example of Mesh()}
+@pfig{mesh, Example of Mesh()}
@c ------------------------------------------------------------------
+@external
@node Fall sample, Belt sample, Mesh sample, 2D samples
@subsection Fall sample
}
@end verbatim
-@fig{png/fall, Example of Fall()}
+@pfig{fall, Example of Fall()}
@c ------------------------------------------------------------------
+@external
@node Belt sample, Boxs sample, Fall sample, 2D samples
@subsection Belt sample
}
@end verbatim
-@fig{png/belt, Example of Belt()}
+@pfig{belt, Example of Belt()}
@c ------------------------------------------------------------------
+@external
@node Boxs sample, Tile sample, Fall sample, 2D samples
@subsection Boxs sample
}
@end verbatim
-@fig{png/boxs, Example of Boxs()}
+@pfig{boxs, Example of Boxs()}
@c ------------------------------------------------------------------
+@external
@node Tile sample, TileS sample, Boxs sample, 2D samples
@subsection Tile sample
}
@end verbatim
-@fig{png/tile, Example of Tile()}
+@pfig{tile, Example of Tile()}
@c ------------------------------------------------------------------
+@external
@node TileS sample, Dens sample, Tile sample, 2D samples
@subsection TileS sample
}
@end verbatim
-@fig{png/tiles, Example of TileS()}
+@pfig{tiles, Example of TileS()}
@c ------------------------------------------------------------------
+@external
@node Dens sample, Cont sample, TileS sample, 2D samples
@subsection Dens sample
}
@end verbatim
-@fig{png/dens, Example of Dens()}
+@pfig{dens, Example of Dens()}
@c ------------------------------------------------------------------
+@external
@node Cont sample, ContF sample, Dens sample, 2D samples
@subsection Cont sample
}
@end verbatim
-@fig{png/cont, Example of Cont()}
+@pfig{cont, Example of Cont()}
@c ------------------------------------------------------------------
+@external
@node ContF sample, ContD sample, Cont sample, 2D samples
@subsection ContF sample
}
@end verbatim
-@fig{png/contf, Example of ContF()}
+@pfig{contf, Example of ContF()}
@c ------------------------------------------------------------------
+@external
@node ContD sample, ContV sample, ContF sample, 2D samples
@subsection ContD sample
}
@end verbatim
-@fig{png/contd, Example of ContD()}
+@pfig{contd, Example of ContD()}
@c ------------------------------------------------------------------
+@external
@node ContV sample, Axial sample, ContD sample, 2D samples
@subsection ContV sample
}
@end verbatim
-@fig{png/contv, Example of ContV()}
+@pfig{contv, Example of ContV()}
@c ------------------------------------------------------------------
+@external
@node Axial sample, Grad sample, ContV sample, 2D samples
@subsection Axial sample
}
@end verbatim
-@fig{png/axial, Example of Axial()}
+@pfig{axial, Example of Axial()}
@c ------------------------------------------------------------------
+@external
@node Grad sample, , Axial sample, 2D samples
@subsection Grad sample
}
@end verbatim
-@fig{png/grad, Example of Grad()}
+@pfig{grad, Example of Grad()}
@c ------------------------------------------------------------------
+@external
@node 3D samples, Vector field samples, 2D samples, Examples
@section 3D samples
{
register long i,j,k,n=61,m=50,l=40,i0;
if(a) a->Create(n,m,l); if(b) b->Create(n,m,l);
- float x,y,z;
+ mreal x,y,z;
for(i=0;i<n;i++) for(j=0;j<m;j++) for(k=0;k<l;k++)
{
x=2*i/(n-1.)-1; y=2*j/(m-1.)-1; z=2*k/(l-1.)-1; i0 = i+n*(j+m*k);
register long i,j,k,n=61,m=50,l=40,i0;
if(a) mgl_data_create(a,n,m,l);
if(b) mgl_data_create(b,n,m,l);
- float x,y,z;
+ mreal x,y,z;
for(i=0;i<n;i++) for(j=0;j<m;j++) for(k=0;k<l;k++)
{
x=2*i/(n-1.)-1; y=2*j/(m-1.)-1; z=2*k/(l-1.)-1; i0 = i+n*(j+m*k);
@end menu
@c ------------------------------------------------------------------
+@external
@node Surf3 sample, Surf3C sample, , 3D samples
@subsection Surf3 sample
}
@end verbatim
-@fig{png/surf3, Example of Surf3()}
+@pfig{surf3, Example of Surf3()}
@c ------------------------------------------------------------------
+@external
@node Surf3C sample, Surf3A sample, Surf3 sample, 3D samples
@subsection Surf3C sample
}
@end verbatim
-@fig{png/surf3c, Example of Surf3C()}
+@pfig{surf3c, Example of Surf3C()}
@c ------------------------------------------------------------------
+@external
@node Surf3A sample, Cloud sample, Surf3C sample, 3D samples
@subsection Surf3A sample
}
@end verbatim
-@fig{png/surf3a, Example of Surf3A()}
+@pfig{surf3a, Example of Surf3A()}
@c ------------------------------------------------------------------
+@external
@node Cloud sample, Dens3 sample, Surf3A sample, 3D samples
@subsection Cloud sample
}
@end verbatim
-@fig{png/cloud, Example of Cloud()}
+@pfig{cloud, Example of Cloud()}
@c ------------------------------------------------------------------
+@external
@node Dens3 sample, Cont3 sample, Cloud sample, 3D samples
@subsection Dens3 sample
}
@end verbatim
-@fig{png/densa, Example of Dens3()}
+@pfig{densa, Example of Dens3()}
@c ------------------------------------------------------------------
+@external
@node Cont3 sample, ContF3 sample, Dens3 sample, 3D samples
@subsection Cont3 sample
}
@end verbatim
-@fig{png/conta, Example of Cont3()}
+@pfig{conta, Example of Cont3()}
@c ------------------------------------------------------------------
+@external
@node ContF3 sample, Dens projection sample, Cont3 sample, 3D samples
@subsection ContF3 sample
}
@end verbatim
-@fig{png/contfa, Example of ContF3()}
+@pfig{contfa, Example of ContF3()}
@c ------------------------------------------------------------------
+@external
@node Dens projection sample, Cont projection sample, ContF3 sample, 3D samples
@subsection Dens projection sample
}
@end verbatim
-@fig{png/dens_xyz, {Example of DensX(), DensY(), DensZ()}}
+@pfig{dens_xyz, {Example of DensX(), DensY(), DensZ()}}
@c ------------------------------------------------------------------
+@external
@node Cont projection sample, ContF projection sample, Dens projection sample, 3D samples
@subsection Cont projection sample
}
@end verbatim
-@fig{png/cont_xyz, {Example of ContX(), ContY(), ContZ()}}
+@pfig{cont_xyz, {Example of ContX(), ContY(), ContZ()}}
@c ------------------------------------------------------------------
+@external
@node ContF projection sample, TriPlot and QuadPlot, Cont projection sample, 3D samples
@subsection ContF projection sample
}
@end verbatim
-@fig{png/contf_xyz, {Example of ContFX(), ContFY(), ContFZ()}}
+@pfig{contf_xyz, {Example of ContFX(), ContFY(), ContFZ()}}
@c ------------------------------------------------------------------
+@external
@node TriPlot and QuadPlot, Axial sample, ContF projection sample, 3D samples
@subsection TriPlot and QuadPlot
@verbatim
int sample(mglGraph *gr)
{
- float q[] = {0,1,2,3, 4,5,6,7, 0,2,4,6, 1,3,5,7, 0,4,1,5, 2,6,3,7};
- float xc[] = {-1,1,-1,1,-1,1,-1,1}, yc[] = {-1,-1,1,1,-1,-1,1,1}, zc[] = {-1,-1,-1,-1,1,1,1,1};
+ mreal q[] = {0,1,2,3, 4,5,6,7, 0,2,4,6, 1,3,5,7, 0,4,1,5, 2,6,3,7};
+ mreal xc[] = {-1,1,-1,1,-1,1,-1,1}, yc[] = {-1,-1,1,1,-1,-1,1,1}, zc[] = {-1,-1,-1,-1,1,1,1,1};
mglData qq(6,4,q), xx(8,xc), yy(8,yc), zz(8,zc);
gr->Light(true); //gr->Alpha(true);
gr->SubPlot(2,1,0); gr->Title("QuadPlot sample"); gr->Rotate(50,60);
gr->QuadPlot(qq,xx,yy,zz,"yr");
gr->QuadPlot(qq,xx,yy,zz,"k#");
- float t[] = {0,1,2, 0,1,3, 0,2,3, 1,2,3};
- float xt[] = {-1,1,0,0}, yt[] = {-1,-1,1,0}, zt[] = {-1,-1,-1,1};
+ mreal t[] = {0,1,2, 0,1,3, 0,2,3, 1,2,3};
+ mreal xt[] = {-1,1,0,0}, yt[] = {-1,-1,1,0}, zt[] = {-1,-1,-1,1};
mglData tt(4,3,t), uu(4,xt), vv(4,yt), ww(4,zt);
gr->SubPlot(2,1,1); gr->Title("TriPlot sample"); gr->Rotate(50,60);
gr->TriPlot(tt,uu,vv,ww,"b");
}
@end verbatim
-@fig{png/triplot, Example of TriPlot() and QuadPlot()}
+@pfig{triplot, Example of TriPlot() and QuadPlot()}
@c ------------------------------------------------------------------
+@external
@node Dots sample, , TriPlot and QuadPlot, 3D samples
@subsection Dots sample
mglData x(n),y(n),z(n);
for(i=0;i<n;i++)
{
- float t=M_PI*(mgl_rnd()-0.5), f=2*M_PI*mgl_rnd();
+ mreal t=M_PI*(mgl_rnd()-0.5), f=2*M_PI*mgl_rnd();
x.a[i] = 0.9*cos(t)*cos(f);
y.a[i] = 0.9*cos(t)*sin(f);
z.a[i] = 0.6*sin(t);
}
@end verbatim
-@fig{png/dots, Example of Dots()}
+@pfig{dots, Example of Dots()}
@c ------------------------------------------------------------------
+@external
@node Vector field samples, Hints, 3D samples, Examples
@section Vector field samples
{
register long i,j,n=20,m=30,i0;
if(a) a->Create(n,m); if(b) b->Create(n,m);
- float x,y;
+ mreal x,y;
for(i=0;i<n;i++) for(j=0;j<m;j++)
{
x=i/(n-1.); y=j/(m-1.); i0 = i+n*j;
register long i,j,k,n=10,i0;
if(!ex || !ey || !ez) return;
ex->Create(n,n,n); ey->Create(n,n,n); ez->Create(n,n,n);
- float x,y,z, r1,r2;
+ mreal x,y,z, r1,r2;
for(i=0;i<n;i++) for(j=0;j<n;j++) for(k=0;k<n;k++)
{
x=2*i/(n-1.)-1; y=2*j/(n-1.)-1; z=2*k/(n-1.)-1; i0 = i+n*(j+k*n);
register long i,j,n=20,m=30,i0;
if(a) mgl_data_create(a,n,m,1);
if(b) mgl_data_create(b,n,m,1);
- float x,y;
+ mreal x,y;
for(i=0;i<n;i++) for(j=0;j<m;j++)
{
x=i/(n-1.); y=j/(m-1.); i0 = i+n*j;
mgl_data_create(ex,n,n,n);
mgl_data_create(ey,n,n,n);
mgl_data_create(ez,n,n,n);
- float x,y,z, r1,r2;
+ mreal x,y,z, r1,r2;
for(i=0;i<n;i++) for(j=0;j<n;j++) for(k=0;k<n;k++)
{
x=2*i/(n-1.)-1; y=2*j/(n-1.)-1; z=2*k/(n-1.)-1; i0 = i+n*(j+k*n);
@c ------------------------------------------------------------------
+@external
@node Vect sample, Traj sample, , Vector field samples
@subsection Vect sample
}
@end verbatim
-@fig{png/vect, Example of Vect()}
+@pfig{vect, Example of Vect()}
@c ------------------------------------------------------------------
+@external
@node Traj sample, Flow sample, Vect sample, Vector field samples
@subsection Traj sample
}
@end verbatim
-@fig{png/traj, Example of Traj()}
+@pfig{traj, Example of Traj()}
@c ------------------------------------------------------------------
+@external
@node Flow sample, Pipe sample, Traj sample, Vector field samples
@subsection Flow sample
}
@end verbatim
-@fig{png/flow, Example of Flow()}
+@pfig{flow, Example of Flow()}
@c ------------------------------------------------------------------
+@external
@node Pipe sample, Dew sample, Flow sample, Vector field samples
@subsection Pipe sample
}
@end verbatim
-@fig{png/pipe, Example of Pipe()}
+@pfig{pipe, Example of Pipe()}
@c ------------------------------------------------------------------
+@external
@node Dew sample, , Pipe sample, Vector field samples
@subsection Dew sample
}
@end verbatim
-@fig{png/dew, Example of Dew()}
+@pfig{dew, Example of Dew()}
@c ------------------------------------------------------------------
+@external
@node Hints, FAQ, Vector field samples, Examples
@section Hints
@end menu
@c ------------------------------------------------------------------
+@external
@node ``Compound'' graphics, Transparency and lighting, , Hints
@subsection ``Compound'' graphics
}
@end verbatim
-@fig{png/combined, Example of ``combined'' plots}
+@pfig{combined, Example of ``combined'' plots}
@c ------------------------------------------------------------------
+@external
@node Transparency and lighting, Types of transparency, ``Compound'' graphics, Hints
@subsection Transparency and lighting
}
@end verbatim
-@fig{png/alpha, Example of transparency and lightings}
+@pfig{alpha, Example of transparency and lightings}
@c ------------------------------------------------------------------
+@external
@node Types of transparency, Adding fog, Transparency and lighting, Hints
@subsection Types of transparency
}
@end verbatim
-@fig{png/type0, Example of @code{SetTranspType(0)}.}
-@fig{png/type1, Example of @code{SetTranspType(1)}.}
-@fig{png/type2, Example of @code{SetTranspType(2)}.}
+@pfig{type0, Example of @code{SetTranspType(0)}.}
+@pfig{type1, Example of @code{SetTranspType(1)}.}
+@pfig{type2, Example of @code{SetTranspType(2)}.}
@c ------------------------------------------------------------------
+@external
@node Adding fog, Several light sources, Types of transparency, Hints
@subsection Adding fog
}
@end verbatim
-@fig{png/fog, Example of @code{Fog()}.}
+@pfig{fog, Example of @code{Fog()}.}
@c ------------------------------------------------------------------
+@external
@node Several light sources, Using primitives, Adding fog, Hints
@subsection Several light sources
}
@end verbatim
-@fig{png/several_light, Example of several light sources.}
+@pfig{several_light, Example of several light sources.}
@c ------------------------------------------------------------------
+@external
@node Using primitives, STFA sample, Several light sources, Hints
@subsection Using primitives
MathGL provide a set of functions for drawing primitives (see @ref{Primitives}). Primitives are low level object, which used by most of plotting functions. Picture below demonstrate some of commonly used primitives.
-@fig{png/primitives, Primitives in MathGL.}
+@pfig{primitives, Primitives in MathGL.}
Generally, you can create arbitrary new kind of plot using primitives. For example, MathGL don't provide any special functions for drawing molecules. However, you can do it using only one type of primitives @code{Drop}. The sample code is:
@verbatim
}
@end verbatim
-@fig{png/molecule, Example of molecules drawing.}
+@pfig{molecule, Example of molecules drawing.}
Moreover, some of special plots can be more easily produced by primitives rather than by specialized function. For example, Venn diagram can be produced by @code{Error} plot:
@verbatim
@end verbatim
Of course, the first variant is more suitable if you need to plot a lot of circles. But for few ones the usage of primitives looks easy.
-@fig{png/venn, Example of Venn diagram.}
+@pfig{venn, Example of Venn diagram.}
@c ------------------------------------------------------------------
+@external
@node STFA sample, Mapping visualization, Using primitives, Hints
@subsection STFA sample
}
@end verbatim
-@fig{png/stfa, Example of STFA().}
+@pfig{stfa, Example of STFA().}
@c ------------------------------------------------------------------
+@external
@node Mapping visualization, Making histogram, STFA sample, Hints
@subsection Mapping visualization
}
@end verbatim
-@fig{png/map, Example of Map().}
+@pfig{map, Example of Map().}
@c ------------------------------------------------------------------
+@external
@node Making histogram, Nonlinear fitting sample, Mapping visualization, Hints
@subsection Making histogram
@verbatim
int sample(mglGraph *gr)
{
- mglData a(50, 40), b(50, 40);
- gr->Puts(mglPoint(0, 0), "\\to", ":C", -1.4);
- gr->SetRanges(-1,1,-1,1,-2,2);
-
- gr->SubPlot(2, 1, 0);
- gr->Fill(a,"x"); gr->Fill(b,"y");
- gr->Puts(mglPoint(0, 1.1), "\\{x, y\\}", ":C", -2); gr->Box();
- gr->Map(a, b, "brgk");
-
- gr->SubPlot(2, 1, 1);
- gr->Fill(a,"(x^3+y^3)/2"); gr->Fill(b,"(x-y)/2");
- gr->Puts(mglPoint(0, 1.1), "\\{\\frac{x^3+y^3}{2}, \\frac{x-y}{2}\\}", ":C", -2);
- gr->Box();
- gr->Map(a, b, "brgk");
+ mglData x(10000), y(10000), z(10000); gr->Fill(x,"2*rnd-1");
+ gr->Fill(y,"2*rnd-1"); gr->Fill(z,"exp(-6*(v^2+w^2))",x,y);
+ mglData xx=gr->Hist(x,z), yy=gr->Hist(y,z); xx.Norm(0,1);
+ yy.Norm(0,1);
+ gr->MultiPlot(3,3,3,2,2,""); gr->SetRanges(-1,1,-1,1,0,1);
+ gr->Box(); gr->Dots(x,y,z,"wyrRk");
+ gr->MultiPlot(3,3,0,2,1,""); gr->SetRanges(-1,1,0,1);
+ gr->Box(); gr->Bars(xx);
+ gr->MultiPlot(3,3,5,1,2,""); gr->SetRanges(0,1,-1,1);
+ gr->Box(); gr->Barh(yy);
+ gr->SubPlot(3,3,2);
+ gr->Puts(mglPoint(0.5,0.5),"Hist and\nMultiPlot\nsample","a",-6);
return 0;
}
@end verbatim
-@fig{png/hist, Example of Hist().}
+@pfig{hist, Example of Hist().}
@c ------------------------------------------------------------------
+@external
@node Nonlinear fitting sample, PDE solving hints, Making histogram, Hints
@subsection Nonlinear fitting hints
The next step is the fitting itself. For that let me specify an initial values @var{ini} for coefficients @samp{abc} and do the fitting for approximation formula @samp{a+b*sin(c*x)}
@verbatim
- float ini[3] = {1,1,3};
+ mreal ini[3] = {1,1,3};
mglData Ini(3,ini);
mglData res = gr->Fit(rnd, "a+b*sin(c*x)", "abc", Ini);
@end verbatim
mglData rnd(100), in(100);
gr->Fill(rnd,"0.4*rnd+0.1+sin(2*pi*x)");
gr->Fill(in,"0.3+sin(2*pi*x)");
- float ini[3] = {1,1,3};
+ mreal ini[3] = {1,1,3};
mglData Ini(3,ini);
mglData res = gr->Fit(rnd, "a+b*sin(c*x)", "abc", Ini);
}
@end verbatim
-@fig{png/fit, Example of nonlinear fitting.}
+@pfig{fit, Example of nonlinear fitting.}
@c ------------------------------------------------------------------
+@external
@node PDE solving hints, MGL parser using, Nonlinear fitting sample, Hints
@subsection PDE solving hints
}
@end verbatim
-@fig{png/pde, Example of PDE solving.}
+@pfig{pde, Example of PDE solving.}
The last example is example of beam tracing. Beam tracing equation is special kind of PDE equation written in coordinates accompanied to a ray. Generally this is the same parameters and limitation as for PDE solving but the coordinates are defined by the ray and by parameter of grid width @var{w} in direction transverse the ray. So, you don't need to specify the range of coordinates. @strong{BUT} there is limitation. The accompanied coordinates are well defined only for smooth enough rays, i.e. then the ray curvature @math{K} (which is defined as @math{1/K^2 = (|\ddot r|^2 |\dot r|^2 - (\ddot r, \dot r)^2)/|\dot r|^6}) is much large then the grid width: @math{K>>w}. So, you may receive incorrect results if this condition will be broken.
}
@end verbatim
-@fig{png/qo2d, Example of beam tracing.}
+@pfig{qo2d, Example of beam tracing.}
@c ------------------------------------------------------------------
+@external
@node MGL parser using, ``Templates'', PDE solving hints, Hints
@subsection MGL parser using
int sample(mglGraph *gr)
{
gr->Title("MGL parser sample");
- float a[100]; // let a_i = sin(4*pi*x), x=0...1
+ mreal a[100]; // let a_i = sin(4*pi*x), x=0...1
for(int i=0;i<100;i++)a[i]=sin(4*M_PI*i/99);
mglParse *parser = new mglParse;
mglData *d = parser->AddVar("dat");
int sample(HMGL gr)
{
mgl_title(gr, "MGL parser sample")
- float a[100]; // let a_i = sin(4*pi*x), x=0...1
+ mreal a[100]; // let a_i = sin(4*pi*x), x=0...1
int i;
for(i=0;i<100;i++) a[i]=sin(4*M_PI*i/99);
HMPR parser = mgl_create_parser();
HMDT d = mgl_add_var(parser, "dat");
- mgl_data_set_float(d,a,100,1,1); // set data to variable
+ mgl_data_set_mreal(d,a,100,1,1); // set data to variable
mgl_parse_text(gr, parser, "plot dat; xrange 0 1\nbox\naxis");
// you may break script at any line do something
// and continue after that
}
@end verbatim
-@fig{png/parser, Example of MGL script parsing.}
+@pfig{parser, Example of MGL script parsing.}
@c ------------------------------------------------------------------
+@external
@node ``Templates'', Nonlinear fitting sample, MGL parser using, Hints
@subsection ``Templates''
I understand that this is obvious thing for any professional programmer, but I several times receive suggestion about ``templates'' ... So, I decide to point out it here.
@c ------------------------------------------------------------------
+@external
@node Stereo image, , ``Templates'', Hints
@subsection Stereo image
}
@end verbatim
-@fig{png/stereo, Example of stereo image.}
+@pfig{stereo, Example of stereo image.}
+@external
@node FAQ, , Hints, Examples
-@section FAQ
+@section FAQ -- TODO: UPDATE!!!
@table @strong
-@item The plot does not appear
-Check that points of the plot lie inside the bounding box and resize the bounding box using @code{Axis()} function. Check that the data have correct dimensions for selected type of plot. Be sure that @code{Finish()} is called after the plotting functions (or be sure that the plot is saved to a file). Sometimes the light reflection from flat surfaces (like, @code{Dens()}) can look as if the plot were absent.
+@item График не рисуется?!
+Проверьте, что точки графика находятся внутри ограничивающего параллелепипеда, при необходимости увеличьте его с помощью функции @code{Axis()}. Проверьте, что размерность массива правильная для выбранного типа графика. Убедитесь, что функция @code{Finish()} была вызвана после построения графика (или график был сохранен в файл). Иногда отражение света от плоских поверхностей (типа, @code{Dens()}) может выглядеть как отсутствие графика.
-@item I can not find some special kind of plot.
-Most ``new'' types of plots can be created by using the existing drawing functions. For example, the surface of curve rotation can be created by a special function @code{Torus()}, or as a parametrically specified surface by @code{Surf()}. See also, @ref{Hints}. If you can not find a specific type of plot, please e-mail me and this plot will appear in the next version of MathGL library.
+@item Не нашел нужного графика?!
+Многие ``новые'' графики можно строить, используя уже существующие функции. Например, поверхность вращения кривой относительно оси можно построить, используя специальную функцию @code{Torus()}, а можно построить как параметрически заданную поверхность @code{Surf()}. См. также @ref{Hints} и @ref{Examples} MathGL. Если же нужного типа графика все равно нет, то пишите мне @email{mathgl.abalakin@@gmail.com, e-mail} и в следующей версии этот график появится.
-@item Should I know some graphical libraries (like OpenGL) before using the MathGL library?
-No. The MathGL library is self-contained and does not require the knowledge of external libraries.
+@item Требуется ли знание сторонних библиотек (например, OpenGL) для использования библиотеки MathGL?
+Нет. Библиотека MathGL самодостаточна и не требует знания сторонних библиотек.
-@item In which language is the library written? For which languages does it have an interface?
-The core of the MathGL library is written in C++. But there are interfaces for: pure C, Fortran, Pascal, Forth, and its own command language MGL. Also there is a large set of interpreted languages, which are supported (Python, Java, ALLEGROCL, CHICKEN, Lisp, CFFI, C#, Guile, Lua, Modula 3, Mzscheme, Ocaml, Octave, Perl, PHP, Pike, R, Ruby, Tcl). These interfaces are written using SWIG (both pure C functions and classes) but only the interface for Python and Octave is included in the autoconf/automake script. The reason is that I don't know any other interpreted languages :(. Note that most other languages can use (link to) the pure C functions.
+@item На каком языке написана библиотека? Для каких языков у нее есть интерфейсы?
+Ядро библиотеки написано на С++. Кроме него, есть интерфейсы для чистого С, фортрана, паскаля, форта и собственный командный язык MGL. Также есть поддержка большого числа интерпретируемых языков (Python, Java, ALLEGROCL, CHICKEN, Lisp, CFFI, C#, Guile, Lua, Modula 3, Mzscheme, Ocaml, Octave, Perl, PHP, Pike, R, Ruby, Tcl). Эти интерфейсы написаны с помощью SWIG (и функции чистого С и классы). Однако на данный момент только интерфейсы для Python и Octave включены в скрипты сборки. Причина в том, что я не знаю других языков, чтобы проверить качество интерфейса :(. Замечу, что большинство прочих языков могут использовать С функции напрямую.
-@item How can I use MathGL with Fortran?
-You can use MathGL as is with @code{gfortran} because it uses by default the AT&T notation for external functions. For other compilers (like Visual Fortran) you have to switch on the AT&T notation manually. The AT&T notation requires that the symbol @samp{_} is added at the end of each function name, function argument(s) is passed by pointers and the string length(s) is passed at the end of the argument list. For example:
+@item Как мне использовать MathGL с Фортраном?
+Библиотеку MathGL можно использовать как есть с компилятором @code{gfortran} поскольку он использует по умолчанию AT&T нотацию для внешних функций. Для других компиляторов (например, Visual Fortran) необходимо включить использование AT&T нотации вручную. AT&T нотация требует, чтобы имя функции завершалось символом @samp{_}, аргументы функции передавались по указателю и длины строк передавались в конце списка аргументов. Например:
-@emph{C function} -- @code{void mgl_fplot(HMGL graph, const char *fy, const char *stl, int n);}
+@emph{C функция} -- @code{void mgl_fplot(HMGL graph, const char *fy, const char *stl, int n);}
-@emph{AT&T function} -- @code{void mgl_fplot_(uintptr_t *graph, const char *fy, const char *stl, int *n, int ly, int ls);}
+@emph{AT&T функция} -- @code{void mgl_fplot_(uintptr_t *graph, const char *fy, const char *stl, int *n, int ly, int ls);}
-@item How can I print in Russian/Spanish/Arabic/Japanese, and so on?
-The standard way is to use Unicode encoding for the text output. But the MathGL library also has interface for 8-bit (char *) strings with internal conversion to Unicode. This conversion depends on the current locale OS. You may change it by @code{setlocale()} function. For example, for Russian text in CP1251 encoding you may use @code{setlocale(LC_CTYPE, "ru_RU.cp1251");} (under MS Windows the name of locale may differ -- @code{setlocale(LC_CTYPE, "russian_russia.1251")}). I strongly recommend not to use the constant @code{LC_ALL} in the conversion. Since it also changes the number format, it may lead to mistakes in formula writing and reading of the text in data files. For example, the program will await a @samp{,} as a decimal point but the user will enter @samp{.}.
+@item У меня есть класс Foo и в нем метод рисования Foo::draw(mglGraph *gr). Как мне нарисовать что-то в окне FLTK, GLUT или Qt?
+Функции-члены класса в С++ имеют ``скрытый'' параметр -- указатель на экземпляр класса и их прямое использование невозможно. Решением будет определение интерфейсной функции:
+@example
+int foo_draw(mglGraph *gr, void *par)
+@{ ((Foo *)foo)->draw(gr); @}
+@end example
+и подстановка именно ее в вызов функции @code{Window()}:
+@example
+gr->Window(argc,argv,foo_draw,"Title",this);
+@end example
-@item How can I exclude a point or a region of plot from the drawing?
-There are 3 general ways. First, the point with @code{NAN} value as one of the coordinates will never be plotted. Second, special variables @var{CutMin}, @var{CutMax} or function @code{CutOff}() define the condition when the points should be omitted (see @ref{Cutting}). Last, you may change the transparency of a part of the plot by the help of functions @code{SurfA()}, @code{Surf3A()} (see @ref{Dual plotting}). In this last case the transparency is switched on smoothly.
+Можно также наследовать Ваш класс от класса @code{mglDraw} и использовать функцию типа @code{gr->Window(argc, argv, foo, "Title");}.
-@item I use VisualStudio, CBuilder or some other compiler (not MinGW/gcc). How can I link the MathGL library?
-In version 2.0, the recommended class @code{mglGraph} (header file @code{#include <mgl2/mgl.h>}) contains only @code{inline} functions and is acceptable for any compiler with the same binary files. However, if you plan to access low-level features (i.e. classes mglBase, mglCanvas and so on) then you have to recompile MathGL by yours compiler.
+@item Как мне вывести текст на русском/испанском/арабском/японском и т.д.?
+Стандартный путь состоит в использовании кодировки UTF-8 для вывода текста. Кроме того, все функции вывода текста имеют интерфейс для 8-битных (char *) строк. Однако в последнем случае Вам может потребоваться установить используемую в исходном тексте локаль. Например, для русского языка в кодировке CP1251 можно использовать @code{setlocale(LC_CTYPE, "ru_RU.cp1251");} (под MS Windows имена локали другие -- @code{setlocale(LC_CTYPE, "russian_russia.1251")}). Настоятельно не рекомендую использовать константу @code{LC_ALL}, поскольку при этом меняется и формат чисел (в частности, десятичная точка), что может, например, вызвать сложности (неудобство) при написании формул и чтении текстовых файлов. Например, программа ожидает @samp{,} в качестве разделителя целой и дробной части, а пользователь вводит @samp{.}.
-@c @strong{Finally!} Please @emph{do not} ask me Windows-specific questions. I do not use Windows. I know nothing about Visual Basic, Visual C++, CBuiled or .NET. Please find the appropriate Usenet discussion group and ask your question there.
+@item Как мне вырезать (исключить из рисования) точку или область на графике?
+Есть три основных способа. Во-первых, можно вырезать точку, задав одну из ее координат равной @code{NAN}. Во-вторых, можно воспользоваться функцией @code{SetCutBox()} или @code{CutOff()} для удаления точек из некоторой области (@pxref{Cutting}). Наконец, можно сделать эти точки прозрачными (невидимыми) с помощью функций @code{SurfA()}, @code{Surf3A()} (@pxref{Dual plotting}). В последнем случае обеспечивается еще и плавность включения прозрачности.
-@item How I can build MathGL under Windows?
-The simplest way is using the combination CMake+MinGW. Also you need some extra libraries like GSL, PNG, JPEG and so on. All of them can be found at @url{http://gnuwin32.sourceforge.net/packages.html}. After installing all components, just run CMake configurator and make the MathGL itself.
+@item Я использую VisualStudio, CBuilder или другой компилятор (не MinGW/gcc). Как мне подключить библиотеку MathGL?
+Начиная с версии 2.0, рекомендуемый к использованию класс mglGraph (заголовочный файл @code{#include <mgl2/mgl.h>}) содержbn только с @code{inline} функции и может использоваться с любым компилятором без перекомпиляции бинарной версии библиотеки. Однако, если Вы планируете использовать низкоуровневые возможности (т.е. классы mglBase, mglCanvas и т.д.), то Вам следует перекомпилировать библиотеку MathGL с использованием Вашего компилятора.
-@item How many people write this library?
-Most of the library was written by one person. This is a result of nearly a year of work (mostly in the evening and on holidays): I spent half a year to write the kernel and half a year to a year on extending, improving the library and writing documentation. This process continues now :). The autoconf/automake script was written mostly by D.Kulagin, and the export to IDTF was written mostly by M.Vidassov.
+@item Как мне собрать MathGL под Windows?
+Простейший путь -- использование комбинации CMake и MinGW. Также Вам может потребоваться дополнительные библиотеки, такие как GSL, PNG, JPEG и пр. Все они могут быть найдены на @url{http://gnuwin32.sourceforge.net/packages.html}. После установки всех компонент, просто запустите конфигуратор CMake и соберите MathGL командой make.
-@item How can I display a bitmap on the figure?
-You can import data into a @code{mglData} instance and display it by @code{Dens()} function. For example, for black-and-white bitmap you can use the code: @code{mglData bmp; bmp.Import("fname.png","wk"); gr->Dens(bmp,"wk");}.
+@item Как создать окно FLTK/GLUT/Qt с текущими результатами параллельно с выполнением основных вычислений?
+Следует создать отдельный поток для обработки сообщений в окно. Кросс-платформенный путь -- использование библиотеки @code{pthread}. Обновление данных в окне можно выполнить вызовом функции @code{mglGraphFLTK::Update()}. Пример код имеет вид:
+@verbatim
+//-----------------------------------------------------------------------------
+#include <mgl2/window.h>
+#include <pthread.h>
-@item How can I use MathGL in Qt, FLTK, wxWidgets etc.?
-There are special classes (widgets) for these libraries: QMathGL for Qt, Fl_MathGL for FLTK and so on. If you don't find the appropriate class then you can create your own widget that displays a bitmap using mglCanvas::GetBits().
+mglPoint pnt; // some global variable for changable data
+//-----------------------------------------------------------------------------
+int sample(mglGraph *gr)
+{
+ gr->Box(); gr->Line(mglPoint(),pnt,"Ar2"); // just draw a vector
+ return 0;
+}
+//-----------------------------------------------------------------------------
+void *mgl_fltk_tmp(void *) { mglFlRun(); return 0; }
+int main (int argc, char ** argv)
+{
+ mglWindow gr(0,sample,"test"); // create window
+ static pthread_t tmp;
+ pthread_create(&tmp, 0, mgl_fltk_tmp, 0);
+ pthread_detach(tmp); // run window handling in the separate thread
+ for(int i=0;i<10;i++) // do calculation
+ {
+ sleep(1); // which can be very long
+ pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);
+ gr.Update(); // update window
+ }
+ return 0; // finish calculations and close the window
+}
+//-----------------------------------------------------------------------------
+@end verbatim
+В случае если требуется вывести статичную картинку с текущими результатами расчетов, то достаточно передать @code{NULL} вместо функции рисования и вызывать @code{Update()} по мере необходимости для обновления графика. Такой способ подходит и для пользователей фортрана.
+@verbatim
+//-----------------------------------------------------------------------------
+#include <mgl2/window.h>
+//-----------------------------------------------------------------------------
+int sample(mglGraph *gr)
+{
+ gr->Box(); gr->Line(mglPoint(),pnt,"Ar2"); // just draw a vector
+ return 0;
+}
+//-----------------------------------------------------------------------------
+void *mgl_fltk_tmp(void *) { mglFlRun(); return 0; }
+int main (int argc, char ** argv)
+{
+ mglWindow gr(0,NULL,"test"); // create window
+ for(int i=0;i<10;i++) // do calculation
+ {
+ sleep(1); // which can be very long
+ pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);
+ sample(&gr); // draw picture
+ gr.Update(); // update window
+ }
+ return 0; // finish calculations and close the window
+}
+//-----------------------------------------------------------------------------
+@end verbatim
-@item How can I create U3D file (make 3D in PDF)?
-There are 2 steps: first you should create IDTF file, and later convert it to U3D. You can use @uref{http://sourceforge.net/project/showfiles.php?group_id=152187&package_id=300628, U3D tools} for converting IDTF file to U3D. It needs @uref{http://libharu.org, libharu} 2.1.0 or later. For installation use @code{./bootstrap, ./configure, make, sudo make install}. It provides IDTFConverter program for converting text files *.idtf to binary files *.u3d. The latter can be included into PDF.
+@item Сколько человек участвовало в создании библиотеки?
+Большую часть библиотеки написал один человек. Это результат примерно года работы на написание ядра библиотеки и базовых функций (в основном вечерами и по выходным). Процесс усовершенствования продолжается и теперь :). Скрипты сборки в основном написаны Д.Кулагиным, а экспорт в IDTF написан М.Видассовым.
-@item How I can change the font family?
-First, you should download new font files from @uref{http://mathgl.sourceforge.net/download.html, here} or from @uref{http://sourceforge.net/project/showfiles.php?group_id=152187&package_id=267177, here}. Next, you should load the font files into mglGraph class instance @var{gr} by the following command: @code{gr->LoadFont(fontname,path);}. Here @var{fontname} is the base font name like @samp{STIX} and @var{path} sets the location of font files. Use @code{gr->RestoreFont();} to start using the default font.
+@item Как мне показать растровую картинку на рисунке?
+Можно импортировать ее в экземпляр @code{mglData} и построить с помощью функции @code{Dens()}. Например, для черно-белого рисунка можно использовать код: @code{mglData bmp; bmp.Import("fname.png","wk"); gr->Dens(bmp,"wk");}.
-@item How can I draw tick out of a bounding box?
-Just set a negative value in @var{SetTickLen}. For example, use @code{gr->SetTickLen(-0.1);}.
+@item Как использовать MathGL в Qt, FLTK, wxWidgets ...?
+Есть специальные классы (виджеты) для этих библиотек: QMathGL для Qt, Fl_MathGL для FLTK и т.д. Если Вы не нашли подходящий класс, то можете создать свой собственный виджет, рисующий растровое изображение из mglCanvas::GetBits().
-@item How can I prevent text rotation?
-Just use @code{SetRotatedText(false)}.
+@item Как мне создать U3D файл (3D in PDF)?
+Процедура состоит из двух шагов: создания файла IDTF и его конвертация в U3D. Можно использовать @uref{http://sourceforge.net/project/showfiles.php?group_id=152187&package_id=300628, U3D tools} для конвертации IDTF в U3D. Ему требуется библиотека @uref{http://libharu.org, libharu} 2.1.0 или более поздняя. Для установки используйте обычную процедуру @code{./bootstrap, ./configure, make, sudo make install}. В результате появится программа IDTFConverter для конвертации файлов *.idtf в бинарные файлы *.u3d. Последние можно включить в PDF.
-@item What is @code{*.so}? What is @code{gcc}? How I can use @code{make}?
-This standard GNU tool. There is special FAQ about its usage under Windows -- @uref{http://www.mingw.org/wiki/FAQ}.
+@item Как сменить шрифт (семейство шрифтов)?
+Во-первых, надо загрузить файлы @uref{http://mathgl.sourceforge.net/download.html, отсюда} или @uref{http://sourceforge.net/project/showfiles.php?group_id=152187&package_id=267177, отсюда}. Далее, в экземпляре mglGraph загружаем шрифты: @code{gr->LoadFont(fontname,path);}. Здесь @var{fontname} -- базовое имя шрифта, например @samp{STIX}, и @var{path} -- путь к папке с файлами шрифтов. Вызовите @code{gr->RestoreFont();} для использования шрифта по умолчанию.
+
+@item Как нарисовать метки оси снаружи от графика?
+Просто используйте отрицательные значения длины меток, например @code{gr->SetTickLen(-0.1);}.
@end table
+@external
+
<html>
<head><title>MathGL 2.0</title></head>
-<frameset rows="130,*" frameborder="0" noresize>
+<frameset rows="90,*" frameborder="0" noresize>
<frame src="title.html">
<frameset cols="140,*" frameborder="0" noresize>
<frame name="toc" src="toc_en.html">
<frame name="main" src="web_en/web_en_1.html">
</frameset>
</frameset>
-</html>
\ No newline at end of file
+</html>
\input texinfo
@setfilename mathgl_en.info
-@set VERSION 2.0
+@set VERSION 2.0.3
@settitle MathGL @value{VERSION}
@syncodeindex pg cp
@comment %**end of header
* Index::
@end menu
+@macro external {}
+@end macro
+
@ifhtml
@macro fig {fname,text}
@center @image{../\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@center @image{../png/\fname\, 11cm, , \text\, .png}
+@c @center @image{../png/\fname\, 11cm, , \text\. See also @uref{../pdf/\fname\.pdf, U3D PDF} sample, .png}
+@end macro
@end ifhtml
@ifnothtml
@macro fig {fname,text}
@center @image{\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
@end iftex
@ifnottex
@macro fig {fname,text}
@c @center @image{\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@c @center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
@end ifnottex
@end ifnothtml
@uref{http://mathgl.sourceforge.net/pdf_u3d/\nam\.pdf, 3D pdf}
@end macro
-@macro reklama
-@end macro
-
@node Overview, Examples, , Top
@include overview_en.texi
@setfilename mathgl_ru.info
@c @documentlanguage ru
@documentencoding UTF-8
-@set VERSION 2.0
+@set VERSION 2.0.3
@settitle MathGL @value{VERSION}
@syncodeindex pg cp
@comment %**end of header
* Index::
@end menu
+@macro external {}
+@end macro
+
@ifhtml
@macro fig {fname,text}
@center @image{../\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@center @image{../png/\fname\, 11cm, , \text\, .png}
+@c @center @image{../png/\fname\, 11cm, , \text\, .png}. See also @uref{../pdf/\fname\.pdf, U3D PDF} sample.
+@end macro
@end ifhtml
@ifnothtml
@macro fig {fname,text}
@center @image{\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
@end iftex
@ifnottex
@macro fig {fname,text}
@c @center @image{\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@c @center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
@end ifnottex
@end ifnothtml
\input texinfo
@setfilename mgl_en.info
-@set VERSION 2.0
+@set VERSION 2.0.3
@settitle MGL script language for version @value{VERSION}
@syncodeindex pg cp
@comment %**end of header
* Index::
@end menu
+@macro external {}
+@end macro
+
@ifhtml
@macro fig {fname,text}
@center @image{../\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@center @image{../png/\fname\, 11cm, , \text\, .png}
+@c @center @image{../png/\fname\, 11cm, , \text\. See also @uref{../pdf/\fname\.pdf, U3D PDF} sample, .png}
+@end macro
@end ifhtml
@ifnothtml
@macro fig {fname,text}
@center @image{\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
@end iftex
@ifnottex
@macro fig {fname,text}
@c @center @image{\fname\, 11cm, , \text\, .png}
@end macro
+@macro pfig {fname,text}
+@c @center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
@end ifnottex
@end ifnothtml
@end macro
@set UDAV
-@macro reklama
-@end macro
-
@c @node Overview, Examples, , Top
@c @include overview_en.texi
@setfilename mgl_ru.info
@c @documentlanguage ru
@documentencoding UTF-8
-@set VERSION 2.0
+@set VERSION 2.0.3
@settitle Язык MGL для версии @value{VERSION}
@syncodeindex pg cp
@comment %**end of header
@end ifnottex
@menu
-* Overview::
-* Examples::
+@c * Overview::
+@c * Examples::
+* MGL scripts::
+* General concepts::
* MathGL core::
* Data processing::
-* Samples::
* Copying This Manual::
* Index::
@end menu
+@macro external {}
+@end macro
+
+@ifhtml
+@macro fig {fname,text}
+@center @image{../\fname\, 11cm, , \text\, .png}
+@end macro
+@macro pfig {fname,text}
+@center @image{../png/\fname\, 11cm, , \text\, .png}
+@c @center @image{../png/\fname\, 11cm, , \text\. See also @uref{../pdf/\fname\.pdf, U3D PDF} sample, .png}
+@end macro
+@end ifhtml
+
+@ifnothtml
+@iftex
+@macro fig {fname,text}
+@center @image{\fname\, 11cm, , \text\, .png}
+@end macro
+@macro pfig {fname,text}
+@center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
+@end iftex
+
+@ifnottex
+@macro fig {fname,text}
+@c @center @image{\fname\, 11cm, , \text\, .png}
+@end macro
+@macro pfig {fname,text}
+@c @center @image{png/\fname\, 11cm, , \text\, .png}
+@end macro
+@end ifnottex
+@end ifnothtml
+
@rmacro sref {arg}
-См. раздел @ref{\arg\}, для примеров кода и графика.
@end rmacro
-@macro tdref{nam}
-@uref{http://mathgl.sourceforge.net/pdf_u3d/\nam\.pdf, 3D pdf}
+@macro tdref {nam}
@end macro
@set UDAV
-@node Overview, Examples, , Top
-@include overview_ru.texi
+@c @node Overview, Examples, , Top
+@c @include overview_ru.texi
+
+@c @node Examples, MGL scripts, Overview, Top
+@c @include ex_mgl_ru.texi
-@node Examples, MathGL core, Overview, Top
-@include ex_mgl_ru.texi
+@node MGL scripts, General concepts, , Top
+@include parse_ru.texi
-@node MathGL core, Data handling, Examples, Top
+@node General concepts, MathGL core, MGL scripts, Top
+@include concept_ru.texi
+
+@node MathGL core, Data processing, General concepts, Top
@include core_ru.texi
-@node Data processing, Samples, MathGL core, Top
+@node Data processing, Copying This Manual, MathGL core, Top
@include data_ru.texi
-@node Samples, Copying This Manual, Data handling, Top
-@include samples_ru.texi
-
-@node Copying This Manual, Index, Samples, Top
+@node Copying This Manual, Index, Data processing, Top
@appendix GNU Free Documentation License
@include fdl.texi
@node Index, , Copying This Manual, Top
-@unnumbered Индекс
+@unnumbered Index
@printindex cp
@c ------------------------------------------------------------------
+@external
@node mglBase class, mglDataA class, , Other classes
-@subsection Define new kind of plot (mglBase class)
+@section Define new kind of plot (mglBase class)
Basically most of new kinds of plot can be created using just MathGL primitives (see @ref{Primitives}). However the usage of @code{mglBase} methods can give you higher speed of drawing and better control of plot settings.
All plotting functions should use a pointer to @code{mglBase} class (or @code{HMGL} type in C functions) due to compatibility issues. Exactly such type of pointers are used in front-end classes (@code{mglGraph, mglWindow}) and in widgets (@code{QMathGL, Fl_MathGL}).
-MathGL tries to remember all vertexes and all primitives and plot creation stage, and to use them for making final picture by demand. Basically for making plot, you need to add vertexes by @code{AddPnt()} function, which return index for new vertex, and call one of primitive drawing function (like @code{mark_plot(), arrow_plot(), line_plot(), trig_plot(), quad_plot(), text_plot()}), using vertex indexes as argument(s). @code{AddPnt()} function use 2 float numbers for color specification. First one is positioning in textures -- integer part is texture index, fractional part is relative coordinate in the texture. Second number is like a transparency of plot (or second coordinate in the 2D texture).
+MathGL tries to remember all vertexes and all primitives and plot creation stage, and to use them for making final picture by demand. Basically for making plot, you need to add vertexes by @code{AddPnt()} function, which return index for new vertex, and call one of primitive drawing function (like @code{mark_plot(), arrow_plot(), line_plot(), trig_plot(), quad_plot(), text_plot()}), using vertex indexes as argument(s). @code{AddPnt()} function use 2 mreal numbers for color specification. First one is positioning in textures -- integer part is texture index, fractional part is relative coordinate in the texture. Second number is like a transparency of plot (or second coordinate in the 2D texture).
I don't want to put here detailed description of @code{mglBase} class. It was rather well documented in @code{mgl2/base.h} file. I just show and example of its usage on the base of circle drawing.
#ifdef __cplusplus
extern "C" {
#endif
-void circle(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt);
+void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt);
#ifdef __cplusplus
}
#endif
Now, we create a C++ file and put the code of function. I'll write it line by line and try to comment all important points.
@verbatim
-void circle(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt)
+void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
@end verbatim
First, we need to check all input arguments and send warnings if something is wrong. In our case it is negative value of @var{r} argument. We just send warning, since it is not critical situation -- other plot still can be drawn.
@end verbatim
Next step, is determining colors for filling and for border. First one for filling.
@verbatim
- float c=gr->NextColor(pal), d;
+ mreal c=gr->NextColor(pal), d;
@end verbatim
Second one for border. I use black color (call @code{gr->AddTexture('k')}) if second color is not specified.
@verbatim
- float k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');
+ mreal k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');
@end verbatim
If user want draw only border (@code{fill=false}) then I use first color for border.
@verbatim
@end verbatim
Let find coordinates of vertex.
@verbatim
- float t = i*2*M_PI/(n-1.);
+ mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
@end verbatim
Save previous vertex and add next one
Another sample I want to show is exactly the same function but with smooth coloring using color scheme. So, I'll add comments only in the place of difference.
@verbatim
-void circle_cs(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt)
+void circle_cs(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
@end verbatim
In this case let allow negative radius too. Formally it is not the problem for plotting (formulas the same) and this allow us to handle all color range.
@end verbatim
Next step, is determining colors for filling and for border. First one for filling.
@verbatim
- float c=gr->GetC(ss,r);
+ mreal c=gr->GetC(ss,r);
@end verbatim
Second one for border.
@verbatim
- float k=gr->NextColor(pal);
+ mreal k=gr->NextColor(pal);
@end verbatim
The rest part is the same as in previous function.
@verbatim
for(i=0,m1=n1=-1;i<n;i++)
{
if(gr->Stop) return;
- float t = i*2*M_PI/(n-1.);
+ mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
n2 = n1; n1 = gr->AddPnt(p,c,q,-1,3);
m2 = m1; m1 = gr->CopyNtoC(n1,k);
class MyGraph : public mglGraph
{
public:
- inline void Circle(mglPoint p, float r, const char *stl="", const char *opt="")
+ inline void Circle(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle(p.x,p.y,p.z, r, stl, opt); }
- inline void CircleCS(mglPoint p, float r, const char *stl="", const char *opt="")
+ inline void CircleCS(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle_cs(p.x,p.y,p.z, r, stl, opt); }
};
@end verbatim
#ifdef __cplusplus
extern "C" {
#endif
-void circle(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt);
-void circle_cs(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt);
+void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt);
+void circle_cs(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt);
#ifdef __cplusplus
}
#endif
class MyGraph : public mglGraph
{
public:
- inline void CircleCF(mglPoint p, float r, const char *stl="", const char *opt="")
+ inline void CircleCF(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle(p.x,p.y,p.z, r, stl, opt); }
- inline void CircleCS(mglPoint p, float r, const char *stl="", const char *opt="")
+ inline void CircleCS(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle_cs(p.x,p.y,p.z, r, stl, opt); }
};
//---------------------------------------------------------
-void circle(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt)
+void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
if(r<=0) { gr->SetWarn(mglWarnNeg,"Circle"); return; }
static int cgid=1; gr->StartGroup("Circle",cgid++);
bool fill = stl && strchr(stl,'@');
long pal=0;
char mk=gr->SetPenPal(stl,&pal);
- float c=gr->NextColor(pal), d;
- float k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');
+ mreal c=gr->NextColor(pal), d;
+ mreal k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');
if(!fill) k=c;
gr->Reserve(2*n+2);
mglPoint q(NAN,NAN);
for(i=0,m1=n1=-1;i<n;i++)
{
if(gr->Stop) return;
- float t = i*2*M_PI/(n-1.);
+ mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
n2 = n1; n1 = gr->AddPnt(p,c,q,-1,3);
m2 = m1; m1 = gr->CopyNtoC(n1,k);
gr->EndGroup();
}
//---------------------------------------------------------
-void circle_cs(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt)
+void circle_cs(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
static int cgid=1; gr->StartGroup("CircleCS",cgid++);
gr->SaveState(opt);
if(pen) pen++;
long pal=0;
char mk=gr->SetPenPal(pen,&pal);
- float c=gr->GetC(ss,r);
- float k=gr->NextColor(pal);
+ mreal c=gr->GetC(ss,r);
+ mreal k=gr->NextColor(pal);
if(!fill) k=c;
gr->Reserve(2*n+2);
for(i=0,m1=n1=-1;i<n;i++)
{
if(gr->Stop) return;
- float t = i*2*M_PI/(n-1.);
+ mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
n2 = n1; n1 = gr->AddPnt(p,c,q,-1,3);
m2 = m1; m1 = gr->CopyNtoC(n1,k);
@c ------------------------------------------------------------------
+@external
@node mglDataA class, mglColor class, mglBase class, Other classes
-@subsection User defined types (mglDataA class)
+@section User defined types (mglDataA class)
@code{mglData} class have abstract predecessor class @code{mglDataA}. Exactly the pointers to @code{mglDataA} instances are used in all plotting functions and some of data processing functions. This was done for taking possibility to define yours own class, which will handle yours own data (for example, complex numbers, or differently organized data). And this new class will be almost the same as @code{mglData} for plotting purposes.
{ nx=mx; ny=my; nz=mz; if(a) delete []a;
a = new dual[nx*ny*nz]; }
/// Get maximal value of the data
- inline float Maximal() const { return mgl_data_max(this); }
+ inline mreal Maximal() const { return mgl_data_max(this); }
/// Get minimal value of the data
- inline float Minimal() const { return mgl_data_min(this); }
+ inline mreal Minimal() const { return mgl_data_min(this); }
protected:
inline mreal v(long i,long j=0,long k=0) const
@c ------------------------------------------------------------------
+@external
@node mglColor class, mglPoint class, mglDataA class, Other classes
@section mglColor class
@cindex mglColor
Structure for working with colors. This structure is defined in @code{#include <mgl2/type.h>}.
-There are two ways to set the color in MathGL. First one is using of float values of red, green and blue channels for precise color definition. The second way is the using of character id. There are a set of characters specifying frequently used colors. Normally capital letter gives more dark color than lowercase one. @xref{Line styles}.
+There are two ways to set the color in MathGL. First one is using of mreal values of red, green and blue channels for precise color definition. The second way is the using of character id. There are a set of characters specifying frequently used colors. Normally capital letter gives more dark color than lowercase one. @xref{Line styles}.
-@deftypecv {Parameter} mglColor @code{float} {r, g, b, a}
+@deftypecv {Parameter} mglColor @code{mreal} {r, g, b, a}
Reg, green and blue component of color.
@end deftypecv
-@deftypemethod mglColor @code{} mglColor (@code{float} R, @code{float} G, @code{float} B, @code{float} A=@code{1})
-Constructor sets the color by float values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
+@deftypemethod mglColor @code{} mglColor (@code{mreal} R, @code{mreal} G, @code{mreal} B, @code{mreal} A=@code{1})
+Constructor sets the color by mreal values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
@end deftypemethod
-@deftypemethod mglColor @code{} mglColor (@code{char} c=@code{'k'}, @code{float} bright=@code{1})
+@deftypemethod mglColor @code{} mglColor (@code{char} c=@code{'k'}, @code{mreal} bright=@code{1})
Constructor sets the color from character id. The black color is used by default. Parameter @var{br} set additional ``lightness'' of color.
@end deftypemethod
-@deftypemethod mglColor @code{void} Set (@code{float} R, @code{float} G, @code{float} B, @code{float} A=@code{1})
+@deftypemethod mglColor @code{void} Set (@code{mreal} R, @code{mreal} G, @code{mreal} B, @code{mreal} A=@code{1})
Sets color from values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
@end deftypemethod
-@deftypemethod mglColor @code{void} Set (@code{mglColor} c, @code{float} bright=@code{1})
+@deftypemethod mglColor @code{void} Set (@code{mglColor} c, @code{mreal} bright=@code{1})
Sets color as ``lighted'' version of color @var{c}.
@end deftypemethod
-@deftypemethod mglColor @code{void} Set (@code{char} p, @code{float} bright=@code{1})
+@deftypemethod mglColor @code{void} Set (@code{char} p, @code{mreal} bright=@code{1})
Sets color from symbolic id.
@end deftypemethod
@deftypemethod mglColor @code{bool} Valid ()
Checks correctness of the color.
@end deftypemethod
-@deftypemethod mglColor @code{float} Norm ()
+@deftypemethod mglColor @code{mreal} Norm ()
Gets maximal of spectral component.
@end deftypemethod
@deftypemethod mglColor @code{bool} operator== (@code{const mglColor &}c)
Compare with another color
@end deftypemethod
-@deftypemethod mglColor @code{bool} operator*= (@code{float} v)
+@deftypemethod mglColor @code{bool} operator*= (@code{mreal} v)
Multiplies color components by number @var{v}.
@end deftypemethod
@deftypefn {Library Function} @code{mglColor} operator- (@code{const mglColor &}a, @code{const mglColor &}b)
Subtracts colors by its RGB values.
@end deftypefn
-@deftypefn {Library Function} @code{mglColor} operator* (@code{const mglColor &}a, @code{float} b)
-@deftypefnx {Library Function} @code{mglColor} operator* (@code{float} a, @code{const mglColor &}b)
+@deftypefn {Library Function} @code{mglColor} operator* (@code{const mglColor &}a, @code{mreal} b)
+@deftypefnx {Library Function} @code{mglColor} operator* (@code{mreal} a, @code{const mglColor &}b)
Multiplies color by number.
@end deftypefn
-@deftypefn {Library Function} @code{mglColor} operator/ (@code{const mglColor &}a, @code{float} b)
+@deftypefn {Library Function} @code{mglColor} operator/ (@code{const mglColor &}a, @code{mreal} b)
Divide color by number.
@end deftypefn
@deftypefn {Library Function} @code{mglColor} operator! (@code{const mglColor &}a)
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node mglPoint class, mglFont class, mglColor class, Other classes
@section mglPoint class
@cindex mglPoint
Structure describes point in space. This structure is defined in @code{#include <mgl2/type.h>}
-@deftypecv {Parameter} mglPoint @code{float} {x, y, z, c}
+@deftypecv {Parameter} mglPoint @code{mreal} {x, y, z, c}
Point coordinates @{x,y,z@} and one extra value @var{c} used for amplitude, transparency and so on. By default all values are zero.
@end deftypecv
-@deftypemethod mglPoint @code{} mglPoint (@code{float} X=@code{0}, @code{float} Y=@code{0}, @code{float} Z=@code{0}, @code{float} C=@code{0})
-Constructor sets the color by float values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
+@deftypemethod mglPoint @code{} mglPoint (@code{mreal} X=@code{0}, @code{mreal} Y=@code{0}, @code{mreal} Z=@code{0}, @code{mreal} C=@code{0})
+Constructor sets the color by mreal values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
@end deftypemethod
@deftypemethod mglPoint @code{bool} IsNAN ()
Returns @code{true} if point contain NAN values.
@end deftypemethod
-@deftypemethod mglPoint @code{float} norm ()
+@deftypemethod mglPoint @code{mreal} norm ()
Returns the norm @math{\sqrt@{x^2+y^2+z^2@}} of vector.
@end deftypemethod
@deftypemethod mglPoint @code{void} Normalize ()
Normalizes vector to be unit vector.
@end deftypemethod
-@deftypemethod mglPoint @code{float} val (@code{int} i)
+@deftypemethod mglPoint @code{mreal} val (@code{int} i)
Returns point component: @var{x} for @var{i}=0, @var{y} for @var{i}=1, @var{z} for @var{i}=2, @var{c} for @var{i}=3.
@end deftypemethod
@deftypefn {Library Function} @code{mglPoint} operator- (@code{const mglPoint &}a, @code{const mglPoint &}b)
Point of difference (difference of vectors).
@end deftypefn
-@deftypefn {Library Function} @code{mglPoint} operator* (@code{float} a, @code{const mglPoint &}b)
-@deftypefnx {Library Function} @code{mglPoint} operator* (@code{const mglPoint &}a, @code{float} b)
+@deftypefn {Library Function} @code{mglPoint} operator* (@code{mreal} a, @code{const mglPoint &}b)
+@deftypefnx {Library Function} @code{mglPoint} operator* (@code{const mglPoint &}a, @code{mreal} b)
Multiplies (scale) points by number.
@end deftypefn
-@deftypefn {Library Function} @code{mglPoint} operator/ (@code{const mglPoint &}a, @code{float} b)
+@deftypefn {Library Function} @code{mglPoint} operator/ (@code{const mglPoint &}a, @code{mreal} b)
Multiplies (scale) points by number 1/b.
@end deftypefn
-@deftypefn {Library Function} @code{float} operator* (@code{const mglPoint &}a, @code{const mglPoint &}b)
+@deftypefn {Library Function} @code{mreal} operator* (@code{const mglPoint &}a, @code{const mglPoint &}b)
Scalar product of vectors.
@end deftypefn
@deftypefn {Library Function} @code{mglPoint} operator! (@code{const mglPoint &}a)
Return vector perpendicular to vector @var{a}.
@end deftypefn
-@deftypefn {Library Function} @code{float} mgl_norm (@code{const mglPoint &}a)
+@deftypefn {Library Function} @code{mreal} mgl_norm (@code{const mglPoint &}a)
Return the norm sqrt(|@var{a}|^2) of vector @var{a}.
@end deftypefn
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node mglFont class, , mglPoint class, Other classes
@section mglFont class
@cindex mglFont
@end deftypemethod
-@deftypemethod mglFont @code{float} Height (@code{int} font)
+@deftypemethod mglFont @code{mreal} Height (@code{int} font)
Gets height of text for font specified by integer constant.
@end deftypemethod
-@deftypemethod mglFont @code{float} Puts (@code{const char *}str, @code{int} font=@code{0}, @code{int} align=@code{0})
+@deftypemethod mglFont @code{mreal} Puts (@code{const char *}str, @code{int} font=@code{0}, @code{int} align=@code{0})
Prints 8-bit text string for font specified by integer constant.
@end deftypemethod
-@deftypemethod mglFont @code{float} Width (@code{const char *}str, @code{int} font=@code{0})
+@deftypemethod mglFont @code{mreal} Width (@code{const char *}str, @code{int} font=@code{0})
Gets width of 8-bit text string for font specified by integer constant.
@end deftypemethod
-@deftypemethod mglFont @code{float} Puts (@code{const wchar_t *}str, @code{int} font=@code{0}, @code{int} align=@code{0})
+@deftypemethod mglFont @code{mreal} Puts (@code{const wchar_t *}str, @code{int} font=@code{0}, @code{int} align=@code{0})
Prints Unicode text string for font specified by integer constant.
@end deftypemethod
-@deftypemethod mglFont @code{float} Width (@code{const wchar_t *}str, @code{int} font=@code{0})
+@deftypemethod mglFont @code{mreal} Width (@code{const wchar_t *}str, @code{int} font=@code{0})
Gets width of Unicode text string for font specified by integer constant.
@end deftypemethod
-@deftypemethod mglFont @code{float} Height (@code{const char *}how)
+@deftypemethod mglFont @code{mreal} Height (@code{const char *}how)
Gets height of text for font specified by string.
@end deftypemethod
-@deftypemethod mglFont @code{float} Puts (@code{const char *}str, @code{const char *}how)
+@deftypemethod mglFont @code{mreal} Puts (@code{const char *}str, @code{const char *}how)
Prints 8-bit text string for font specified by string.
@end deftypemethod
-@deftypemethod mglFont @code{float} Width (@code{const char *}str, @code{const char *}how)
+@deftypemethod mglFont @code{mreal} Width (@code{const char *}str, @code{const char *}how)
Gets width of 8-bit text string for font specified by string.
@end deftypemethod
-@deftypemethod mglFont @code{float} Puts (@code{const wchar_t *}str, @code{const char *}how)
+@deftypemethod mglFont @code{mreal} Puts (@code{const wchar_t *}str, @code{const char *}how)
Prints Unicode text string for font specified by string.
@end deftypemethod
-@deftypemethod mglFont @code{float} Width (@code{const wchar_t *}str, @code{const char *}how)
+@deftypemethod mglFont @code{mreal} Width (@code{const wchar_t *}str, @code{const char *}how)
Gets width of Unicode text string for font specified by string.
@end deftypemethod
@end deftypecv
@c ------------------------------------------------------------------
+@external
@node Format of font files, , , mglFont class
@subsection Format of font files
@item
First string contains human readable comment and is always ignored.
@item
-Second string contains 3 numbers, delimited by space or tabulation. The order of numbers is the following: @var{numg} -- the number of glyphs in the file (integer), @var{fact} -- the factor for glyph sizing (float), @var{size} -- the size of buffer for glyph description (integer).
+Second string contains 3 numbers, delimited by space or tabulation. The order of numbers is the following: @var{numg} -- the number of glyphs in the file (integer), @var{fact} -- the factor for glyph sizing (mreal), @var{size} -- the size of buffer for glyph description (integer).
@item
After it @var{numg}-th strings with glyphs description are placed. Each string contains 6 positive numbers, delimited by space of tabulation. The order of numbers is the following: Unicode glyph ID, glyph width, number of lines in glyph, position of lines coordinates in the buffer (length is 2*number of lines), number of triangles in glyph, position of triangles coordinates in the buffer (length is 6*number of triangles).
@item
Note: the closing contour line is done automatically (so the last segment may be absent). For starting new contour use a point with coordinates @code{@{0x3fff, 0x3fff@}}.
+@external
+
@c ------------------------------------------------------------------
+@external
@node mglBase class, mglDataA class, , Other classes
-@subsection Define new kind of plot (mglBase class)
+@section Define new kind of plot (mglBase class)
Basically most of new kinds of plot can be created using just MathGL primitives (see @ref{Primitives}). However the usage of @code{mglBase} methods can give you higher speed of drawing and better control of plot settings.
All plotting functions should use a pointer to @code{mglBase} class (or @code{HMGL} type in C functions) due to compatibility issues. Exactly such type of pointers are used in front-end classes (@code{mglGraph, mglWindow}) and in widgets (@code{QMathGL, Fl_MathGL}).
-MathGL tries to remember all vertexes and all primitives and plot creation stage, and to use them for making final picture by demand. Basically for making plot, you need to add vertexes by @code{AddPnt()} function, which return index for new vertex, and call one of primitive drawing function (like @code{mark_plot(), arrow_plot(), line_plot(), trig_plot(), quad_plot(), text_plot()}), using vertex indexes as argument(s). @code{AddPnt()} function use 2 float numbers for color specification. First one is positioning in textures -- integer part is texture index, fractional part is relative coordinate in the texture. Second number is like a transparency of plot (or second coordinate in the 2D texture).
+MathGL tries to remember all vertexes and all primitives and plot creation stage, and to use them for making final picture by demand. Basically for making plot, you need to add vertexes by @code{AddPnt()} function, which return index for new vertex, and call one of primitive drawing function (like @code{mark_plot(), arrow_plot(), line_plot(), trig_plot(), quad_plot(), text_plot()}), using vertex indexes as argument(s). @code{AddPnt()} function use 2 mreal numbers for color specification. First one is positioning in textures -- integer part is texture index, fractional part is relative coordinate in the texture. Second number is like a transparency of plot (or second coordinate in the 2D texture).
I don't want to put here detailed description of @code{mglBase} class. It was rather well documented in @code{mgl2/base.h} file. I just show and example of its usage on the base of circle drawing.
#ifdef __cplusplus
extern "C" {
#endif
-void circle(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt);
+void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt);
#ifdef __cplusplus
}
#endif
Now, we create a C++ file and put the code of function. I'll write it line by line and try to comment all important points.
@verbatim
-void circle(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt)
+void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
@end verbatim
First, we need to check all input arguments and send warnings if something is wrong. In our case it is negative value of @var{r} argument. We just send warning, since it is not critical situation -- other plot still can be drawn.
@end verbatim
Next step, is determining colors for filling and for border. First one for filling.
@verbatim
- float c=gr->NextColor(pal), d;
+ mreal c=gr->NextColor(pal), d;
@end verbatim
Second one for border. I use black color (call @code{gr->AddTexture('k')}) if second color is not specified.
@verbatim
- float k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');
+ mreal k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');
@end verbatim
If user want draw only border (@code{fill=false}) then I use first color for border.
@verbatim
@end verbatim
Let find coordinates of vertex.
@verbatim
- float t = i*2*M_PI/(n-1.);
+ mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
@end verbatim
Save previous vertex and add next one
Another sample I want to show is exactly the same function but with smooth coloring using color scheme. So, I'll add comments only in the place of difference.
@verbatim
-void circle_cs(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt)
+void circle_cs(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
@end verbatim
In this case let allow negative radius too. Formally it is not the problem for plotting (formulas the same) and this allow us to handle all color range.
@end verbatim
Next step, is determining colors for filling and for border. First one for filling.
@verbatim
- float c=gr->GetC(ss,r);
+ mreal c=gr->GetC(ss,r);
@end verbatim
Second one for border.
@verbatim
- float k=gr->NextColor(pal);
+ mreal k=gr->NextColor(pal);
@end verbatim
The rest part is the same as in previous function.
@verbatim
for(i=0,m1=n1=-1;i<n;i++)
{
if(gr->Stop) return;
- float t = i*2*M_PI/(n-1.);
+ mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
n2 = n1; n1 = gr->AddPnt(p,c,q,-1,3);
m2 = m1; m1 = gr->CopyNtoC(n1,k);
class MyGraph : public mglGraph
{
public:
- inline void Circle(mglPoint p, float r, const char *stl="", const char *opt="")
+ inline void Circle(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle(p.x,p.y,p.z, r, stl, opt); }
- inline void CircleCS(mglPoint p, float r, const char *stl="", const char *opt="")
+ inline void CircleCS(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle_cs(p.x,p.y,p.z, r, stl, opt); }
};
@end verbatim
#ifdef __cplusplus
extern "C" {
#endif
-void circle(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt);
-void circle_cs(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt);
+void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt);
+void circle_cs(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt);
#ifdef __cplusplus
}
#endif
class MyGraph : public mglGraph
{
public:
- inline void CircleCF(mglPoint p, float r, const char *stl="", const char *opt="")
+ inline void CircleCF(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle(p.x,p.y,p.z, r, stl, opt); }
- inline void CircleCS(mglPoint p, float r, const char *stl="", const char *opt="")
+ inline void CircleCS(mglPoint p, mreal r, const char *stl="", const char *opt="")
{ circle_cs(p.x,p.y,p.z, r, stl, opt); }
};
//---------------------------------------------------------
-void circle(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt)
+void circle(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
if(r<=0) { gr->SetWarn(mglWarnNeg,"Circle"); return; }
static int cgid=1; gr->StartGroup("Circle",cgid++);
bool fill = stl && strchr(stl,'@');
long pal=0;
char mk=gr->SetPenPal(stl,&pal);
- float c=gr->NextColor(pal), d;
- float k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');
+ mreal c=gr->NextColor(pal), d;
+ mreal k=(gr->GetNumPal(pal)>1)?gr->NextColor(pal):gr->AddTexture('k');
if(!fill) k=c;
gr->Reserve(2*n+2);
mglPoint q(NAN,NAN);
for(i=0,m1=n1=-1;i<n;i++)
{
if(gr->Stop) return;
- float t = i*2*M_PI/(n-1.);
+ mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
n2 = n1; n1 = gr->AddPnt(p,c,q,-1,3);
m2 = m1; m1 = gr->CopyNtoC(n1,k);
gr->EndGroup();
}
//---------------------------------------------------------
-void circle_cs(HMGL gr, float x, float y, float z, float r, const char *stl, const char *opt)
+void circle_cs(HMGL gr, mreal x, mreal y, mreal z, mreal r, const char *stl, const char *opt)
{
static int cgid=1; gr->StartGroup("CircleCS",cgid++);
gr->SaveState(opt);
if(pen) pen++;
long pal=0;
char mk=gr->SetPenPal(pen,&pal);
- float c=gr->GetC(ss,r);
- float k=gr->NextColor(pal);
+ mreal c=gr->GetC(ss,r);
+ mreal k=gr->NextColor(pal);
if(!fill) k=c;
gr->Reserve(2*n+2);
for(i=0,m1=n1=-1;i<n;i++)
{
if(gr->Stop) return;
- float t = i*2*M_PI/(n-1.);
+ mreal t = i*2*M_PI/(n-1.);
mglPoint p(x+r*cos(t), y+r*sin(t), z);
n2 = n1; n1 = gr->AddPnt(p,c,q,-1,3);
m2 = m1; m1 = gr->CopyNtoC(n1,k);
@c ------------------------------------------------------------------
+@external
@node mglDataA class, mglColor class, mglBase class, Other classes
-@subsection User defined types (mglDataA class)
+@section User defined types (mglDataA class)
@code{mglData} class have abstract predecessor class @code{mglDataA}. Exactly the pointers to @code{mglDataA} instances are used in all plotting functions and some of data processing functions. This was done for taking possibility to define yours own class, which will handle yours own data (for example, complex numbers, or differently organized data). And this new class will be almost the same as @code{mglData} for plotting purposes.
long nx; ///< number of points in 1st dimensions ('x' dimension)
long ny; ///< number of points in 2nd dimensions ('y' dimension)
long nz; ///< number of points in 3d dimensions ('z' dimension)
- dual *a; ///< data array
+ dual *a; ///< data array
bool use_abs; ///< flag to use abs() or arg()
inline mglComplex(long xx=1,long yy=1,long zz=1)
{ nx=mx; ny=my; nz=mz; if(a) delete []a;
a = new dual[nx*ny*nz]; }
/// Get maximal value of the data
- inline float Maximal() const { return mgl_data_max(this); }
+ inline mreal Maximal() const { return mgl_data_max(this); }
/// Get minimal value of the data
- inline float Minimal() const { return mgl_data_min(this); }
+ inline mreal Minimal() const { return mgl_data_min(this); }
protected:
inline mreal v(long i,long j=0,long k=0) const
@c ------------------------------------------------------------------
+@external
@node mglColor class, mglPoint class, mglDataA class, Other classes
@section mglColor class
@cindex mglColor
Structure for working with colors. This structure is defined in @code{#include <mgl2/type.h>}.
-There are two ways to set the color in MathGL. First one is using of float values of red, green and blue channels for precise color definition. The second way is the using of character id. There are a set of characters specifying frequently used colors. Normally capital letter gives more dark color than lowercase one. @xref{Line styles}.
+There are two ways to set the color in MathGL. First one is using of mreal values of red, green and blue channels for precise color definition. The second way is the using of character id. There are a set of characters specifying frequently used colors. Normally capital letter gives more dark color than lowercase one. @xref{Line styles}.
-@deftypecv {Parameter} mglColor @code{float} {r, g, b, a}
+@deftypecv {Parameter} mglColor @code{mreal} {r, g, b, a}
Reg, green and blue component of color.
@end deftypecv
-@deftypemethod mglColor @code{} mglColor (@code{float} R, @code{float} G, @code{float} B, @code{float} A=@code{1})
-Constructor sets the color by float values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
+@deftypemethod mglColor @code{} mglColor (@code{mreal} R, @code{mreal} G, @code{mreal} B, @code{mreal} A=@code{1})
+Constructor sets the color by mreal values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
@end deftypemethod
-@deftypemethod mglColor @code{} mglColor (@code{char} c=@code{'k'}, @code{float} bright=@code{1})
+@deftypemethod mglColor @code{} mglColor (@code{char} c=@code{'k'}, @code{mreal} bright=@code{1})
Constructor sets the color from character id. The black color is used by default. Parameter @var{br} set additional ``lightness'' of color.
@end deftypemethod
-@deftypemethod mglColor @code{void} Set (@code{float} R, @code{float} G, @code{float} B, @code{float} A=@code{1})
+@deftypemethod mglColor @code{void} Set (@code{mreal} R, @code{mreal} G, @code{mreal} B, @code{mreal} A=@code{1})
Sets color from values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
@end deftypemethod
-@deftypemethod mglColor @code{void} Set (@code{mglColor} c, @code{float} bright=@code{1})
+@deftypemethod mglColor @code{void} Set (@code{mglColor} c, @code{mreal} bright=@code{1})
Sets color as ``lighted'' version of color @var{c}.
@end deftypemethod
-@deftypemethod mglColor @code{void} Set (@code{char} p, @code{float} bright=@code{1})
+@deftypemethod mglColor @code{void} Set (@code{char} p, @code{mreal} bright=@code{1})
Sets color from symbolic id.
@end deftypemethod
@deftypemethod mglColor @code{bool} Valid ()
Checks correctness of the color.
@end deftypemethod
-@deftypemethod mglColor @code{float} Norm ()
+@deftypemethod mglColor @code{mreal} Norm ()
Gets maximal of spectral component.
@end deftypemethod
@deftypemethod mglColor @code{bool} operator== (@code{const mglColor &}c)
Compare with another color
@end deftypemethod
-@deftypemethod mglColor @code{bool} operator*= (@code{float} v)
+@deftypemethod mglColor @code{bool} operator*= (@code{mreal} v)
Multiplies color components by number @var{v}.
@end deftypemethod
@deftypefn {Library Function} @code{mglColor} operator- (@code{const mglColor &}a, @code{const mglColor &}b)
Subtracts colors by its RGB values.
@end deftypefn
-@deftypefn {Library Function} @code{mglColor} operator* (@code{const mglColor &}a, @code{float} b)
-@deftypefnx {Library Function} @code{mglColor} operator* (@code{float} a, @code{const mglColor &}b)
+@deftypefn {Library Function} @code{mglColor} operator* (@code{const mglColor &}a, @code{mreal} b)
+@deftypefnx {Library Function} @code{mglColor} operator* (@code{mreal} a, @code{const mglColor &}b)
Multiplies color by number.
@end deftypefn
-@deftypefn {Library Function} @code{mglColor} operator/ (@code{const mglColor &}a, @code{float} b)
+@deftypefn {Library Function} @code{mglColor} operator/ (@code{const mglColor &}a, @code{mreal} b)
Divide color by number.
@end deftypefn
@deftypefn {Library Function} @code{mglColor} operator! (@code{const mglColor &}a)
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node mglPoint class, mglFont class, mglColor class, Other classes
@section mglPoint class
@cindex mglPoint
Structure describes point in space. This structure is defined in @code{#include <mgl2/type.h>}
-@deftypecv {Parameter} mglPoint @code{float} {x, y, z, c}
+@deftypecv {Parameter} mglPoint @code{mreal} {x, y, z, c}
Point coordinates @{x,y,z@} and one extra value @var{c} used for amplitude, transparency and so on. By default all values are zero.
@end deftypecv
-@deftypemethod mglPoint @code{} mglPoint (@code{float} X=@code{0}, @code{float} Y=@code{0}, @code{float} Z=@code{0}, @code{float} C=@code{0})
-Constructor sets the color by float values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
+@deftypemethod mglPoint @code{} mglPoint (@code{mreal} X=@code{0}, @code{mreal} Y=@code{0}, @code{mreal} Z=@code{0}, @code{mreal} C=@code{0})
+Constructor sets the color by mreal values of Red, Green, Blue and Alpha channels. These values should be in interval [0,1].
@end deftypemethod
@deftypemethod mglPoint @code{bool} IsNAN ()
Returns @code{true} if point contain NAN values.
@end deftypemethod
-@deftypemethod mglPoint @code{float} norm ()
+@deftypemethod mglPoint @code{mreal} norm ()
Returns the norm @math{\sqrt@{x^2+y^2+z^2@}} of vector.
@end deftypemethod
@deftypemethod mglPoint @code{void} Normalize ()
Normalizes vector to be unit vector.
@end deftypemethod
-@deftypemethod mglPoint @code{float} val (@code{int} i)
+@deftypemethod mglPoint @code{mreal} val (@code{int} i)
Returns point component: @var{x} for @var{i}=0, @var{y} for @var{i}=1, @var{z} for @var{i}=2, @var{c} for @var{i}=3.
@end deftypemethod
@deftypefn {Library Function} @code{mglPoint} operator- (@code{const mglPoint &}a, @code{const mglPoint &}b)
Point of difference (difference of vectors).
@end deftypefn
-@deftypefn {Library Function} @code{mglPoint} operator* (@code{float} a, @code{const mglPoint &}b)
-@deftypefnx {Library Function} @code{mglPoint} operator* (@code{const mglPoint &}a, @code{float} b)
+@deftypefn {Library Function} @code{mglPoint} operator* (@code{mreal} a, @code{const mglPoint &}b)
+@deftypefnx {Library Function} @code{mglPoint} operator* (@code{const mglPoint &}a, @code{mreal} b)
Multiplies (scale) points by number.
@end deftypefn
-@deftypefn {Library Function} @code{mglPoint} operator/ (@code{const mglPoint &}a, @code{float} b)
+@deftypefn {Library Function} @code{mglPoint} operator/ (@code{const mglPoint &}a, @code{mreal} b)
Multiplies (scale) points by number 1/b.
@end deftypefn
-@deftypefn {Library Function} @code{float} operator* (@code{const mglPoint &}a, @code{const mglPoint &}b)
+@deftypefn {Library Function} @code{mreal} operator* (@code{const mglPoint &}a, @code{const mglPoint &}b)
Scalar product of vectors.
@end deftypefn
@deftypefn {Library Function} @code{mglPoint} operator! (@code{const mglPoint &}a)
Return vector perpendicular to vector @var{a}.
@end deftypefn
-@deftypefn {Library Function} @code{float} mgl_norm (@code{const mglPoint &}a)
+@deftypefn {Library Function} @code{mreal} mgl_norm (@code{const mglPoint &}a)
Return the norm sqrt(|@var{a}|^2) of vector @var{a}.
@end deftypefn
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node mglFont class, , mglPoint class, Other classes
@section mglFont class
@cindex mglFont
@end deftypemethod
-@deftypemethod mglFont @code{float} Height (@code{int} font)
+@deftypemethod mglFont @code{mreal} Height (@code{int} font)
Gets height of text for font specified by integer constant.
@end deftypemethod
-@deftypemethod mglFont @code{float} Puts (@code{const char *}str, @code{int} font=@code{0}, @code{int} align=@code{0})
+@deftypemethod mglFont @code{mreal} Puts (@code{const char *}str, @code{int} font=@code{0}, @code{int} align=@code{0})
Prints 8-bit text string for font specified by integer constant.
@end deftypemethod
-@deftypemethod mglFont @code{float} Width (@code{const char *}str, @code{int} font=@code{0})
+@deftypemethod mglFont @code{mreal} Width (@code{const char *}str, @code{int} font=@code{0})
Gets width of 8-bit text string for font specified by integer constant.
@end deftypemethod
-@deftypemethod mglFont @code{float} Puts (@code{const wchar_t *}str, @code{int} font=@code{0}, @code{int} align=@code{0})
+@deftypemethod mglFont @code{mreal} Puts (@code{const wchar_t *}str, @code{int} font=@code{0}, @code{int} align=@code{0})
Prints Unicode text string for font specified by integer constant.
@end deftypemethod
-@deftypemethod mglFont @code{float} Width (@code{const wchar_t *}str, @code{int} font=@code{0})
+@deftypemethod mglFont @code{mreal} Width (@code{const wchar_t *}str, @code{int} font=@code{0})
Gets width of Unicode text string for font specified by integer constant.
@end deftypemethod
-@deftypemethod mglFont @code{float} Height (@code{const char *}how)
+@deftypemethod mglFont @code{mreal} Height (@code{const char *}how)
Gets height of text for font specified by string.
@end deftypemethod
-@deftypemethod mglFont @code{float} Puts (@code{const char *}str, @code{const char *}how)
+@deftypemethod mglFont @code{mreal} Puts (@code{const char *}str, @code{const char *}how)
Prints 8-bit text string for font specified by string.
@end deftypemethod
-@deftypemethod mglFont @code{float} Width (@code{const char *}str, @code{const char *}how)
+@deftypemethod mglFont @code{mreal} Width (@code{const char *}str, @code{const char *}how)
Gets width of 8-bit text string for font specified by string.
@end deftypemethod
-@deftypemethod mglFont @code{float} Puts (@code{const wchar_t *}str, @code{const char *}how)
+@deftypemethod mglFont @code{mreal} Puts (@code{const wchar_t *}str, @code{const char *}how)
Prints Unicode text string for font specified by string.
@end deftypemethod
-@deftypemethod mglFont @code{float} Width (@code{const wchar_t *}str, @code{const char *}how)
+@deftypemethod mglFont @code{mreal} Width (@code{const wchar_t *}str, @code{const char *}how)
Gets width of Unicode text string for font specified by string.
@end deftypemethod
@end deftypecv
@c ------------------------------------------------------------------
+@external
@node Format of font files, , , mglFont class
@subsection Format of font files
@item
First string contains human readable comment and is always ignored.
@item
-Second string contains 3 numbers, delimited by space or tabulation. The order of numbers is the following: @var{numg} -- the number of glyphs in the file (integer), @var{fact} -- the factor for glyph sizing (float), @var{size} -- the size of buffer for glyph description (integer).
+Second string contains 3 numbers, delimited by space or tabulation. The order of numbers is the following: @var{numg} -- the number of glyphs in the file (integer), @var{fact} -- the factor for glyph sizing (mreal), @var{size} -- the size of buffer for glyph description (integer).
@item
After it @var{numg}-th strings with glyphs description are placed. Each string contains 6 positive numbers, delimited by space of tabulation. The order of numbers is the following: Unicode glyph ID, glyph width, number of lines in glyph, position of lines coordinates in the buffer (length is 2*number of lines), number of triangles in glyph, position of triangles coordinates in the buffer (length is 6*number of triangles).
@item
Note: the closing contour line is done automatically (so the last segment may be absent). For starting new contour use a point with coordinates @code{@{0x3fff, 0x3fff@}}.
+@external
+
* Utilities::
@end menu
+@external
@node What is MathGL?, MathGL features, , Overview
@section What is MathGL?
At this version (@value{VERSION}) MathGL has more than 50 general types of graphics for 1d, 2d and 3d data arrays. It can export graphics to bitmap and vector (EPS or SVG) files. It has OpenGL interface and can be used from console programs. It has functions for data handling and script MGL language for simplification of data plotting. It also has several types of transparency and smoothed lighting, vector fonts and TeX-like symbol parsing, arbitrary curvilinear coordinate system and many other useful things (see pictures section at @uref{http://mathgl.sf.net/, homepage}). Finally it is platform-independent and free (under GPL v.2.0 or later license).
+@external
@node MathGL features, Installation, What is MathGL?, Overview
@section MathGL features
In fact, I created the functions for drawing of all the types of scientific plots that I know. The list of plots is growing; if you need some special type of a plot then please email me @email{mathgl.abalakin@@gmail.com, e-mail} and it will appear in the new version.
-I tried to make plots as nice looking as possible: e.g., a surface can be transparent and highlighted by several (up to 10) light sources. Most of the drawing functions have 2 variants: simple one for the fast plotting of data, complex one for specifying of the exact position of the plot (including parametric representation). Resulting image can be saved in bitmap PNG, JPEG, TGA, BMP format, or in vector EPS, SVG or TeX format, or in 3D formats OBJ, OFF, STL, or in IDTF format which can be converted into U3D.
+I tried to make plots as nice looking as possible: e.g., a surface can be transparent and highlighted by several (up to 10) light sources. Most of the drawing functions have 2 variants: simple one for the fast plotting of data, complex one for specifying of the exact position of the plot (including parametric representation). Resulting image can be saved in bitmap PNG, JPEG, GIF, TGA, BMP format, or in vector EPS, SVG or TeX format, or in 3D formats OBJ, OFF, STL, or in PRC format which can be converted into U3D.
All texts are drawn by vector fonts, which allows for high scalability and portability. Texts may contain commands for: some of the TeX-like symbols, changing index (upper or lower indexes) and the style of font inside the text string (@pxref{Font styles}). Texts of ticks are rotated with axis rotation. It is possible to create a legend of plot and put text in an arbitrary position on the plot. Arbitrary text encoding (by the help of function @code{setlocale()}) and UTF-16 encoding are supported.
There is fast evaluation of a textual mathematical expression (@pxref{Textual formulas}). It is based on string precompilation to tree-like code at the creation of class instance. At evaluation stage code performs only fast tree-walk and returns the value of the expression. In addition to changing data values, textual formulas are also used for drawing in @emph{arbitrary} curvilinear coordinates. A set of such curvilinear coordinates is limited only by user's imagination rather than a fixed list like: polar, parabolic, spherical, and so on.
+@external
@node Installation, Quick guide, MathGL features, Overview
@section Installation
MathGL can be installed in 4 different ways.
@enumerate
@item
-Compile from sources. The standard script cmake build system is useded in the library. To run it, one should execute commands: @code{cmake .} twice, after it @code{make} and @code{make install} with root/sudo rights. Sometimes after installation you may need to update the library list -- just execute @code{ldconfig} with root/sudo rights.
+Compile from sources. The cmake build system is useded in the library. To run it, one should execute commands: @code{cmake .} twice, after it @code{make} and @code{make install} with root/sudo rights. Sometimes after installation you may need to update the library list -- just execute @code{ldconfig} with root/sudo rights.
There are several additional options which are switched off by default. They are: @code{enable-fltk, enable-glut, enable-qt} for ebabling FLTK, GLUT and/or Qt windows; @code{enable-jpeg, enable-gif, enable-hdf5} and so on for enabling corresponding file formats; @code{enable-all} for enabling all additional features. For using @code{double} as base internal data type use option @code{enable-double}. For enabling language interfaces use @code{enable-python, enable-octave} or @code{enable-langall} for all languages. You can use WYSIWYG tool (@code{cmake-gui}) to view all of them, or type @code{cmake -D enable-all=on -D enable-langall=on .} in command line for enabling all features.
@item
-Use a precompiled binary. There are binaries for MinGW (platform Win32). For a precompiled variant one needs only to unpack the archive to the location of the compiler (or in any other folder and setup paths). By default, precompiled versions include the support of GSL (www.gsl.org) and PNG. So, one needs to have these libraries installed on system (it can be found, for example, at @uref{http://gnuwin32.sourceforge.net/packages.html}).
+Use a precompiled binary. There are binaries for MinGW (platform Win32). For a precompiled variant one needs only to unpack the archive to the location of the compiler (i.e. mathgl/lib in mingw/lib, mathgl/include in mingw/include and so on) or in arbitrary other folder and setup paths in compiler. By default, precompiled versions include the support of GSL (www.gsl.org) and PNG. So, one needs to have these libraries installed on system (it can be found, for example, at @uref{http://gnuwin32.sourceforge.net/packages.html}).
@item
-Install precompiled versions from standard packages (RPM, deb, DevPak and so on, see @uref{http://mathgl.sf.net/download.html, Download} section at homepage).
+Install precompiled versions from standard packages (RPM, deb, DevPak and so on).
@end enumerate
+Note, you can download the latest sources (which can be not stable) from sourceforge.net SVN by command @code{svn co https://mathgl.svn.sourceforge.net/svnroot/mathgl mathgl} or just download MathGL 2.* sources by command @code{svn co https://mathgl.svn.sourceforge.net/svnroot/mathgl/mathgl-2x mathgl-2x} .
@c ------------------------------------------------------------------
+@external
@node Quick guide, Changes from v.1, Installation, Overview
@section Quick guide
This is enough for a compilation of console program or with external (non-MathGL) window library. If you want to use FLTK or Qt windows provided by MathGL then you need to add the option @code{-lmgl-wnd}. Fortran users also should add C++ library by the option @code{-lstdc++}.
@c ------------------------------------------------------------------
+@external
@node Changes from v.1, Utilities, Quick guide, Overview
@section Changes from v.1.*
@end itemize
@c ------------------------------------------------------------------
+@external
@node Utilities, , Changes from v.1, Overview
@section Utilities for parsing MGL
Additionally you can create animated GIF file or a set of JPEG files with names @samp{frameNNNN.jpg} (here @samp{NNNN} is frame index). Values of the parameter @code{$0} for making animation can be specified inside the script by comment @code{##a val} for each value @code{val} (one comment for one value) or by option(s) @samp{-A val}. Also you can specify a cycle for animation by comment @code{##c v1 v2 dv} or by option @code{-C v1:v2:dv}. In the case of found/specified animation parameters, tool will execute script several times -- once for each value of @code{$0}.
+@external
-
@chapter Обзор MathGL
@cindex Обзор MathGL
@end itemize
@menu
-* Why I have written MathGL?::
+* What is MathGL?::
* MathGL features::
-* Installation and usage::
-* General concepts::
-* FAQ::
-* Interfaces::
-* Thanks::
+* Installation::
+* Quick guide::
+* Changes from v.1::
+* Utilities::
@end menu
-@node Why I have written MathGL?, MathGL features, , Overview
-@section Зачем написана MathGL?
+@external
+@node What is MathGL?, MathGL features, , Overview
+@section Что такое MathGL?
Код для создания качественной научной графики на различных платформах. Код для быстрой обработки и отображения больших массивов данных. Код для работы в графическом и консольном режимах и легкого интегрирования в другие программы. Код с большим обновляемым набором графиков и инструментами обработки данных. Именно такого кода мне не хватало в последние годы при работе на персональных компьютерах и на кластерах. И именно такой код я постарался создать в библиотеке MathGL.
На данный момент (версия @value{VERSION}) MathGL это более 50 основных типов графиков для одно-, двух- и трехмерных массивов, возможность экспорта в растровые и векторные (EPS или SVG) файлы, интерфейс для OpenGL и возможность запуска в консольном режиме, функции для обработки данных и даже простейший командный (интерпретируемый) язык MGL для упрощения построения графиков. Кроме того, есть несколько типов прозрачности, гладкое освещение, векторные шрифты, TeX-ие команды в надписях, произвольные криволинейные системы координат и прочие полезные мелочи (см. раздел pictures на @uref{http://mathgl.sf.net/, домашней странице}). Ну, и, естественно, полная переносимость библиотеки и ее свободное распространение под лицензией GPL v.2.0 или более поздней.
-@node MathGL features, Installation and usage, Why I have written MathGL?, Overview
+@external
+@node MathGL features, Installation, What is MathGL?, Overview
@section Возможности MathGL
Библиотека MathGL позволяет строить широкий класс графиков, включая:
Фактически, я постарался реализовать все известные мне типы научных графиков. Список графиков постоянно пополняется, и если Вам нужен какой-то новый вариант, пишите на @email{mathgl.abalakin@@gmail.com, e-mail}, и в новой версии библиотеки этот график появится.
-Я постарался сделать графики максимально красивыми -- поверхности могут быть прозрачными и освещены произвольно расположенными источниками света (максимальное их количество 10). Большинство функций рисования имеет два варианта: простой для быстрого построения картинки и более сложный для детальной настройки отображения, включающего в том числе возможность параметрического задания всех массивов. Получившееся изображение можно сохранить в растровом формате PNG, JPEG, GIF, TGA или BMP; в векторном EPS, SVG или TeX формате, и в IDTF формате (с помощью класса mglGraphIDTF), который можно конвертировать в U3D формат.
+Я постарался сделать графики максимально красивыми -- поверхности могут быть прозрачными и освещены произвольно расположенными источниками света (максимальное их количество 10). Большинство функций рисования имеет два варианта: простой для быстрого построения картинки и более сложный для детальной настройки отображения, включающего в том числе возможность параметрического задания всех массивов. Получившееся изображение можно сохранить в растровом формате PNG, JPEG, GIF, TGA или BMP; в векторном EPS, SVG или TeX формате, или в 3D формате OBJ, OFF, STL, или в PRC формате, который может быть конвертирован U3D.
Все надписи выводятся векторным шрифтом, что обеспечивает их хорошую масштабируемость и переносимость. Текст может содержать команды для большинства ТеХ-их символов, изменения положения (верхний и нижний индексы) и стиля шрифта внутри строки текста (@pxref{Font styles}). Текст меток поворачивается вместе с осями. На график можно вывести описание кривых (легенду) и поместить надпись в произвольную точку экрана или пустить ее вдоль кривой. Поддерживаются произвольные кодировки текста (с помощью стандартной функции @code{setlocale()}) и текст в кодировке UTF-16.
Для @emph{быстрого} вычисления значения выражения, заданного текстовой строкой (@pxref{Textual formulas}). Он основан на компиляции строки в древоподобную структуру при создании экземпляра класса. На этапе вычисления происходит быстрый обход дерева с выдачей результата для конкретных значений переменных. Помимо изменения значений массива данных, текстовые формулы используются для рисования в @emph{произвольной} криволинейной системе координат. Набор таких координат ограничивается только фантазией пользователя, а не фиксированным числом (типа полярной, параболической, цилиндрической и т.д.).
-@node Installation and usage, General concepts, MathGL features, Overview
+@external
+@node Installation, Quick guide, MathGL features, Overview
@section Установка MathGL
Установка библиотеки возможна 4-мя способами.
@enumerate
@item
-Скомпилировать библиотеку непосредственно из исходных файлов. С библиотекой поставляется стандартный скрипт для autoconf/automake. Для его запуска достаточно в командной строке выполнить 3 команды: сначала @code{./configure} далее @code{make} и, наконец, с правами суперпользователя @code{make install}. Иногда после компиляции библиотеки может потребоваться обновление списка библиотека в системе -- выполните команду @code{ldconfig} с правами суперпользователя. Замечу, что если используется версия из SVN, то вначале (перед @code{./configure}) следует выполнить команду @code{./bootstrap}.
-
-Скрипт @code{./configure} имеет несколько дополнительных опций, которые по умолчанию отключены. К их числу относятся: @code{--enable-fltk, --enable-glut, --enable-qt} для поддержки FLTK, GLUT и/или Qt окон; @code{--enable-jpeg, --enable-gif, --enable-hdf5} для поддержки соответствующих форматов; @code{--enable-all} для включения всех возможностей. Для использования типа @code{double} для внутреннего хранения данных используйте опцию @code{--enable-double}. Для создания интерфейсов к другим языкам (кроме С/Фортран/MGL) используйте опции @code{--enable-python, --enable-octave} или @code{--enable-langall} для всех поддерживаемых языков. Полный список опций можно увидеть, выполнив @code{./configure --help}.
+Скомпилировать библиотеку непосредственно из исходных файлов. С библиотекой поставляется файлы для системы сборки CMake. Для его запуска достаточно в командной строке выполнить 3 команды: сначала @code{cmake .} дважды, далее @code{make} и, наконец, с правами суперпользователя @code{make install}. Иногда после компиляции библиотеки может потребоваться обновление списка библиотека в системе -- выполните команду @code{ldconfig} с правами суперпользователя.
-@item
-В случае если инструменты autoconf/automake не доступны (например, при компиляции под Windows или MacOS), то можно воспользоваться системой сборки CMake. В данном случае сборка самой библиотеки и утилит возможна и не на GNU компиляторах.
+Есть несколько дополнительных опций, которые по умолчанию отключены. К их числу относятся: @code{enable-fltk, enable-glut, enable-qt} для поддержки FLTK, GLUT и/или Qt окон; @code{enable-jpeg, enable-gif, enable-hdf5} для поддержки соответствующих форматов; @code{enable-all} для включения всех возможностей. Для использования типа @code{double} для внутреннего хранения данных используйте опцию @code{enable-double}. Для создания интерфейсов к другим языкам (кроме С/Фортран/MGL) используйте опции @code{enable-python, enable-octave} или @code{enable-langall} для всех поддерживаемых языков. Вы можете воспользоваться WYSIWYG утилитой (@code{cmake-gui}) для просмотра и изменения всех опций, или выполнить @code{cmake -D enable-all=on -D enable-langall=on .} в командной строке для включения всех опций.
@item
Использовать предварительно скомпилированные файлы -- с библиотекой поставляются файлы для MinGW (платформа Win32). В скомпилированной версии достаточно распаковать заголовочные файлы в папку с заголовочными файлами и библиотеку libmgl.a в папку с библиотеками. По умолчанию, скомпилированная версия включают поддержку GSL (www.gsl.org), PNG, GIF и JPEG. Соответственно, при сборке программы эти библиотеки должны быть установлены (их можно найти на @uref{http://gnuwin32.sourceforge.net/packages.html}).
Установить из стандартных пакетов (RPM, deb, DevPak и пр.).
@end enumerate
-При сборке пользовательской программы достаточно указать ключ @code{-lmgl} для компиляции в консольной программе или с использованием внешней графической библиотеки. При использовании окон FLTK или GLUT надо указать/добавить ключи, включающие соответствующие библиотеки -- @code{-lmgl-fltk} или @code{-lmgl-glut}. Для использования в Фортране дополнительно надо указать опцию @code{-lstdc++} для библиотек C++.
-
-@node General concepts, FAQ, Installation and usage, Overview
-@section Основные принципы
-
-Возможности библиотеки MathGL довольно богаты -- число только основных типов графиков превышает 50 видов. Кроме того, есть функции для обработки данных, настройки вида графика и пр. и пр. Тем не менее, я старался придерживаться единого стиля в порядке аргументов функций и способе их ``настройки''. В основном все ниже сказанное относится к функциям рисования различных графиков.
-
-Всего основных концепций (базисных идей) шесть:
-@enumerate
-@item
-@strong{Все рисунки создаются в памяти.} Это могут быть как растровые картинки (для @code{SetQuality(MGL_DRAW_LMEM)}), так и векторные списки примитивов (по умолчанию). Дальнейшая судьба рисунков определяется пользователем: можно сохранить в файл, вывести на экран, создать анимацию/кино, дополнительно отредактировать и т.д. Такой подход обеспечивает высокую переносимость библиотеки -- один и тот же программный код создаст в точности одинаковый рисунок на @emph{любой} операционной системе. Кроме того, при таком подходе рисунки можно создавать непосредственно в консольной программе -- графическое окно не нужно!
-@item
-@strong{Все настройки графиков (стиль линий, цветовые схемы поверхностей, стиль и цвет текста) задаются строками.} Это обеспечивает: удобство для пользователя -- короткую строку легче читать и здесь тяжелее ошибиться, чем в большом списке параметров; переносимость -- строки выглядят одинаково на всех платформах и не надо заботиться о типе и числе аргументов.
-@item
-@strong{Все функции имеют ``упрощенный'' и ``продвинутый'' варианты.} Сделано опять из-за удобства. В ``упрощенном'' варианте для построения графика нужны только один-два массив(а) данных, которые автоматически равнораспределяются в заданном диапазоне осей координат. В ``продвинутой'' версии можно не только указать явно диапазон построения графика, но и задать его параметрически. Последнее позволяет легко строить довольно сложные кривые и поверхности. В обоих вариантах функций порядок аргументов стандартен: сначала идут массивы данных, потом необязательный строковый параметр стиля графика, а далее строка опций для более точной настройки графика.
-@item
-@strong{Все данные передаются через экземпляры класса mglData(A).} Такой подход позволяет избежать ошибок при работе с памятью и единообразно передавать данные разных типов (float, double, данные из файла, заполненных пользователем и пр.) в функции рисования.
-@item
-@strong{Все элементы рисунков векторные.} Изначально библиотека MathGL была ориентированна на работу с научными данными, которые по своей природе векторные (линии, грани, матрицы и т.д.). Поэтому векторность используется во всех рисунках! Причем иногда даже в ущерб производительности (например, при выводе шрифтов). Помимо всего прочего, векторность позволяет легко масштабировать рисунок -- измените размер картинки в 2 раза, и рисунок пропорционально растянется.
-@item
-@strong{Новые графики не удаляют уже нарисованное.} Этот, в чем-то неожиданный, подход позволяет создавать огромное количество ``комбинированных'' графиков. Например, поверхность с наложенными линиями уровня строится двумя последовательными вызовами функций рисования поверхности и линий уровня (в любом порядке). И совершенно не надо писать специальную функцию (как в Matlab и некоторых других программах) для рисования этого графика. Примеров таких графиков можно привести множество (см. раздел @ref{Hints} и сайт программы @uref{http://mathgl.sf.net/index.html}).
-@end enumerate
-
-Кроме основных концепций я хотел бы остановиться на нескольких, как оказалось, нетривиальных моментах -- способе указания положения графика, осей координат и строковых параметров линий, поверхностей, текста.
-
-@menu
-* Coordinate axes::
-* Line styles::
-* Color scheme::
-* Font styles::
-* Textual formulas::
-* Command options::
-@end menu
-
-@include concept_ru.texi
-
-
-@node FAQ, Interfaces, General concepts, Overview
-@section FAQ
-
-@table @strong
-@item График не рисуется?!
-Проверьте, что точки графика находятся внутри ограничивающего параллелепипеда, при необходимости увеличьте его с помощью функции @code{Axis()}. Проверьте, что размерность массива правильная для выбранного типа графика. Убедитесь, что функция @code{Finish()} была вызвана после построения графика (или график был сохранен в файл). Иногда отражение света от плоских поверхностей (типа, @code{Dens()}) может выглядеть как отсутствие графика.
+@c TODO Translate it!
-@item Не нашел нужного графика?!
-Многие ``новые'' графики можно строить, используя уже существующие функции. Например, поверхность вращения кривой относительно оси можно построить, используя специальную функцию @code{Torus()}, а можно построить как параметрически заданную поверхность @code{Surf()}. См. также @ref{Hints} и @ref{Examples} MathGL. Если же нужного типа графика все равно нет, то пишите мне @email{mathgl.abalakin@@gmail.com, e-mail} и в следующей версии этот график появится.
+Note, you can download the latest sources (which can be not stable) from sourceforge.net SVN by command @code{svn co https://mathgl.svn.sourceforge.net/svnroot/mathgl mathgl} or just download MathGL 2.* sources by command @code{svn co https://mathgl.svn.sourceforge.net/svnroot/mathgl/mathgl-2x mathgl-2x} .
-@item Требуется ли знание сторонних библиотек (например, OpenGL) для использования библиотеки MathGL?
-Нет. Библиотека MathGL самодостаточна и не требует знания сторонних библиотек.
+@c ------------------------------------------------------------------
+@external
+@node Quick guide, Changes from v.1, Installation, Overview
+@section Quick guide
-@item На каком языке написана библиотека? Для каких языков у нее есть интерфейсы?
-Ядро библиотеки написано на С++. Кроме него, есть интерфейсы для чистого С, фортрана, паскаля, форта и собственный командный язык MGL. Также есть поддержка большого числа интерпретируемых языков (Python, Java, ALLEGROCL, CHICKEN, Lisp, CFFI, C#, Guile, Lua, Modula 3, Mzscheme, Ocaml, Octave, Perl, PHP, Pike, R, Ruby, Tcl). Эти интерфейсы написаны с помощью SWIG (и функции чистого С и классы). Однако на данный момент только интерфейсы для Python и Octave включены в скрипты сборки. Причина в том, что я не знаю других языков, чтобы проверить качество интерфейса :(. Замечу, что большинство прочих языков могут использовать С функции напрямую.
+There are 3 steps to prepare the plot in MathGL: (1) prepare data to be plotted, (2) setup plot, (3) plot data. Let me show this on the example of surface plotting.
-@item Как мне использовать MathGL с Фортраном?
-Библиотеку MathGL можно использовать как есть с компилятором @code{gfortran} поскольку он использует по умолчанию AT&T нотацию для внешних функций. Для других компиляторов (например, Visual Fortran) необходимо включить использование AT&T нотации вручную. AT&T нотация требует, чтобы имя функции завершалось символом @samp{_}, аргументы функции передавались по указателю и длины строк передавались в конце списка аргументов. Например:
-
-@emph{C функция} -- @code{void mgl_fplot(HMGL graph, const char *fy, const char *stl, int n);}
-
-@emph{AT&T функция} -- @code{void mgl_fplot_(uintptr_t *graph, const char *fy, const char *stl, int *n, int ly, int ls);}
-
-@item У меня есть класс Foo и в нем метод рисования Foo::draw(mglGraph *gr). Как мне нарисовать что-то в окне FLTK, GLUT или Qt?
-Функции-члены класса в С++ имеют ``скрытый'' параметр -- указатель на экземпляр класса и их прямое использование невозможно. Решением будет определение интерфейсной функции:
-@example
-int foo_draw(mglGraph *gr, void *par)
-@{ ((Foo *)foo)->draw(gr); @}
-@end example
-и подстановка именно ее в вызов функции @code{Window()}:
-@example
-gr->Window(argc,argv,foo_draw,"Title",this);
-@end example
-
-Можно также наследовать Ваш класс от класса @code{mglDraw} и использовать функцию типа @code{gr->Window(argc, argv, foo, "Title");}.
-
-@item Как мне вывести текст на русском/испанском/арабском/японском и т.д.?
-Стандартный путь состоит в использовании кодировки UTF-8 для вывода текста. Кроме того, все функции вывода текста имеют интерфейс для 8-битных (char *) строк. Однако в последнем случае Вам может потребоваться установить используемую в исходном тексте локаль. Например, для русского языка в кодировке CP1251 можно использовать @code{setlocale(LC_CTYPE, "ru_RU.cp1251");} (под MS Windows имена локали другие -- @code{setlocale(LC_CTYPE, "russian_russia.1251")}). Настоятельно не рекомендую использовать константу @code{LC_ALL}, поскольку при этом меняется и формат чисел (в частности, десятичная точка), что может, например, вызвать сложности (неудобство) при написании формул и чтении текстовых файлов. Например, программа ожидает @samp{,} в качестве разделителя целой и дробной части, а пользователь вводит @samp{.}.
-
-@item Как мне вырезать (исключить из рисования) точку или область на графике?
-Есть три основных способа. Во-первых, можно вырезать точку, задав одну из ее координат равной @code{NAN}. Во-вторых, можно воспользоваться функцией @code{SetCutBox()} или @code{CutOff()} для удаления точек из некоторой области (@pxref{Cutting}). Наконец, можно сделать эти точки прозрачными (невидимыми) с помощью функций @code{SurfA()}, @code{Surf3A()} (@pxref{Dual plotting}). В последнем случае обеспечивается еще и плавность включения прозрачности.
-
-@item Я использую VisualStudio, CBuilder или другой компилятор (не MinGW/gcc). Как мне подключить библиотеку MathGL?
-Начиная с версии 2.0, рекомендуемый к использованию класс mglGraph (заголовочный файл @code{#include <mgl2/mgl.h>}) содержbn только с @code{inline} функции и может использоваться с любым компилятором без перекомпиляции бинарной версии библиотеки. Однако, если Вы планируете использовать низкоуровневые возможности (т.е. классы mglBase, mglCanvas и т.д.), то Вам следует перекомпилировать библиотеку MathGL с использованием Вашего компилятора.
-
-@item Как мне собрать MathGL под Windows?
-Простейший путь -- использование комбинации CMake и MinGW. Также Вам может потребоваться дополнительные библиотеки, такие как GSL, PNG, JPEG и пр. Все они могут быть найдены на @url{http://gnuwin32.sourceforge.net/packages.html}. После установки всех компонент, просто запустите конфигуратор CMake и соберите MathGL командой make.
-
-@item Как создать окно FLTK/GLUT/Qt с текущими результатами параллельно с выполнением основных вычислений?
-Следует создать отдельный поток для обработки сообщений в окно. Кросс-платформенный путь -- использование библиотеки @code{pthread}. Обновление данных в окне можно выполнить вызовом функции @code{mglGraphFLTK::Update()}. Пример код имеет вид:
+First we need the data. MathGL use its own class @code{mglData} to handle data arrays (see @ref{Data processing}). This class give ability to handle data arrays by more or less format independent way. So, create it
@verbatim
-//-----------------------------------------------------------------------------
-#include <mgl2/window.h>
-#include <pthread.h>
-
-mglPoint pnt; // some global variable for changable data
-//-----------------------------------------------------------------------------
-int sample(mglGraph *gr)
-{
- gr->Box(); gr->Line(mglPoint(),pnt,"Ar2"); // just draw a vector
- return 0;
-}
-//-----------------------------------------------------------------------------
-void *mgl_fltk_tmp(void *) { mglFlRun(); return 0; }
-int main (int argc, char ** argv)
-{
- mglWindow gr(0,sample,"test"); // create window
- static pthread_t tmp;
- pthread_create(&tmp, 0, mgl_fltk_tmp, 0);
- pthread_detach(tmp); // run window handling in the separate thread
- for(int i=0;i<10;i++) // do calculation
- {
- sleep(1); // which can be very long
- pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);
- gr.Update(); // update window
- }
- return 0; // finish calculations and close the window
-}
-//-----------------------------------------------------------------------------
+ int main()
+ {
+ mglData dat(30,40); // data to for plotting
+ for(long i=0;i<30;i++) for(long j=0;j<40;j++)
+ dat.a[i+30*j] = 1/(1+(i-15)*(i-15)/225.+(j-20)*(j-20)/400.);
@end verbatim
-В случае если требуется вывести статичную картинку с текущими результатами расчетов, то достаточно передать @code{NULL} вместо функции рисования и вызывать @code{Update()} по мере необходимости для обновления графика. Такой способ подходит и для пользователей фортрана.
+Here I create matrix 30*40 and initialize it by formula. Note, that I use @code{long} type for indexes @var{i}, @var{j} because data arrays can be really large and @code{long} type will automatically provide proper indexing.
+
+Next step is setup of the plot. The only setup I need is axis rotation and lighting.
@verbatim
-//-----------------------------------------------------------------------------
-#include <mgl2/window.h>
-//-----------------------------------------------------------------------------
-int sample(mglGraph *gr)
-{
- gr->Box(); gr->Line(mglPoint(),pnt,"Ar2"); // just draw a vector
- return 0;
-}
-//-----------------------------------------------------------------------------
-void *mgl_fltk_tmp(void *) { mglFlRun(); return 0; }
-int main (int argc, char ** argv)
-{
- mglWindow gr(0,NULL,"test"); // create window
- for(int i=0;i<10;i++) // do calculation
- {
- sleep(1); // which can be very long
- pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);
- sample(&gr); // draw picture
- gr.Update(); // update window
- }
- return 0; // finish calculations and close the window
-}
-//-----------------------------------------------------------------------------
+ mglGraph gr; // class for plot drawing
+ gr.Rotate(50,60); // rotate axis
+ gr.Light(true); // enable lighting
@end verbatim
-@item Сколько человек участвовало в создании библиотеки?
-Большую часть библиотеки написал один человек. Это результат примерно года работы на написание ядра библиотеки и базовых функций (в основном вечерами и по выходным). Процесс усовершенствования продолжается и теперь :). Скрипты сборки в основном написаны Д.Кулагиным, а экспорт в IDTF написан М.Видассовым.
-
-@item Как мне показать растровую картинку на рисунке?
-Можно импортировать ее в экземпляр @code{mglData} и построить с помощью функции @code{Dens()}. Например, для черно-белого рисунка можно использовать код: @code{mglData bmp; bmp.Import("fname.png","wk"); gr->Dens(bmp,"wk");}.
-
-@item Как использовать MathGL в Qt, FLTK, wxWidgets ...?
-Есть специальные классы (виджеты) для этих библиотек: QMathGL для Qt, Fl_MathGL для FLTK и т.д. Если Вы не нашли подходящий класс, то можете создать свой собственный виджет, рисующий растровое изображение из mglCanvas::GetBits().
-
-@item Как мне создать U3D файл (3D in PDF)?
-Процедура состоит из двух шагов: создания файла IDTF и его конвертация в U3D. Можно использовать @uref{http://sourceforge.net/project/showfiles.php?group_id=152187&package_id=300628, U3D tools} для конвертации IDTF в U3D. Ему требуется библиотека @uref{http://libharu.org, libharu} 2.1.0 или более поздняя. Для установки используйте обычную процедуру @code{./bootstrap, ./configure, make, sudo make install}. В результате появится программа IDTFConverter для конвертации файлов *.idtf в бинарные файлы *.u3d. Последние можно включить в PDF.
-
-@item Как сменить шрифт (семейство шрифтов)?
-Во-первых, надо загрузить файлы @uref{http://mathgl.sourceforge.net/download.html, отсюда} или @uref{http://sourceforge.net/project/showfiles.php?group_id=152187&package_id=267177, отсюда}. Далее, в экземпляре mglGraph загружаем шрифты: @code{gr->LoadFont(fontname,path);}. Здесь @var{fontname} -- базовое имя шрифта, например @samp{STIX}, и @var{path} -- путь к папке с файлами шрифтов. Вызовите @code{gr->RestoreFont();} для использования шрифта по умолчанию.
-
-@item Как нарисовать метки оси снаружи от графика?
-Просто используйте отрицательные значения длины меток, например @code{gr->SetTickLen(-0.1);}.
-
-@end table
-
-@node Interfaces, Thanks, FAQ, Overview
-@section Интерфейсы
-
-Библиотека MathGL имеет интерфейсы к целому ряду языков программирования. Большинство из них базируется на С интерфейсе и построены с помощью инструментария SWIG. Сюда входят Python, Java, Octave, Lisp, C#, Guile, Lua, Modula 3, Ocaml, Perl, PHP, Pike, R, Ruby, Tcl. Кроме того, есть отдельный интерфейс к Фортрану, имеющий похожий набор функций, но со слегка различным типом аргументов (использованы целые вместо указателей). Функции С и Фортран интерфейса помечены [функции С].
-@c ++++++++++
-Некоторые из языков представленных выше поддерживают объектное программирование (классы). Для них написан собственная оболочка и соответствующие функции/методы помечены (Python). Функции и методы доступные в С++ помечены (С++).
-@c ++++++++++
-Наконец, специальный командный язык MGL был написан для быстрого доступа к функциям C++ со всеми их возможностями. Скрипты MGL могут быть выполнены как из внешних программ (UDAV, mglconv, mglview и т.д.) так и из кода на C++/C/Python и пр. (@pxref{mglParse class}).
-
-@menu
-* C interface::
-* Python interface::
-* MGL interface::
-@end menu
-
-@node C interface, Python interface, , Interfaces
-@subsection C/Фортран интерфейс
-
-C интерфейс является базовым для большинства других интерфейсов. Он содержит функции на чистом C для большинства методов классов MathGL. В отличие от членов-функций C++ классов, C функции в качестве аргументов должны явно иметь переменные типа HMGL (для графики) и/или HMDT (для массивов данных) для указания объекта рисования или данных. Таким образом, первым вызовом пользователя должно быть создание этих объектов с помощью функций @code{mgl_create_*()}, а последним -- их удаление с помощью функций @code{mgl_delete_*()}.
-
-Все функции описанны в заголовочном файле @code{#include <mgl2/mgl_c.h>} и используют переменные для идентификаторов объектов рисования/данных следующих типов:
-@itemize
-@item
-@code{HMGL} --- Указатель на класс @code{mglGraph} (@pxref{MathGL core}).
-@item
-@code{HMDT} --- Указатель на класс @code{mglData} (@pxref{Data processing}).
-@item
-@code{HMPR} --- Указатель на класс @code{mglParse} (@pxref{mglParse class})..
-@end itemize
-Эти переменные содержат идентификаторы объектов графики или данных.
-
-Фортрановские функции имеют те же имена, что и функции C. Однако, есть различие: переменные типов @code{HMGL, HMDT} должны быть объявлены как целые достаточной разрядности (integer*4 на 32-битных системах или integer*8 на 64-битных системах). Все С функции являются процедурами для Фортрана (должны вызываться с помощью оператора call). Исключение составляют функции, возвращающие переменные типа @code{HMGL} или @code{HMDT}. Последние должны быть объявлены целыми для использования в фортрановском коде. Также помните, что строки в фортране обозначаются одинарной кавычкой @code{'}, а не двойной @code{"} как в С/С++.
-
-@node Python interface, MGL interface, C interface, Interfaces
-@subsection C++/Python interface
-
-MathGL provides the interface to a set of languages via SWIG library. Some of these languages support classes. The typical example is Python -- which is named in this chapter's title. Exactly the same classes are used for high-level C++ API. Its feature is using only inline member-functions what make high-level API to be independent on compiler even for binary build.
-
-There are 2 classes in:
-@itemize
-@item @code{mglGraph}
--- provide most plotting functions (@pxref{MathGL core}).
-@item @code{mglData}
--- provide base data processing (@pxref{Data processing}). It have an additional feature to access data values. You can use a construct like this: @code{dat[i]=sth;} or @code{sth=dat[i]} where flat representation of data is used (i.e., @var{i} can be in range 0...nx*nx*nz-1). You can also import NumPy arrays as input arguments in Python: @code{mgl_dat = mglData(numpy_dat);}.
-@c @item @code{mglParse} -- practically the same as C++ class @code{MathGL provides the interface to a set of languages via SWIG library. Some of these languages support classes. The typical example is Python -- which is denoted in the chapter title.
-@end itemize
-
-
-To use Python classes just execute @samp{import mathgl}. The simplest example will be:
+Everything is ready. And surface can be plotted.
@verbatim
-import mathgl
-a=mathgl.mglGraph()
-a.Box()
-a.WritePNG("test.png")
+ gr.Surf(dat); // plot surface
@end verbatim
-Alternatively you can import all classes from @code{mathgl} module and easily access MathGL classes like this:
+Basically plot is done. But I decide to add yellow (@samp{y} color, see @ref{Color styles}) contour lines on the surface. To do it I can just add:
@verbatim
-from mathgl import *
-a=mglGraph()
-a.Box()
-a.WritePNG("test.png")
+ gr.Cont(dat,"y"); // plot yellow contour lines
+@end verbatim
+This demonstrate one of base MathGL concept (see, @ref{General concepts}) -- ``new drawing never clears things drawn already''. So, you can just consequently call different plotting functions to obtain ``combined'' plot. For example, if one need to draw axis then he can just call one more plotting function
+@verbatim
+ gr.Axis(); // draw axis
@end verbatim
-This becomes useful if you create many @code{mglData} objects, for example.
-
-@node MGL interface, , Python interface, Interfaces
-@subsection MGL interface
+Now picture is ready and we can save it in a file.
+@verbatim
+ gr.WriteFrame("sample.png"); // save it
+ }
+@end verbatim
-MathGL имеет встроенный скриптовый язык MGL для обработки и отображения данных. Скрипты MGL можно использовать как независимо (программами UDAV, mgl2png, mgl2eps, mgl2svg и пр., @pxref{Utilities}) так и вызовами библиотеки.
+To compile your program, you need to specify the linker option @code{-lmgl}.
-Язык MGL достаточно простой. Каждая строка -- отдельная команда. Первое слово -- имя команды, а все остальные ее аргументы. Команда может иметь до 1000 аргументов (по крайней мере сейчас). Слова разделяются одно от другого пробелом или символом табуляции. Различий между верхним и нижним индексом нет, т.е. переменные @var{a} и @var{A} идентичны. Символ @samp{#} начинает комментарий -- все символы после него игнорируются до конца строки. Исключением является случай, когда @samp{#} входит в строку. Опции команды указываются после символа @samp{;} (@pxref{Command options}). Символ @samp{:} начинает новую команду (подобно переводу строки) если он расположен не внутри скобок или строки.
+This is enough for a compilation of console program or with external (non-MathGL) window library. If you want to use FLTK or Qt windows provided by MathGL then you need to add the option @code{-lmgl-wnd}. Fortran users also should add C++ library by the option @code{-lstdc++}.
-Если строка содержит ссылки на внешние параметры (@samp{$0}, @samp{$1} ... @samp{$9}) или макроопределения (@samp{$a}, @samp{$b} ... @samp{$z}), то текущие значения параметров/макроопределений подставляются в строку вместо ссылки до выполнением команды. Это позволяет использовать один и тот же скрипт при различных входных параметрах командной строки или вводить макроопределения по ходу исполнения команд скрипта.
+@c ------------------------------------------------------------------
+@external
+@node Changes from v.1, Utilities, Quick guide, Overview
+@section Changes from v.1.*
-Аргументы команды могут быть строками, переменными или числами.
+There are a lot of changes for v.2. Here I denote only main of them.
@itemize @bullet
@item
-Строка -- произвольный набор символов между метками @samp{'}.
-
+mglGraph class is single plotter class instead of mglGraphZB, mglGraphPS and so on.
@item
-Обычно переменная имеет имя, состоящее из букв и чисел (должно начинаться с буквы и не быть длиннее 64 символов). В качестве переменной можно использовать временные массивы, включающие в себя:
-@itemize @bullet
+Text style and text color positions are swapped. I.e. text style @samp{r:C} give red centered text, but not roman dark cyan text as for v.1.*.
@item
-срезы (``подмассивы'') массивов данных (подобно команде @ref{subdata}). Например, @code{a(1)} или @code{a(1,:)} или @code{a(1,:,:)} -- вторая строка массива @var{a}, @code{a(:,2)} или @code{a(:,2,:)} -- третий столбец, @code{a(:,:,0)} -- первый срез и т.д. Также можно выделить часть массива с m-го по n-ый элемент @code{a(m:n,:,:)} или просто @code{a(m:n)}.
-
+ColumnPlot() indexing is reverted.
@item
-произвольные комбинации столбцов данных (например, @code{a('n*w^2/exp(t)')}), если столбцы данных были именованы командой @ref{idset} или в файле данных (в строке начинающейся с @code{##}).
-
+Move most of arguments of plotting functions into the string parameter and/or options.
@item
-произвольное выражение из существующих переменных и констант. Например, @samp{sqrt(dat(:,5)+1)} даст временный массив данных с элементами равными @code{tmp[i,j] = sqrt(dat[i,5,j]+1)}.
-
+``Bright'' colors (like @{b8@}) can be used in color schemes and line styles.
@item
-массивы с элементами заданными в квадратных скобках [], разделенные @samp{,}. При этом внутри выражения не должно быть пробелов! Например, @samp{[1,2,3]} даст временный массив из 3 элементов @{1, 2, 3@}; @samp{[[11,12],[21,22]]} даст матрицу 2*2 и т.д. Элементами такой конструкции могут быть и массивы если их размерности одинаковые, например @samp{[v1,v2,...,vn]}.
-
+Intensively use pthread internally for parallelization of drawing and data processing.
@item
-результат команд построения новых данных (@pxref{Make another data}), если они заключены в фигурные скобки @{@}. Например, @samp{@{sum dat 'x'@}} даст временный массив, который есть результат суммирования @var{dat} вдоль 'x'. Это такой же массив как и @var{tmp}, полученный командой @samp{sum tmp dat 'x'}. При этом можно использовать вложенные конструкции, например @samp{@{sum @{max dat 'z'@} 'x'@}}.
-@end itemize
-Временные массивы не могут стоять в качестве первого аргумента команд, создающих массивы (например, @samp{new}, @samp{read}, @samp{hist} и т.д.).
-
+Add tick labels rotation and skipping. Add ticks in time/date format.
+@item
+New kinds of plots (Tape(), Label(), Cones(), ContV()). Extend existing plots. New primitives (Circle(), Ellipse(), Rhomb(), ...). New plot positioning (MultiPlot(), GridPlot())
+@item
+Improve MGL scripts. Add 'ask' command and allow string concatenation from different lines.
+@item
+Export to LaTeX and to 3D formats (OBJ, OFF, STL).
@item
-К скалярным переменным, кроме собственно чисел, относятся: специальные переменные @code{nan=#QNAN, pi=3.1415926..., on=1, off=0, :=-1}, переменные с суффиксами (@pxref{Data information}), переменные определенные командой @ref{define}. Также массивы размером 1x1x1 считаются скалярами (например, @samp{pi/dat.nx}).
+Add pipes support in utilities (@code{mglconv, mglview}).
@end itemize
-Перед первым использованием все переменные должны быть определены с помощью команд, создающих массивы (@ref{new}, @ref{var}, @ref{list}, @ref{copy}, @ref{read}, @ref{hist}, @ref{sum} и др., @pxref{Data create} и @ref{Make another data}).
-Команды могут иметь несколько наборов аргументов (например, @code{plot ydat} и @code{plot xdat ydat}). Все аргументы команды для выбранного набора должны быть указаны, однако часть из них могут иметь значения по умолчанию. Такие аргументы в описании команд будут помещены в квадратные скобки [], например @code{plot ydat ['stl'='' zval=nan]}. При этом запись @code{[arg1 arg2 arg3 ...]} подразумевает @code{[arg1 [arg2 [arg3 ...]]]}, т.е. опускать можно только аргументы с конца, если вы согласны с их значениями по умолчанию. Например, @code{plot ydat '' 1} или @code{plot ydat ''} правильно, а @code{plot ydat 1} не правильно (аргумент @code{'stl'} пропущен).
+@c ------------------------------------------------------------------
+@external
+@node Utilities, , Changes from v.1, Overview
+@section Utilities for parsing MGL
+MathGL library provides several tools for parsing MGL scripts. There is tools saving it to bitmap or vectorial images (@code{mglconv}). Tool @code{mglview} show MGL script and allow to rotate and setup the image. Another feature of @code{mglview} is loading *.mgld files (see @code{ExportMGLD()}) for quick viewing 3d pictures.
-@node Thanks, , Interfaces, Overview
-@section Благодарности
-
-@itemize @bullet
-@item
-My special thanks to Marina Balakina for the patience during library writing and for the help in documentation writing and spelling.
-@item
-I'm thankful to D. Kulagin and S.M. Plis for making Debian packages.
-@item
-I'm thankful to M. Vidassov for the help in handling solid UTF-8 fonts.
-@item
-I'm thankful to N. Troickiy and V. Lipatov for making RPM packages.
-@item
-I'm thankful to S. Skobelev, A. Korotkevich, V. Onuchin, S.M. Plis, R. Kiselev, A. Ivanov, M. Vidiassov and V. Lipatov for fruitful comments.
+Both tools have similar set of arguments. They can be name of script file or options. You can use @samp{-} as script name for using standard input (i.e. pipes). Options are:
+@itemize
+@item @strong{-1} @var{str}
+set @var{str} as argument $1 for script;
+@item ...
+...
+@item @strong{-9} @var{str}
+set @var{str} as argument $9 for script;
+@item @strong{-A} @var{val}
+add @var{val} into the list of animation parameters;
+@item @strong{-C} @var{v1}:@var{v2}[:@var{dv}]
+add values from @var{v1} ot @var{v2} with step @var{dv} (default is 1) into the list of animation parameters;
+@item @strong{-L} @var{loc}
+set locale to @var{loc};
+@item @strong{-o} @var{name}
+set output file name;
+@item @strong{-h}
+print help message.
@end itemize
+
+Additionally you can create animated GIF file or a set of JPEG files with names @samp{frameNNNN.jpg} (here @samp{NNNN} is frame index). Values of the parameter @code{$0} for making animation can be specified inside the script by comment @code{##a val} for each value @code{val} (one comment for one value) or by option(s) @samp{-A val}. Also you can specify a cycle for animation by comment @code{##c v1 v2 dv} or by option @code{-C v1:v2:dv}. In the case of found/specified animation parameters, tool will execute script several times -- once for each value of @code{$0}.
+
+@external
@c ------------------------------------------------------------------
+@external
@node MGL definition, Program flow commands, , MGL scripts
@section MGL definition
@c ------------------------------------------------------------------
+@external
@node Program flow commands, MGL definition, MGL scripts
@section Program flow commands
@ifclear UDAV
@c ------------------------------------------------------------------
+@external
@node mglParse class, , Program flow commands, MGL scripts
@section mglParse class
@cindex mglParse
@end deftypefn
@end ifclear
+
+@external
+
@c ------------------------------------------------------------------
-@chapter MGL scripts
+@chapter Скрипты MGL
+
+@c TODO Translate it!
MathGL library supports the simplest scripts for data handling and plotting. These scripts can be used independently (with the help of UDAV, mglconv, mglview programs and others
@ifclear UDAV
@c ------------------------------------------------------------------
+@external
@node MGL definition, Program flow commands, , MGL scripts
-@section MGL definition
+@section Основы MGL
-MGL script language is rather simple. Each string is a command. First word of string is the name of command. Other words are command arguments. Command may have up to 1000 arguments (at least for now). Words are separated from each other by space or tabulation symbol. The upper or lower case of words is important, i.e. variables @var{a} and @var{A} are different variables. Symbol @samp{#} starts the comment (all characters after # will be ignored). The exception is situation when @samp{#} is a part of some string. Also options can be specified after symbol @samp{;} (@pxref{Command options}). Symbol @samp{:} starts new command (like new line character) if it is not placed inside a string or inside brackets.
+Язык MGL достаточно простой. Каждая строка -- отдельная команда. Первое слово -- имя команды, а все остальные ее аргументы. Команда может иметь до 1000 аргументов (по крайней мере сейчас). Слова разделяются одно от другого пробелом или символом табуляции. Различий между верхним и нижним индексом нет, т.е. переменные @var{a} и @var{A} идентичны. Символ @samp{#} начинает комментарий -- все символы после него игнорируются до конца строки. Исключением является случай, когда @samp{#} входит в строку. Опции команды указываются после символа @samp{;} (@pxref{Command options}). Символ @samp{:} начинает новую команду (подобно переводу строки) если он расположен не внутри скобок или строки.
-If string contain references to external parameters (substrings @samp{$0}, @samp{$1} ... @samp{$9}) or definitions (substrings @samp{$a}, @samp{$b} ... @samp{$z}) then before execution the values of parameter/definition will be substituted instead of reference. It allows to use the same MGL script for different parameters (filenames, paths, condition and so on).
+Если строка содержит ссылки на внешние параметры (@samp{$0}, @samp{$1} ... @samp{$9}) или макроопределения (@samp{$a}, @samp{$b} ... @samp{$z}), то текущие значения параметров/макроопределений подставляются в строку вместо ссылки до выполнением команды. Это позволяет использовать один и тот же скрипт при различных входных параметрах командной строки или вводить макроопределения по ходу исполнения команд скрипта.
-Argument can be a string, a variable (data arrays) or a number (scalars).
+Аргументы команды могут быть строками, переменными или числами.
@itemize @bullet
@item
-The string is any symbols between ordinary marks @samp{'}. Long strings can be concatenated from several lines by @samp{\} symbol. I.e. the string @samp{'a +'\<br>' b'} will give string @samp{'a + b'} (here @samp{<br>} is newline).
+Строка -- произвольный набор символов между метками @samp{'}. Длинные строки могут быть соединены из нескольких линий файла символом @samp{\}. Т.е. строки файла @samp{'a +'\<br>' b'} дадут строку @samp{'a + b'} (здесь @samp{<br>} -- перевод строки).
@item
-Usually variable have a name which is arbitrary combination of symbols (except spaces and @samp{'}) started from a letter and with length less than 64. A temporary array can be used as variable:
+Обычно переменная имеет имя, состоящее из букв и чисел (должно начинаться с буквы и не быть длиннее 64 символов). В качестве переменной можно использовать временные массивы, включающие в себя:
@itemize @bullet
@item
-sub-arrays (like in @ref{subdata} command) as command argument. For example, @code{a(1)} or @code{a(1,:)} or @code{a(1,:,:)} is second row, @code{a(:,2)} or @code{a(:,2,:)} is third column, @code{a(:,:,0)} is first slice and so on. Also you can extract a part of array from m-th to n-th element by code @code{a(m:n,:,:)} or just @code{a(m:n)}.
+срезы (``подмассивы'') массивов данных (подобно команде @ref{subdata}). Например, @code{a(1)} или @code{a(1,:)} или @code{a(1,:,:)} -- вторая строка массива @var{a}, @code{a(:,2)} или @code{a(:,2,:)} -- третий столбец, @code{a(:,:,0)} -- первый срез и т.д. Также можно выделить часть массива с m-го по n-ый элемент @code{a(m:n,:,:)} или просто @code{a(m:n)}.
@item
-any column combinations defined by formulas, like @code{a('n*w^2/exp(t)')} if names for data columns was specified (by @ref{idset} command or in the file at string started with @code{##}).
+произвольные комбинации столбцов данных (например, @code{a('n*w^2/exp(t)')}), если столбцы данных были именованы командой @ref{idset} или в файле данных (в строке начинающейся с @code{##}).
@item
-any expression (without spaces) of existed variables produce temporary variable. For example, @samp{sqrt(dat(:,5)+1)} will produce temporary variable with data values equal to @code{tmp[i,j] = sqrt(dat[i,5,j]+1)}.
+произвольное выражение из существующих переменных и констант. Например, @samp{sqrt(dat(:,5)+1)} даст временный массив данных с элементами равными @code{tmp[i,j] = sqrt(dat[i,5,j]+1)}.
@item
-temporary variable of higher dimensions by help of []. For example, @samp{[1,2,3]} will produce a temporary vector of 3 elements @{1, 2, 3@}; @samp{[[11,12],[21,22]]} will produce matrix 2*2 and so on. Here you can join even an arrays of the same dimensions by construction like @samp{[v1,v2,...,vn]}.
+массивы с элементами заданными в квадратных скобках [], разделенные @samp{,}. При этом внутри выражения не должно быть пробелов! Например, @samp{[1,2,3]} даст временный массив из 3 элементов @{1, 2, 3@}; @samp{[[11,12],[21,22]]} даст матрицу 2*2 и т.д. Элементами такой конструкции могут быть и массивы если их размерности одинаковые, например @samp{[v1,v2,...,vn]}.
@item
-result of code for making new data (@pxref{Make another data}) inside @{@}. For example, @samp{@{sum dat 'x'@}} produce temporary variable which contain result of summation of @var{dat} along direction 'x'. This is the same array @var{tmp} as produced by command @samp{sum tmp dat 'x'}. You can use nested constructions, like @samp{@{sum @{max dat 'z'@} 'x'@}}.
+результат команд построения новых данных (@pxref{Make another data}), если они заключены в фигурные скобки @{@}. Например, @samp{@{sum dat 'x'@}} даст временный массив, который есть результат суммирования @var{dat} вдоль 'x'. Это такой же массив как и @var{tmp}, полученный командой @samp{sum tmp dat 'x'}. При этом можно использовать вложенные конструкции, например @samp{@{sum @{max dat 'z'@} 'x'@}}.
@end itemize
-Temporary variables can not be used as 1st argument for commands which create (return) the data (like @samp{new}, @samp{read}, @samp{hist} and so on).
+Временные массивы не могут стоять в качестве первого аргумента команд, создающих массивы (например, @samp{new}, @samp{read}, @samp{hist} и т.д.).
@item
-Special names @code{nan=#QNAN, pi=3.1415926..., on=1, off=0, :=-1} are treated as number if they were not redefined by user. Variables with suffixes are treated as numbers (@pxref{Data information}). Names defined by @ref{define} command are treated as number. Also results of formulas with sizes 1x1x1 are treated as number (for example, @samp{pi/dat.nx}).
+К скалярным переменным, кроме собственно чисел, относятся: специальные переменные @code{nan=#QNAN, pi=3.1415926..., on=1, off=0, :=-1}, переменные с суффиксами (@pxref{Data information}), переменные определенные командой @ref{define}. Также массивы размером 1x1x1 считаются скалярами (например, @samp{pi/dat.nx}).
@end itemize
-Before the first using all variables must be defined with the help of commands, like, @ref{new}, @ref{var}, @ref{list}, @ref{copy}, @ref{read}, @ref{hist}, @ref{sum} and so on (see sections @ref{Data constructor}, @ref{Data filling} and @ref{Make another data}).
+Перед первым использованием все переменные должны быть определены с помощью команд, создающих массивы (@ref{new}, @ref{var}, @ref{list}, @ref{copy}, @ref{read}, @ref{hist}, @ref{sum} и др., см. @ref{Data constructor}, @ref{Data filling} и @ref{Make another data}).
+
+Команды могут иметь несколько наборов аргументов (например, @code{plot ydat} и @code{plot xdat ydat}). Все аргументы команды для выбранного набора должны быть указаны, однако часть из них могут иметь значения по умолчанию. Такие аргументы в описании команд будут помещены в квадратные скобки [], например @code{plot ydat ['stl'='' zval=nan]}. При этом запись @code{[arg1 arg2 arg3 ...]} подразумевает @code{[arg1 [arg2 [arg3 ...]]]}, т.е. опускать можно только аргументы с конца, если вы согласны с их значениями по умолчанию. Например, @code{plot ydat '' 1} или @code{plot ydat ''} правильно, а @code{plot ydat 1} не правильно (аргумент @code{'stl'} пропущен).
+
-Command may have several set of possible arguments (for example, @code{plot ydat} and @code{plot xdat ydat}). All command arguments for a selected set must be specified. However, some arguments can have default values. These argument are printed in [], like @code{text ydat ['stl'='']} or @code{text x y 'txt' ['fnt'='' size=-1]}. At this, the record @code{[arg1 arg2 arg3 ...]} means @code{[arg1 [arg2 [arg3 ...]]]}, i.e. you can omit only tailing arguments if you agree with its default values. For example, @code{text x y 'txt' '' 1} or @code{text x y 'txt' ''} is correct, but @code{text x y 'txt' 1} is incorrect (argument @code{'fnt'} is missed).
+@c TODO Translate it!
@c ------------------------------------------------------------------
+@external
@node Program flow commands, MGL definition, MGL scripts
@section Program flow commands
@ifclear UDAV
@c ------------------------------------------------------------------
+@external
@node mglParse class, , Program flow commands, MGL scripts
@section mglParse class
@cindex mglParse
@end deftypefn
@end ifclear
+
+@external
+
+++ /dev/null
-pngdir = $(docdir)/png
-
-images = ${shell $(top_builddir)/examples/mgl_example -list}
-png_images = ${images:=.png}
-png_DATA = $(png_images)
-CLEANFILES = $(png_images)
-
-$(png_images): hotdogs.pts # $(top_builddir)/examples/mgl_example
- $(top_builddir)/examples/mgl_example -kind=${@:.png=}
- cp ${@} ../../png/
- touch $(srcdir)/../mathgl.texi
+++ /dev/null
--3.3581 2.5732 1.4934
--3.25778 2.29243 1.45965
--3.0802 2.59925 1.42197
--3.60356 2.40362 1.47383
-5.24516 2.4206 1.30072
-5.42469 2.656 1.27697
-5.12897 2.59593 1.5162
-5.08074 2.17454 1.29715
-5.35839 2.30541 1.03706
-0.314234 -1.24668 0.771201
-0.199285 -1.50489 0.79399
-0.483944 -1.39477 0.994998
-0.524797 -1.06853 0.885649
-0.403729 -0.936904 0.66078
-0.153642 -1.20314 0.54891
--2.62536 -1.39779 -0.911055
--2.35472 -1.36992 -1.01849
--2.54319 -1.64629 -0.821542
--2.84156 -1.45618 -0.730945
--2.83523 -1.16641 -0.829628
--2.56462 -1.11861 -0.996259
-2.87418 -1.98581 -0.595092
-2.84061 -1.79479 -0.820509
-3.02393 -1.75897 -0.534522
-2.91054 -2.09024 -0.323686
-2.72903 -2.24064 -0.612428
-2.65841 -2.10037 -0.856363
-6.31265 3.7305 0.24011
-6.18759 3.47647 0.325652
-6.17274 3.70564 -0.0800137
-6.39293 3.9878 0.0618956
-6.43139 3.86463 0.513914
-3.84975 3.4648 -0.925588
-3.59431 3.38247 -0.854213
-3.7798 3.72419 -0.811975
-4.15893 3.53106 -0.98144
-4.04251 3.24415 -1.01833
-3.74788 3.12439 -0.98844
-2.14197 -3.04583 0.410968
-1.84122 -3.14536 0.550241
-2.04639 -3.17918 0.196293
-2.06812 -2.94437 0.670076
--1.70186 0.504321 0.61956
--1.78475 0.777293 0.610411
--1.84891 0.493439 0.83798
--1.62424 0.245735 0.631356
--1.57339 0.417303 0.359742
--1.66868 0.674163 0.369577
--2.57164 1.21584 -0.743756
--2.31566 1.10419 -0.659823
--2.67611 0.983431 -0.816759
--2.79675 1.43868 -0.754294
--2.50683 1.49307 -0.640831
--2.85831 3.80577 0.187588
--3.03589 3.87076 -0.0420329
--3.02189 4.04633 0.275546
--2.86124 3.90599 0.492198
--2.72507 3.64261 0.458894
--2.74828 3.53887 0.158063
--2.43307 -0.105483 -0.964569
--2.47392 0.184546 -0.924879
--2.16794 -0.0213592 -0.912387
--2.17618 -0.310149 -0.97579
--2.53774 -0.34641 -0.982996
--2.72644 0.0266272 -0.926894
-2.55741 -2.698 0.173276
-2.54559 -2.57237 0.442127
-2.3705 -2.89048 0.304438
-2.72431 -2.41899 0.18726
-1.9329 0.782115 1.33228
-2.07372 0.536763 1.46386
-2.17214 0.8611 1.45373
--2.80681 0.525011 1.2573
--2.61929 0.28831 1.22734
--2.56131 0.690348 1.24508
--2.81006 0.863312 1.29461
--3.07437 0.682266 1.25198
--2.93388 0.253786 1.19793
--4.08497 3.06658 -0.477188
--3.9929 3.34994 -0.508473
--3.80453 3.03208 -0.563298
--4.32072 3.17934 -0.355717
-0.71429 -2.43755 1.13125
-0.577457 -2.64302 0.937117
-0.916566 -2.69839 1.07919
-1.07048 -2.51173 1.22284
-0.932491 -2.24372 1.27808
-0.704217 -2.07408 1.22076
-0.481325 -2.21307 1.06654
-6.77633 5.96032 -0.178714
-6.94684 5.97403 0.117185
-6.85821 5.65343 -0.186667
-6.74866 6.24283 0.0139289
--0.304946 -1.70022 0.0742084
--0.249086 -1.9323 0.145158
--0.175199 -1.63268 0.361055
--0.279403 -1.43671 -0.0334712
--0.301889 -1.66287 -0.225311
--0.26584 -1.92808 -0.226154
-0.270686 -1.89609 -1.12178
-0.42664 -1.58342 -1.20414
-0.507389 -1.87036 -1.30753
-0.28771 -2.24099 -1.08346
-0.0698602 -2.00793 -0.891812
-0.105249 -1.71433 -0.931758
--2.72748 -0.893247 -0.928846
--2.95372 -0.801654 -0.793391
--2.62174 -0.629936 -0.977214
--2.41176 -0.845681 -1.03904
-3.2547 3.60003 1.33696
-3.29474 3.85307 1.22717
-3.09766 3.64218 1.09161
-3.04951 3.38036 1.22149
-3.23911 3.34028 1.44699
-3.45528 3.52774 1.55405
-3.46952 3.81241 1.45288
-2.13552 -2.31356 -1.26343
-2.34225 -2.141 -1.16648
-2.28978 -2.52288 -1.03898
-2.03955 -2.64332 -1.1659
-1.87917 -2.44238 -1.35687
--2.64685 -1.13203 0.96817
--2.55545 -1.40087 0.932776
--2.39014 -1.08724 1.05705
--2.64858 -0.806068 1.04884
--2.84983 -0.905987 0.93024
--2.90094 -1.172 0.793946
-5.46206 6.53047 1.67055
-5.44747 6.32229 1.84814
-5.73482 6.51078 1.7131
-5.46571 6.70016 1.4559
-5.2019 6.49508 1.61418
--2.96176 -0.204601 1.08273
--2.8961 -0.493623 1.03199
--2.63601 -0.263771 1.15631
--2.78725 0.00189162 1.1791
--3.14333 0.0936235 1.08365
--3.24797 -0.110431 0.945928
--3.1717 -0.386754 0.894612
--3.47346 -0.289085 -0.310649
--3.48661 -0.0033554 -0.433021
--3.29665 -0.329489 -0.568534
--3.34481 -0.573148 -0.399182
--3.47098 -0.522645 -0.0868477
--3.58443 -0.227542 -0.00380224
--3.62173 0.00490325 -0.168243
--1.93493 0.792305 0.843012
--1.9404 1.06144 0.740219
--2.14063 0.908349 1.02228
--2.05697 0.575826 1.01327
--1.1033 -0.875587 -0.562918
--1.11228 -0.651707 -0.389252
--0.933491 -0.97847 -0.367397
--1.0533 -1.17043 -0.58353
--1.25204 -1.11933 -0.765217
--1.3032 -0.811943 -0.73879
--1.57893 -0.781166 0.910529
--1.35595 -0.684519 0.716635
--1.53384 -0.481856 0.810603
--1.74273 -0.510285 0.963317
--1.38004 -0.994104 0.826356
-4.7433 5.04488 -0.75171
-4.97556 5.22104 -0.771439
-4.92056 4.82521 -0.848154
-4.65312 4.73047 -0.812904
-4.45911 4.93155 -0.673453
-4.52679 5.19667 -0.599115
-4.75085 5.36744 -0.645883
-1.32843 0.246516 1.03312
-1.28601 -0.0533061 1.12775
-1.55188 0.148591 1.26028
-1.47741 0.5427 1.03714
-1.29585 0.50176 0.830034
-1.1235 0.279323 0.739795
-1.12678 0.0331439 0.925816
--3.41184 -0.662462 0.317813
--3.26844 -0.823944 0.529039
--3.40921 -0.47132 0.541786
--3.52609 -0.401529 0.228077
--3.39951 -0.771987 0.0583163
--3.29761 -0.985696 0.273689
--2.44003 -1.74416 0.77911
--2.40321 -1.93882 0.574524
--2.16401 -1.86492 0.727302
--2.33647 -1.56288 0.932501
--3.19536 -1.22835 -0.271192
--3.29573 -1.04903 -0.0607735
--3.2039 -0.996262 -0.430891
--3.04013 -1.31067 -0.560577
--3.07055 -1.49746 -0.361095
--3.15817 -1.44404 -0.059781
--2.33749 -0.254451 1.15692
--2.08626 -0.459199 1.10064
--2.13336 -0.0834085 1.11195
--2.47607 0.0220306 1.19255
--2.34752 -0.544654 1.13367
--4.06515 1.14606 0.0939439
--3.98855 0.87721 0.208124
--4.10693 1.20843 0.381695
--4.10764 1.40389 -0.0430838
--3.94837 1.06503 -0.169509
--3.74035 0.213102 0.0356933
--3.66615 -0.0230989 0.21915
--3.76119 0.273481 0.35934
--3.84289 0.488681 0.0952445
--3.67135 0.296679 -0.26498
--1.73488 0.824535 -0.0694358
--1.88074 0.984935 -0.269929
--1.81166 1.08 0.0503476
--1.73262 0.898408 0.237072
--1.6277 0.622408 0.0997399
--1.71963 0.630373 -0.25725
--4.44731 2.9857 1.23889
--4.47648 3.31286 1.27093
--4.63912 3.15007 1.045
--4.60983 2.87466 0.943018
--4.39756 2.70469 1.15202
--4.18898 2.86288 1.38837
--4.26454 3.17889 1.42879
--3.1185 2.88722 1.42872
--2.9835 2.29036 1.39026
--2.82421 2.55737 1.28856
--3.62914 0.945485 1.07069
--3.85799 1.03371 0.875528
--3.64957 0.663368 0.923775
--3.34893 0.870816 1.21064
--3.46287 1.17338 1.24476
--3.78027 1.26236 1.07779
--4.10144 1.80983 1.01471
--3.93356 1.92953 1.22535
--4.23873 2.08417 0.996568
--3.87802 1.60653 1.14086
--2.41342 2.76212 0.52291
--2.51387 3.05685 0.485706
--2.51421 2.89601 0.771281
--2.34972 2.47078 0.684162
--2.32 2.51869 0.386456
--2.40892 2.69099 0.171889
--2.49363 2.94328 0.228462
--4.1901 1.67887 0.779085
--4.18138 1.47216 0.555497
--4.01052 1.4394 0.914544
--4.33252 1.98544 0.734667
--4.30575 1.76904 0.476773
--2.14148 2.02084 0.292344
--2.04327 1.74933 0.271785
--2.1878 2.01728 0.0156825
--2.24237 2.27722 0.21845
--2.23397 2.23757 0.523243
--2.1242 1.90144 0.538474
--2.6618 1.7117 1.27036
--2.42223 1.65463 1.12153
--2.57037 1.99444 1.18305
--2.85219 1.92206 1.34625
--2.84725 1.49189 1.34055
--2.55483 1.38925 1.23605
--3.24773 2.89115 -0.563582
--3.13442 3.16171 -0.454071
--2.97275 2.87675 -0.457286
--2.97087 0.910323 -0.830011
--2.8625 0.64601 -0.863657
--3.22997 0.77024 -0.766962
--3.25406 1.08882 -0.760944
--2.94461 1.2067 -0.80286
--3.19264 3.76303 -0.268807
--3.35685 3.98887 -0.189947
--3.09926 3.48731 -0.325277
--3.35013 3.51948 -0.448783
--3.49897 3.80852 -0.379837
--4.13442 2.78485 -0.432249
--4.25185 2.54973 -0.303828
--4.37806 2.88588 -0.257884
--3.85371 2.74253 -0.55972
--3.97769 2.47611 -0.496416
--3.01366 4.06086 0.677485
--3.24816 4.19348 0.803642
--3.00824 3.95263 0.934934
--3.16861 4.19158 0.469881
--3.90096 4.1833 -0.0258327
--4.04109 3.99704 -0.207144
--4.19113 4.15901 0.127059
--3.94038 4.2978 0.268172
--3.6627 4.29 0.171202
--3.68087 4.0663 -0.203356
-1.28305 -0.86711 1.33316
-1.30099 -1.16771 1.37218
-1.57065 -0.909317 1.43042
-1.26322 -0.582139 1.27146
-1.01719 -0.784363 1.17406
-1.04084 -1.07869 1.25768
-4.61406 2.89864 1.84366
-4.57573 2.60027 1.78141
-4.91371 2.83506 1.73841
-4.71687 3.17893 1.88327
-5.72202 6.92474 0.418179
-5.69642 6.94662 0.712281
-5.99169 6.90788 0.535534
-5.89825 6.85722 0.213565
-5.50061 6.84127 0.155097
-5.44399 6.90241 0.40192
-0.581409 -2.87223 -0.92502
-0.728407 -2.72758 -1.16272
-0.861693 -3.02699 -0.941028
-0.738898 -3.13304 -0.678139
-0.378696 -2.85371 -0.713403
-0.399734 -2.57893 -1.02076
-3.53052 -0.877647 -0.465663
-3.51352 -1.0597 -0.221438
-3.36463 -1.08418 -0.576949
-3.37807 -0.814161 -0.768259
-3.5536 -0.61055 -0.671499
-3.6844 -0.728219 -0.274886
-1.66648 -2.62611 -1.34184
-1.48294 -2.32996 -1.49719
-1.84384 -2.83942 -1.12664
-1.47647 -2.85299 -1.22432
-1.33369 -2.63388 -1.37994
-4.50489 1.11766 -0.575304
-4.6655 1.10628 -0.317977
-4.4713 0.844402 -0.419463
-4.28758 0.88656 -0.693971
-4.42024 1.33553 -0.773128
-4.642 1.44308 -0.605366
--1.48623 0.266598 0.170936
--1.49197 0.126599 0.44517
-2.59359 1.53659 -1.07994
-2.52661 1.77098 -0.957494
-2.84365 1.69255 -1.11866
-2.75375 1.31356 -1.19128
-2.46659 1.23055 -1.13156
-2.327 1.45432 -0.98216
--1.07958 -0.561411 -0.0782097
--1.22408 -0.302384 0.00216391
--1.16863 -0.450934 0.22295
--1.02182 -0.682806 0.179951
--0.942777 -0.791918 -0.151739
--1.22775 -0.400658 -0.287671
-1.04695 0.428301 0.327244
-0.971641 0.174597 0.547138
-1.18354 0.549623 0.562124
-1.17307 0.667302 0.263656
-0.98696 0.369718 0.0352485
-0.894835 0.17772 0.283671
-1.26046 -3.38529 -0.241607
-1.16375 -3.37391 0.0781727
-0.961899 -3.33669 -0.253097
-1.31991 -3.31777 -0.563354
-1.58084 -3.35511 -0.331871
-1.50026 -3.38331 -0.00924776
-4.04168 0.775803 1.34296
-3.81296 0.709911 1.45215
-3.82908 0.414927 1.30645
-4.04688 0.393213 1.1022
-4.17992 1.04431 1.38411
-3.93074 1.11424 1.54997
-1.3473 0.802046 0.626675
-1.32412 0.897541 0.381628
-1.46867 0.794179 0.862163
-1.53267 1.08047 0.705362
-3.29336 1.60053 -1.20303
-3.01545 1.48076 -1.2014
-3.09149 1.85641 -1.13924
-3.40073 1.90025 -1.16993
-3.61126 1.59045 -1.18161
-3.33546 1.29132 -1.22525
-5.62358 2.75262 1.0777
-5.77933 2.84311 0.844079
-5.71859 3.03221 1.21844
-5.55879 2.51885 0.898668
-2.47127 2.79266 -0.0777182
-2.42757 2.81723 0.207235
-2.61609 3.03572 -0.0597707
-2.55071 2.7506 -0.316665
-2.33466 2.51481 -0.17884
-2.30551 2.58302 0.0698644
-1.08521 -2.96288 0.91248
-1.36802 -3.05436 0.843495
-1.25744 -2.73844 1.12404
-0.782819 -2.86576 0.886446
-0.844871 -3.09661 0.641085
-1.14979 -3.18763 0.631905
-3.84648 4.33926 1.56949
-3.65213 4.33729 1.37287
-3.73725 4.0621 1.58499
-3.9693 4.1196 1.7283
-4.08582 4.41464 1.72363
-3.99229 4.62724 1.57908
-3.79036 4.58072 1.39268
-5.03437 1.68215 0.891902
-4.84435 1.43156 0.950179
-5.01579 1.49595 0.605661
-5.18484 1.79583 0.665614
-5.14934 1.99853 1.0553
-4.91913 1.76111 1.16106
-2.46454 -2.30791 -0.969099
-2.55173 -2.45591 -0.735053
-3.19021 3.92141 0.982738
-3.0572 3.81201 0.783917
-3.30079 4.16977 0.923489
-3.16722 4.05353 0.673037
-2.7189 -2.40157 -0.393726
-2.70971 -2.48726 -0.121874
-2.5635 -2.65427 -0.444955
-5.45084 2.25177 0.71766
-5.60454 2.46208 0.564752
-4.35675 1.89842 1.64482
-4.62399 2.09368 1.59515
-4.21343 2.113 1.75005
-3.9289 2.02877 1.77861
-4.61179 1.77743 1.45836
-3.14759 2.91117 1.52961
-3.02628 3.1289 1.33969
-2.93803 2.78965 1.40907
-3.08742 2.59319 1.57805
-3.41822 2.89885 1.68978
-3.31105 3.13485 1.575
-1.71171 -3.282 0.327746
-1.48737 -3.21386 0.594408
-1.37689 -3.3338 0.321419
-1.76916 -3.32425 0.0337589
-5.75579 2.71789 0.577461
-5.94258 3.03736 0.615121
-5.92602 3.12933 0.936607
-2.43954 2.2637 -0.607328
-2.5586 2.09251 -0.822849
-2.25817 2.04781 -0.56517
-2.25449 2.26809 -0.342304
-2.44527 2.48975 -0.420863
-2.67582 2.37823 -0.754694
-3.58753 2.45763 -1.10037
-3.37175 2.63871 -1.01289
-3.75839 2.7216 -1.07499
-3.9273 2.45569 -1.11191
-3.75132 2.17725 -1.14135
-3.42295 2.18566 -1.12784
-3.27519 4.26533 0.369612
-3.29396 4.28355 0.645469
-3.41113 4.49746 0.394895
-3.38743 4.36706 0.105512
-3.21926 4.10526 0.129837
-3.12959 4.02135 0.386715
-4.59978 6.05501 1.47473
-4.75672 6.00052 1.68133
-4.75382 6.28774 1.46787
-4.55922 6.20962 1.26715
-4.40091 5.91249 1.27753
-4.49943 5.81285 1.50403
--3.32642 3.74365 1.39215
--3.22072 3.4678 1.43697
--3.10095 3.7764 1.22664
--3.45644 3.98474 1.27466
--3.56871 3.64471 1.5077
-5.08133 4.10986 1.99889
-5.10824 3.79546 1.94206
-5.37527 4.10865 1.95805
-5.18142 4.44088 2.03637
-4.9002 4.37881 2.01722
-4.78193 4.05296 1.99051
-6.68639 5.22605 -0.36527
-6.88973 5.33685 -0.146801
-6.74693 4.93943 -0.17742
-6.50258 4.8874 -0.405334
-6.47977 5.39359 -0.555216
-6.66063 5.6248 -0.410682
-4.32157 5.62849 1.39112
-4.48352 5.55662 1.62522
-4.67681 5.75341 1.71701
-5.41299 2.46472 -0.265353
-5.25421 2.19126 -0.291126
-5.2031 2.46474 -0.540816
-5.3945 2.71948 -0.468382
-5.58851 2.57376 -0.0245429
-5.44063 2.27668 0.0201241
-4.17483 4.76697 -0.580916
-3.987 4.81406 -0.399019
-4.24679 5.02406 -0.497258
-4.38076 4.64899 -0.742947
-4.14359 4.48225 -0.692783
-3.92838 4.54649 -0.515749
-0.575086 -0.319375 0.137793
-0.426735 -0.549375 0.137022
-0.629651 -0.33705 0.411925
-0.747772 -0.0724315 0.27667
-0.664209 -0.167025 -0.0539383
-0.454213 -0.499526 -0.141241
--2.23743 0.183221 1.14406
--2.03553 0.303864 1.03692
--2.35352 2.4442 0.0314378
--2.32934 2.20449 -0.134264
--2.50272 2.48893 -0.211964
--3.37402 4.26158 0.279124
--3.43338 4.30651 0.596241
--1.87524 0.528798 -0.551478
--1.88602 0.762518 -0.433466
--1.73349 0.300054 -0.521238
--1.96498 0.303381 -0.724441
--2.12399 0.560175 -0.730776
--1.34324 -0.0638205 -0.0106493
--1.36259 -0.139144 -0.264176
--1.46066 0.167177 -0.0902646
--1.38353 0.00229609 0.231181
-3.26654 0.0517979 1.45709
-3.57829 0.203283 1.36573
-3.33354 0.35086 1.52647
-3.28727 -0.220293 1.34572
-3.56133 -0.067779 1.24567
--3.61696 0.37237 0.801219
--3.41898 0.600701 1.09081
--4.52311 2.36306 0.419571
--4.459 2.28875 0.715226
--4.61206 2.62362 0.582494
--4.60245 2.65124 0.262696
--4.47308 2.39624 0.101525
--4.41781 2.06891 0.43754
-4.83961 4.17782 -0.936775
-4.53058 4.12255 -0.923979
-4.74213 4.47107 -0.88896
-5.03151 4.46844 -0.906508
-5.14509 4.12191 -0.911607
-4.70785 3.87509 -0.967311
-5.50273 3.5124 1.71626
-5.40921 3.7919 1.8622
-5.18609 3.48348 1.84489
-5.31664 3.20545 1.68799
-5.59982 3.23616 1.50582
-5.7491 3.72678 1.66339
-6.99501 5.09825 1.19778
-7.1119 5.30977 0.944185
-6.98701 5.36939 1.32907
-6.83424 5.32885 1.56402
-6.81141 4.89449 1.39749
-6.92195 4.81256 1.07474
-7.06381 5.01224 0.807921
-5.43954 5.82508 2.07466
-5.73637 5.85909 2.08593
-5.53675 6.09281 1.9949
-5.23955 6.05765 1.94353
-5.16759 5.77041 2.0121
-5.40793 5.54383 2.10897
--2.86183 -0.526187 -0.881125
--2.32645 -0.553547 -1.02275
-2.21361 -2.78034 -0.906335
-1.47907 1.15197 0.434454
-1.36601 1.01447 0.12676
--2.97617 -1.69783 0.27075
--2.89925 -1.62673 0.525337
--3.11257 -1.4446 0.297451
--3.03623 -1.67693 0.00900469
--2.78326 -1.90367 0.225312
-6.25054 6.07188 -0.544069
-6.29252 6.31472 -0.368969
-6.55818 6.0203 -0.373311
-6.43253 5.80054 -0.54681
-6.07033 5.87985 -0.684812
-5.99506 6.26478 -0.527538
--3.63492 0.112787 0.575716
--3.78282 0.486513 0.586754
--3.69946 1.11331 -0.511145
--3.49857 0.892962 -0.632369
--3.77758 0.873102 -0.360233
--3.90739 1.29016 -0.336133
--3.7357 1.45884 -0.540173
--3.4879 1.25244 -0.670554
--2.62358 1.09068 1.27055
--3.09687 1.00106 1.30549
--1.70743 0.0728551 -0.619782
--1.68071 -0.194106 -0.728164
--1.91822 0.0349975 -0.793812
--1.52584 0.124315 -0.337607
--1.51563 -0.0964405 -0.504099
-5.47299 2.93282 1.42801
-5.22021 2.88501 1.60005
-2.5936 -1.6175 1.12672
-2.39091 -1.48471 1.28828
-2.37107 -1.85049 1.1555
-2.64336 -1.8804 0.93882
-2.83566 -1.67922 0.884339
-2.72542 -1.34267 1.17395
-3.24538 -0.925467 0.996022
-3.41791 -0.661114 1.00507
-3.11867 -0.739574 1.21044
--3.33699 -0.810996 -0.24462
-6.24747 4.70483 -0.539291
-5.93087 4.58114 -0.695508
-6.07499 4.91581 -0.685446
--2.95848 -1.72577 -0.267067
--2.86093 -1.65338 -0.558676
--2.74173 -1.88936 -0.362926
--2.82237 -1.9036 -0.0532058
-6.90693 4.77945 0.277344
-6.73574 4.66411 0.0214382
-6.94069 5.04888 0.0572767
-7.06979 5.0969 0.398044
-6.97763 4.80168 0.586328
-6.72735 4.4468 0.294997
--4.18283 1.72571 -0.0951115
--4.29739 1.79113 0.175601
--4.25773 2.02849 -0.121083
--4.06312 1.93244 -0.345216
--4.01319 1.56669 -0.294298
--3.84245 0.768694 0.713488
--3.98523 0.940984 0.515952
--4.6946 3.41935 0.935589
--4.76331 3.19011 0.728442
--3.70859 3.88878 1.3952
--3.88063 3.64395 1.50821
--3.60964 1.45595 1.25828
--3.33752 1.53579 1.36266
--3.64858 1.76612 1.32713
--4.35719 2.36099 1.00197
--4.52455 2.58589 0.867578
--2.65809 3.12868 0.93932
--2.60143 3.23586 0.689814
--2.78144 3.41075 1.01399
--2.83656 3.15778 1.18379
--2.65611 2.85603 1.05981
--4.71472 2.93161 0.357783
--4.70858 2.90754 0.660347
--4.78036 3.21658 0.405898
--4.61173 2.9052 0.0586183
--2.37413 2.26119 0.88467
--2.53193 2.29605 1.08505
--2.3734 1.94616 1.00572
--2.23997 2.05196 0.74335
--2.473 2.62022 0.87297
--3.05776 1.66242 1.38696
--3.18443 1.29657 1.34317
--3.1144 1.99968 1.41874
--3.36284 1.83392 1.40931
--2.93151 3.26702 -0.281744
--2.79929 3.02039 -0.270622
--2.76433 3.32045 -0.0580593
--3.19015 1.40848 -0.764239
--3.4701 1.55582 -0.68822
--4.15944 3.75397 -0.332298
--4.30116 3.96941 -0.058793
--3.80281 3.87197 -0.365872
--4.65055 3.79444 0.387216
--4.58019 3.90963 0.629851
--4.44185 4.0304 0.264238
--4.54924 3.80352 0.0883825
--4.74073 3.52963 0.316487
--4.7667 3.48666 0.599309
--4.67957 3.68312 0.770349
--3.6832 4.34775 0.45773
--3.66027 4.31012 0.800976
--4.16663 4.2224 0.7658
--3.90905 4.23887 0.95564
--3.92208 4.32679 0.622962
--4.16666 4.25078 0.434266
--4.39195 4.11526 0.538737
--4.39364 4.0416 0.857433
--4.1591 4.08814 1.06713
-0.9963 -0.54777 1.07884
-0.798767 -0.552889 0.890631
-0.817338 -0.956563 1.08861
--0.897974 -0.913917 0.179808
--0.986451 -0.986288 0.423002
--0.805115 -1.24111 0.166609
--0.816121 -1.04002 -0.0394137
-0.337806 -0.710791 -0.320536
-0.253942 -0.774728 0.00422765
-0.540335 -0.508611 -0.488465
-0.448634 -0.746107 -0.637475
-0.246884 -0.948563 -0.546828
-0.134343 -0.939422 -0.209397
-1.79182 -0.204334 -1.33122
-1.68044 -0.4419 -1.36272
-1.44567 -0.249134 -1.22029
-1.60329 -0.000688109 -1.20015
-1.86527 0.106519 -1.26752
-2.06888 -0.168414 -1.37421
-1.19518 -0.31502 1.15156
-0.974081 -0.276952 0.929857
-3.20761 0.0327246 -1.19272
-2.96251 -0.17737 -1.26434
-2.93481 0.141685 -1.29712
--1.79135 0.217624 0.857041
--1.89763 0.0174474 0.985016
--1.62781 -0.0164725 0.754094
-1.46163 0.730054 -0.670306
-1.63882 1.02086 -0.649026
-1.6978 0.838746 -0.848748
-1.57397 0.528616 -0.931397
-1.3707 0.473812 -0.77019
-1.26709 0.664551 -0.411118
-1.45798 0.943274 -0.440726
--1.39036 -0.336555 -0.516422
-1.99929 -2.54494 1.05919
-2.27284 -2.39304 0.947648
-2.097 -2.22734 1.1457
-1.80719 -2.34419 1.23004
-1.71359 -2.67017 1.11246
-1.90525 -2.83286 0.910082
-2.19068 -2.68021 0.831294
-6.20235 4.78057 1.87097
-6.3039 4.52233 1.68014
-6.4737 4.88409 1.74998
-6.20783 5.10743 1.98666
-5.92748 4.93304 2.02664
-5.93317 4.60645 1.92894
-4.37438 0.937406 1.1491
-4.42457 1.24506 1.30721
-4.15353 1.35912 1.53929
-5.03429 5.84506 -0.598155
-4.82043 5.91127 -0.445293
-5.10817 6.1067 -0.523355
-5.2629 5.73942 -0.713593
-4.9171 5.59072 -0.638849
-2.22149 1.63674 -0.815198
-2.05914 1.34602 -0.851874
-1.9747 1.55622 -0.621752
-2.10863 1.80549 -0.580732
-2.35931 1.8914 -0.779278
-6.35807 5.10049 -0.575905
-6.12564 5.2591 -0.710731
-5.80907 5.74225 -0.765336
-5.96024 5.50578 -0.767455
-5.50449 5.61488 -0.780989
-5.57882 5.91706 -0.724244
-6.09713 3.55251 1.15161
-6.11286 3.38233 0.836733
-6.292 3.755 1.00323
-5.90052 3.30628 1.2147
-6.95067 6.21531 0.633089
-6.89447 6.22777 0.321251
-6.76468 6.46966 0.642755
-6.90718 6.23708 0.949329
-7.06949 5.94046 0.787405
-7.06007 5.92689 0.443362
-6.08301 3.26753 0.497863
-6.27733 3.60827 0.67259
-2.02755 -2.96523 -0.869759
-1.67022 -3.03059 -1.00326
-2.68833 3.20102 0.680903
-2.75949 3.12449 0.975179
-2.80978 3.39339 0.733275
-2.58434 2.98402 0.739033
-4.42104 6.21925 0.562537
-4.6125 6.44923 0.413904
-4.47513 6.22947 0.310465
-4.32365 6.00536 0.363303
-4.27068 5.97012 0.619123
-4.44879 6.25959 0.811764
-4.58856 6.45642 0.689479
-0.107136 -0.99435 0.159022
--0.0106347 -1.21232 0.309946
-0.248245 -0.957804 0.435146
--0.058333 -1.13786 -0.049878
-4.83131 2.0991 -0.724842
-4.90236 2.39951 -0.773425
-5.07388 2.18804 -0.533646
-4.96941 1.89848 -0.485867
-4.62437 1.96303 -0.833869
-4.60885 2.33426 -0.930307
-2.84663 2.97084 1.22597
-2.89375 3.32192 1.03006
-2.66517 2.87245 1.04304
-2.64159 2.6459 1.1744
-2.80541 2.59759 1.37161
-3.65375 1.79993 1.76306
-3.58772 2.08755 1.78362
-3.3391 1.78086 1.74387
-3.52565 1.52231 1.73333
-3.94732 1.72612 1.71845
-5.52262 2.32271 0.288816
-5.6928 2.62698 0.256876
-5.39341 2.0934 0.462297
-5.30964 1.96214 0.236401
-2.8995 3.14617 -0.448658
-2.71267 3.03107 -0.283407
-2.84308 3.31154 -0.189996
-7.01691 5.6767 0.0975724
-3.4304 4.41893 0.902934
-3.43314 4.52598 0.647929
--2.86137 2.86663 1.27065
--3.05112 3.19167 1.36447
--3.31083 3.13624 1.5009
--3.43484 2.85095 1.5236
-5.4209 6.92367 0.664981
-5.16593 6.85103 0.595611
-2.41874 -2.69942 -0.718325
-2.27546 -2.94078 -0.592459
--2.0369 -1.38819 -1.03681
--2.26334 -1.60707 -0.933447
--2.26556 -1.11954 -1.07572
-2.49148 -1.59898 -1.23192
-2.39095 -1.3633 -1.33635
-2.74193 -1.39493 -1.11909
-2.73321 -1.64696 -1.02613
-2.37726 -1.88255 -1.22685
-2.18817 -1.73092 -1.3686
-3.8192 -0.400994 0.664269
-3.78649 -0.582894 0.436741
-3.95287 -0.325134 0.396717
-3.16898 3.12614 -0.719385
-3.25505 2.90951 -0.872861
-2.96878 2.94109 -0.665912
-3.09038 3.32178 -0.530885
-3.32818 3.38129 -0.700023
-3.44367 3.14194 -0.874567
-4.45667 4.39209 -0.848395
--1.91008 -0.272296 1.02624
--1.67769 -0.222704 0.86507
--2.44932 1.76129 -0.510931
--2.24364 1.60529 -0.391285
--2.7169 1.73209 -0.667163
--2.63854 2.01499 -0.54661
--2.38762 2.00168 -0.344863
--2.81091 3.77364 0.758511
--2.70216 3.50251 0.743846
--2.62764 3.37006 0.420453
--2.64722 0.406292 -0.900401
--2.89253 0.288019 -0.878955
--2.57831 0.708483 -0.850487
--2.36099 0.506001 -0.844763
-0.895645 0.171274 -0.213596
-0.808775 0.071615 0.0141342
-2.95261 0.0533246 1.54838
-2.99107 -0.240328 1.46408
-3.03735 0.338434 1.5919
-2.63866 0.106192 1.58832
-2.6756 -0.192832 1.54374
--3.58223 2.65527 -0.621348
--3.52167 2.96061 -0.590865
--3.71607 2.36708 -0.605868
-0.841079 -3.29945 0.0570917
-0.703276 -3.17306 0.35051
-0.572289 -3.17949 -0.0760034
-1.0237 -3.28325 0.368892
--0.0436037 -2.16221 -0.666844
-0.0329734 -2.47362 -0.567815
--0.143812 -2.21657 -0.374294
--0.173622 -1.93198 -0.50391
-0.135903 -2.33125 -0.866569
-5.36833 6.88996 0.927571
-5.63207 6.91207 0.986224
-5.11699 6.81666 0.884737
-5.22879 6.7857 1.16229
-5.51667 6.82769 1.22651
-0.492167 -2.17619 -1.27108
--3.06244 -0.219382 -0.79153
--3.03797 0.058671 -0.825575
--2.80057 -0.242033 -0.915327
--3.10368 -0.500938 -0.721575
--3.29542 -0.0443823 -0.640957
-3.54889 4.08056 1.40061
-1.89931 1.86609 -0.0710804
-1.84867 1.8375 0.241004
-2.02355 2.08502 -0.0307164
-1.9512 1.79016 -0.346736
-1.76372 1.65781 -0.0281872
--2.77906 -1.43475 0.785394
--3.00396 -1.36739 0.581025
-6.79416 4.48297 0.585706
-6.55862 4.1324 0.324986
-6.5515 4.33336 0.00538146
--3.0134 -0.702942 0.892845
--2.06307 1.41118 0.774104
--1.93006 1.29222 0.559759
--2.06566 1.64776 0.621783
--2.24012 1.49421 0.984831
--2.11375 1.17309 0.935011
-6.70855 6.46824 0.321907
-6.53738 6.66604 0.550523
-5.90359 6.87948 1.05218
-5.80869 6.8038 1.29069
-6.1261 6.7588 1.23687
-5.9791 6.91136 0.797835
-5.67244 4.00024 1.82601
-2.34523 0.0107702 1.56627
-2.05768 -0.0918584 1.51666
-2.36946 -0.289348 1.54743
-2.17102 0.257142 1.52927
--1.8031 -1.60722 0.889516
--2.01207 -1.41379 1.01376
--2.08253 -1.6673 0.895646
--1.87399 -1.85814 0.708345
--1.59652 -1.73724 0.716683
--1.584 -1.43783 0.888191
--3.17749 -0.739618 -0.584753
--3.03525 -1.04684 -0.662182
--2.38331 -0.827782 1.0985
--2.12203 -0.798324 1.09728
--4.20614 1.49573 0.233274
--3.61411 0.633831 -0.48362
--3.39191 0.541088 -0.661285
--3.50872 0.294484 -0.506347
--3.76867 0.554207 -0.223808
--2.2153 1.83113 -0.214637
--2.06518 1.51113 -0.190998
--3.99563 3.17577 1.54105
--3.78575 3.36682 1.57729
--4.12587 3.46106 1.48822
--2.61949 2.56123 1.10863
--2.8799 1.21924 1.33147
--3.70273 2.68702 1.50827
--3.87829 2.34639 1.38825
--2.53738 2.75205 -0.0886397
--2.71644 2.73588 -0.323424
--2.62841 3.0223 -0.0456433
--2.20901 1.75641 0.851081
--2.83704 2.23367 -0.582315
--2.93351 1.95043 -0.682603
--3.10037 2.33017 -0.643582
--2.73793 2.47912 -0.446965
--2.54364 2.25594 -0.38073
--2.35631 0.847093 -0.758055
--3.69009 3.29975 -0.550726
--3.64114 3.57544 -0.501258
--3.39702 3.23965 -0.527561
--4.54791 3.13128 -0.136918
--4.70613 3.22278 0.11291
--4.50048 3.42477 -0.196072
--2.88642 3.69011 1.03273
-2.38341 -2.1121 1.0194
-2.58797 -2.15508 0.800023
--0.00727345 -1.46213 0.536091
-4.57144 6.37544 1.00845
-4.32135 6.02922 0.855065
-4.42716 6.11782 1.08185
-2.39279 -1.02531 -1.37731
-2.28842 -0.736083 -1.41546
-2.66636 -0.877484 -1.2903
-2.65438 -1.17224 -1.24008
-2.12365 -1.16551 -1.44273
-0.947029 -0.0676544 0.751482
-3.54806 0.717383 -1.14804
-3.26958 0.598035 -1.23219
-3.40579 0.990112 -1.21566
-3.72564 1.00003 -1.1139
-3.83236 0.672323 -0.990881
-3.59199 0.426335 -1.07442
--1.12135 -0.718676 0.451641
-1.76789 -2.19618 -1.47054
-1.6378 -1.9417 -1.52956
-2.04021 -2.03279 -1.38621
-4.89006 3.45344 1.90968
-4.80873 3.75814 1.96531
-4.57393 3.50312 1.93919
-5.02 3.13923 1.79711
-1.22207 0.764637 0.0237609
-1.11716 0.562235 -0.119853
-5.49632 5.05005 -0.840496
-5.45755 4.73547 -0.856039
-5.17699 5.03477 -0.842001
-5.36126 5.31798 -0.814108
-5.82673 5.13193 -0.789
-5.75662 4.82527 -0.79249
-4.27014 0.178337 0.280502
-4.14421 -0.0251091 0.0243485
-4.34647 0.31634 0.0786384
-4.32143 0.32691 0.523987
-4.16118 0.1212 0.630855
-4.13256 -0.049425 0.305982
-1.6762 1.06075 0.963286
-1.73561 1.30879 0.859707
-1.65399 0.821687 1.08005
-1.87511 1.03272 1.19798
-2.83629 2.21114 -0.94015
-2.77105 1.94909 -1.01002
-5.02174 3.83418 -0.932701
-4.7044 3.56095 -0.986351
-4.42314 3.69439 -0.982837
-2.56565 3.04872 0.206605
-2.71708 3.26519 0.0829693
-2.03043 -0.8711 -1.45222
-2.08516 -1.46157 -1.43855
-1.8015 -1.08762 -1.48027
-5.0922 5.49635 2.02208
-4.89824 5.31474 1.96835
-5.27685 5.27503 2.08709
-4.89356 5.68995 1.89298
-5.01736 3.52753 -0.920366
-5.3179 3.50334 -0.797628
-5.02054 3.211 -0.885717
-6.49044 5.18705 1.85741
-6.61018 5.45154 1.80496
-6.27207 5.4244 2.01129
-6.72143 5.07267 1.61992
-3.71843 4.98606 0.794463
-3.84339 5.14079 0.946246
-3.83521 5.22737 0.582445
-3.70232 5.00076 0.545876
-3.5726 4.76918 0.644592
-3.70954 4.85213 1.01705
-5.20016 6.80911 0.279993
-4.97813 6.74239 0.422076
-4.91738 6.7294 0.743521
--1.30572 -0.230387 0.328422
--1.26269 -0.493418 0.49699
-4.94289 2.91628 -0.873557
-5.26455 2.91831 -0.677222
-5.07041 2.66266 -0.736423
-4.73056 2.64784 -0.926718
-4.63012 2.98139 -0.995705
-4.18763 2.41065 1.81447
-3.88454 2.33543 1.81838
-4.49948 2.31866 1.72578
-4.27902 2.68544 1.84945
-3.94758 2.66118 1.84511
-2.22773 -3.08715 -0.225525
-2.01225 -3.23091 -0.102127
-2.07452 -3.13061 -0.499213
-2.42395 -2.88864 -0.318726
-2.32791 -3.00243 0.0388688
-2.84437 2.10419 1.55233
-2.83202 2.3593 1.47806
-2.56001 2.11758 1.35314
-2.65597 1.91368 1.4878
-3.02213 1.92534 1.66125
-3.06792 2.30441 1.62743
-4.31478 0.38661 -0.228882
-4.47424 0.617429 -0.131772
-4.20269 0.136258 -0.144758
-4.16407 0.402035 -0.541856
-4.33324 0.612366 -0.446985
-2.63416 2.58818 -0.578693
-2.85448 2.66115 -0.735651
-2.96732 2.44879 -0.91125
-3.55803 4.74165 0.379557
-3.51793 4.60146 0.152682
-4.1725 5.76945 0.401769
-4.1198 5.71311 0.615241
-4.1742 5.77275 0.847412
--4.08181 3.80618 1.3755
-1.0643 0.392978 -0.327417
-1.20075 0.43481 -0.569611
-0.980424 0.158047 -0.490146
-0.162038 -2.61938 0.479033
-0.366356 -2.7069 0.688263
-0.177495 -2.41249 0.69027
-0.351842 -3.0032 -0.272337
-0.692377 -3.22119 -0.344686
-3.54396 -0.97595 0.439956
-3.69933 -0.786986 0.238805
-3.64407 -0.722773 0.600385
-3.37903 -1.04083 0.722992
-3.35584 -1.24202 0.506966
-3.5348 -1.07558 0.157881
-2.39197 2.71538 0.580599
-2.30652 2.50145 0.704393
-2.49901 2.75981 0.838906
-2.29916 2.60419 0.356278
-3.03314 3.48015 -0.329609
-3.0013 3.63469 -0.0882887
-3.19085 3.7252 -0.324681
-3.28809 3.60354 -0.534505
-2.91907 -1.42618 0.976741
-3.10603 -1.46338 0.720405
-3.03567 -1.16423 1.03796
--1.89338 -0.686378 1.0458
--2.98717 2.59789 -0.546802
--2.91852 3.59598 -0.103188
--2.10196 0.802975 -0.627258
--2.07143 1.04115 -0.494572
-3.71608 0.214891 -0.928515
-3.52728 0.0117537 -1.00289
-3.9196 0.432453 -0.841141
-3.79378 -0.0216493 -0.745151
--3.39165 0.28215 0.990615
--3.46821 0.049142 0.804971
--3.17466 0.429606 1.16422
--4.31576 2.31431 -0.156922
--4.08933 2.23466 -0.386964
-0.489774 -3.04492 -0.528126
--0.0491051 -2.47482 -0.284572
--0.106816 -2.38719 -0.00617952
-4.10808 0.133857 -0.393448
-4.00834 -0.200317 -0.168604
-3.966 -0.0939444 -0.434348
-3.96944 0.193297 -0.662922
--1.97006 -1.08846 -1.07646
--2.11733 -0.841206 -1.06313
--1.79887 -0.797267 -1.00332
--1.69038 -1.06764 -1.00967
-3.01407 3.82122 0.51079
-1.70308 -3.02515 0.807143
-1.50625 -2.85997 1.02444
--2.44454 -1.98341 -0.488616
--2.56059 -2.04087 -0.204201
--2.62185 -1.80532 -0.627859
-6.06827 4.3494 -0.555338
-5.99951 4.06054 -0.506586
-5.76495 4.2196 -0.709571
-6.30883 4.42189 -0.38052
-6.3331 4.17427 -0.211343
--2.26998 0.652422 1.13866
--2.39119 0.946479 1.18099
--2.38171 0.417202 1.19089
--1.31138 -0.580318 -0.605914
-4.96424 6.43441 1.52176
-4.93994 6.57882 1.29737
-4.93025 6.20864 1.6971
-2.98566 -1.89651 0.402875
-2.99504 -1.71947 0.629113
-2.80832 -1.98483 0.65407
-2.81584 -2.18673 0.372125
-2.94659 -2.06608 0.132394
-3.11419 -1.77568 0.181057
-3.40603 -0.49194 -0.910627
-3.34842 -0.210649 -1.05994
-3.60165 -0.278384 -0.817812
-3.18387 -0.663541 -1.03314
-5.34814 3.81044 -0.833436
-5.60963 3.60887 -0.649464
-5.49652 4.06618 -0.807599
--2.29419 -1.84626 -0.739208
-4.27438 5.84754 1.07025
--3.89592 0.631513 0.356508
--1.85793 1.23741 0.272008
--2.984 3.48143 1.25566
--4.03153 1.21798 0.708225
--2.74645 2.22476 1.27591
--3.02474 1.65309 -0.747063
--4.41029 3.70975 -0.17619
--4.24984 3.46726 -0.388549
--3.9372 4.02485 1.2545
--3.69259 4.14444 1.14672
--4.52043 3.81682 0.985501
--4.31262 3.86658 1.18948
--4.5472 3.57001 1.13125
-2.44903 -1.19904 1.35848
-2.1307 -1.35446 1.40226
-2.13544 -1.68333 1.31809
-1.42649 -1.36861 -1.50427
-1.49517 -1.09155 -1.46585
-1.78291 -1.39196 -1.50053
-1.57302 -1.63208 -1.53184
-1.26792 -1.69797 -1.54083
-1.14698 -1.30492 -1.44573
-2.55436 -2.74804 -0.0997885
-0.921482 -0.354725 -0.900431
-1.15208 -0.420503 -1.12993
-0.857148 -0.620642 -1.01832
-0.664955 -0.576517 -0.780862
-0.745309 -0.321461 -0.640641
-1.59308 -0.806716 -1.42613
-1.30754 -0.787314 -1.34896
-1.41082 -0.525132 -1.30332
-1.83431 -0.672451 -1.43214
-2.42403 0.251906 -1.33976
-2.32673 0.539772 -1.27671
-2.6952 0.391476 -1.32637
-2.65679 0.0367015 -1.34841
-2.37856 -0.108905 -1.37896
-2.15656 0.129054 -1.33176
--1.18888 -0.91227 0.646598
-0.882412 -0.0881433 -0.609349
-0.770957 -0.0798789 -0.342377
-2.52635 1.48861 1.51161
-2.25694 1.59913 1.30019
-2.37271 1.25519 1.47863
-2.66099 1.21726 1.60642
-2.81597 1.47105 1.63468
-2.79342 1.72577 1.59674
-2.4746 1.72046 1.42371
-4.91798 1.28038 0.273861
-5.0631 1.52727 0.316951
-4.86126 1.27644 0.681867
-4.80274 1.09753 0.442662
-4.75925 1.02914 0.111535
-4.9793 1.45803 -0.000749401
-1.84918 -3.27852 -0.353527
-1.87097 -3.13772 -0.730805
-1.79138 1.54489 -0.338139
-1.81327 1.33966 -0.599624
-3.78526 4.68329 -0.270443
-3.85384 4.92469 -0.140512
-4.05985 5.06709 -0.291874
-2.06778 -1.96345 1.25563
-3.70795 4.43073 -0.38155
-3.62239 4.61083 -0.0906214
-7.05587 5.36537 0.173371
-2.17179 2.35933 0.483175
-2.12679 2.18635 0.686334
-2.15588 2.35987 0.214716
-1.99257 2.04606 0.475675
-1.4513 1.10998 -0.128141
-1.32219 0.866066 -0.210534
-1.52076 1.27825 0.175661
-7.12196 5.61765 0.432257
-7.13462 5.63835 0.79101
-7.13779 5.3273 0.595929
-1.96244 1.88422 0.690245
-2.00865 2.11079 0.237972
-3.22209 2.39594 -1.03568
-3.09851 2.70525 -0.874481
-3.54576 2.88453 -0.996488
-5.97331 4.01783 1.655
-6.23816 4.18383 1.52577
-6.04459 4.34565 1.77096
-6.03504 3.75551 1.43031
-4.85426 1.95583 1.36929
-4.88441 2.27495 1.52269
-2.16662 2.30798 -0.0584886
-2.85463 3.48906 0.0797035
-4.36641 5.55982 -0.261211
-4.30659 5.70868 -0.048627
-4.54324 5.77112 -0.29545
-4.5239 5.46645 -0.465143
-3.56399 4.66754 0.890619
-3.63094 4.58997 1.15028
-1.31461 0.223415 -0.891566
-3.49211 -0.812993 0.779936
-3.20112 -1.23358 0.802344
-4.43517 2.7246 -1.03336
-4.13248 2.67651 -1.0835
-4.29889 3.03756 -1.04986
-4.32493 2.41509 -1.04704
--2.28032 1.36122 -0.539877
--2.07389 1.27868 -0.367909
--1.91479 -0.240171 -0.882894
--1.80039 -0.486833 -0.911414
-3.8584 -0.527549 0.166608
-4.00153 -0.283244 0.10977
-3.8231 -0.563548 -0.0719835
-7.07053 5.59914 1.12616
-6.93117 5.76231 1.38495
-4.4582 0.519046 0.423817
-4.48699 0.548742 0.152924
-4.62911 0.787241 0.227771
-4.04256 -0.111969 0.554354
--3.08706 -0.963685 0.706624
--2.21908 -2.10991 0.280895
--1.87545 -2.0957 0.296578
--2.08609 -2.02663 0.505274
--2.29524 -2.13855 -0.00481676
--2.01344 -2.15349 0.0464491
--3.26443 0.245008 -0.711839
--1.81299 1.01893 0.471673
-2.44308 -2.45355 0.732953
--3.15642 -1.15528 0.477426
--3.22291 -1.24522 0.14199
--2.0714 1.7205 0.0107002
--2.63485 -0.54142 1.10784
--4.00284 2.61531 1.40843
--4.21123 2.49355 1.23522
--3.89522 2.91285 1.5159
--3.73421 2.07515 1.37392
--2.61346 3.22496 0.187374
--2.33161 1.24054 1.11659
--3.20136 2.06015 -0.699392
--3.41658 2.33951 -0.663894
--3.2846 2.61073 -0.62382
--3.92793 3.62917 -0.467471
-0.932763 -1.33349 1.2523
-1.21468 -1.43739 1.3647
-0.697173 -1.20466 1.085
-0.702247 -1.51257 1.17191
-0.984833 -1.65444 1.3132
-4.29148 5.35702 1.52648
-4.48527 5.30227 1.72982
-4.70681 5.48 1.83156
--1.13707 -1.18549 0.635993
--0.940551 -1.26767 0.405044
-3.17393 -0.948401 -0.923305
-2.93503 -0.799032 -1.16505
-3.13595 -0.392096 -1.14549
-3.05366 1.16856 -1.24781
-3.64599 1.29417 -1.16887
-2.19474 1.14273 -1.04246
-1.86283 1.13158 -0.812356
-2.71438 -1.08043 1.29166
-2.46136 -0.881258 1.43992
-2.176 -1.04017 1.45652
-3.57308 1.21911 1.67994
-3.29939 1.06231 1.68362
-3.69656 0.955089 1.58606
-3.84272 1.42387 1.67103
-3.24597 1.37705 1.71614
-3.09243 2.12565 -1.07241
-5.60786 3.32385 -0.547914
-5.85521 3.40983 -0.329565
-5.55673 3.04266 -0.465128
-5.31726 3.20608 -0.728994
-3.51775 4.38546 -0.163124
-3.33964 4.15832 -0.103068
-3.9345 3.83269 1.77134
-4.20448 4.11555 1.84824
-5.80742 3.13501 -0.193377
-5.61141 2.81739 -0.242531
-1.62973 1.20718 -0.446421
-2.34045 -2.75764 0.581962
-2.65502 -2.31421 0.552283
-0.807092 -0.12324 0.548428
-5.62661 4.47492 -0.805358
-5.03009 5.07086 2.03718
-4.77233 4.9352 1.9674
-5.07227 4.76557 2.05017
-5.33643 4.99678 2.08818
-4.1407 5.38491 1.30771
-4.19171 5.62116 1.17016
-3.99973 5.33233 1.08836
-4.03717 5.13834 1.3446
--2.0196 -1.70639 -0.879159
--1.94131 -1.90515 -0.684687
--1.76841 -1.58993 -0.905342
-4.72516 6.44662 1.21841
-4.73792 6.57493 0.915771
-3.68287 4.18187 -0.526314
-3.50624 4.1701 -0.351124
-3.90995 4.2848 -0.642594
-3.70735 3.95738 -0.66932
-2.93633 -1.07939 -1.07913
--3.20956 4.09792 0.063764
--3.50183 4.17958 -0.0142002
-3.91306 -0.155595 0.788118
--4.39097 2.09575 0.146491
-0.184576 -2.77154 -0.463524
-0.0870141 -2.71703 -0.193715
-0.219426 -2.60801 -0.775769
-4.20285 3.82822 1.88007
-4.25872 3.538 1.90751
-4.49702 3.79386 1.94889
--1.57328 -2.03973 -0.222727
--1.7838 -2.02128 -0.456646
--1.49434 -1.90895 -0.46828
--0.957513 -1.3728 -0.447891
--1.20402 -1.4363 -0.67009
-6.83616 6.17327 1.25295
-7.00706 5.93239 1.10711
--3.41004 -0.242093 0.708752
--3.56609 -0.173589 0.451116
--3.90355 0.773166 -0.0564864
-3.3433 -1.3011 -0.351382
-3.25465 -1.53753 -0.15651
-3.19202 -1.43629 -0.547186
-3.41507 -1.27939 -0.0436594
-2.98183 -0.522819 1.37626
-5.9832 3.18839 0.141472
-5.77964 2.88845 0.0259852
--2.13926 -2.01567 -0.53657
--1.9672 -2.11993 -0.265938
--2.25909 -2.10993 -0.274683
--1.79485 -0.94831 1.02389
--1.57427 -1.12795 0.944994
--2.06365 -1.07664 1.07462
--1.80838 -1.26245 1.01602
--3.83176 2.09083 -0.547069
--3.86997 1.74371 -0.481612
--1.94632 1.44485 0.0887583
--1.96622 1.51643 0.384777
--4.32638 3.59105 1.34152
--3.22813 4.02811 1.09674
--4.08072 2.20495 1.22251
--3.46697 2.1126 1.44245
--3.29245 1.78538 -0.723477
--3.63377 1.80859 -0.628613
--3.51612 2.06123 -0.667671
--3.46311 4.20389 0.989019
-1.49452 -0.115509 1.29499
-1.75305 -0.0357478 1.41123
-0.768827 -1.40298 -1.34296
-0.556678 -1.30991 -1.18129
-0.898478 -1.15196 -1.30738
-1.01361 -1.54357 -1.47238
-0.702543 -1.68077 -1.39488
-1.09328 -0.664853 -1.20743
-1.18661 -1.02369 -1.3797
--1.42558 -0.33841 0.641049
-6.05708 6.63049 1.50038
-6.41749 6.64977 1.16437
-6.22387 6.81625 0.942876
-3.09076 1.62294 1.70022
-4.52234 1.67209 -0.815015
-4.28146 1.77505 -0.987945
-4.7855 1.72238 -0.598852
-2.49956 2.93473 0.47466
-2.64666 3.19735 0.414795
-5.36114 4.70226 2.06292
-5.6335 4.97865 2.08567
-5.28675 2.02038 0.791557
-2.77353 3.41595 0.378211
-2.95748 3.57676 0.873368
-2.88726 3.59112 0.567287
-5.71434 5.57136 2.13322
-5.60691 5.27755 2.12246
-3.97017 3.55059 1.82765
-4.10181 3.25591 1.87995
-4.41362 3.24039 1.9119
-4.15012 5.50191 -0.00880473
-4.30526 5.8667 0.152321
-4.4775 5.92667 -0.0920593
--3.48564 3.36832 1.55142
--3.64021 3.07456 1.56285
-1.19266 -0.18378 -1.03496
-1.35133 0.0175528 -1.04411
-0.221046 -1.87146 0.890689
-0.227082 -2.15703 0.861571
-0.450742 -1.91364 1.08247
-0.382439 -1.64119 1.00028
-0.0408999 -1.72004 0.681575
-0.0321474 -2.01193 0.663585
-4.94411 6.68435 1.06579
-2.12227 1.99626 0.902725
-2.2774 2.30864 0.883211
-3.47658 3.86628 -0.539858
-3.53121 3.63415 -0.711546
-0.383882 -2.43701 0.904313
--0.0119596 -2.44544 0.307758
-0.0438695 -2.63832 0.0917509
-0.0047199 -2.24636 0.530223
--0.141071 -2.1755 0.263726
-0.952041 -1.84257 -1.50654
-0.745924 -2.07318 -1.4291
-1.07238 -2.11443 -1.52431
--2.67241 -1.67249 0.712594
--2.69159 -1.85502 0.484789
--1.74437 -2.11499 -0.0390346
--1.59144 -2.04819 0.192405
--3.23048 -0.613651 0.726188
--3.1003 0.484134 -0.812179
--1.73891 -1.97595 0.500675
--2.26099 -1.31324 1.03791
--1.92367 1.23808 -0.129631
--4.64713 3.51719 0.0411152
-1.80291 -2.0016 1.32456
-1.85548 -1.59922 1.39789
-4.70161 5.67007 -0.485873
-4.31853 5.26837 -0.413047
-6.47695 4.35871 1.38263
-6.57226 4.6753 1.52743
-2.04855 -0.472272 -1.41666
-4.00005 0.924923 -0.951886
-2.25363 0.848354 -1.17504
-1.97693 0.94876 -1.00173
-1.63528 -3.25353 -0.648317
-4.19376 0.656773 1.13759
-4.35117 0.605262 0.880451
-4.23031 0.368505 0.823966
-4.49884 0.67108 0.643434
-4.20074 4.22861 -0.813157
-4.19619 5.10754 1.55477
-4.38704 5.0511 1.74036
-3.99278 4.88077 1.4551
-4.18852 4.84039 1.66155
-2.59518 -1.9158 -1.03502
-1.8139 1.71736 0.507648
-1.6818 1.54618 0.289751
-0.336473 -0.750648 0.31608
-5.87675 2.93202 0.325721
-3.67806 2.98568 1.78283
-3.53653 3.25716 1.6805
-3.65639 2.68115 1.79697
-3.98036 2.95554 1.85837
-3.81875 3.25468 1.80484
-2.36931 1.92379 1.26401
-2.15654 1.79216 1.10497
-1.95369 1.69345 0.886935
-2.00576 1.52792 1.08257
-2.0952 2.04456 -0.309954
-4.51107 0.874528 0.904642
-0.610712 -0.311749 -0.307799
--1.74496 -1.33763 -0.997484
--1.45212 -1.25074 -0.889817
-0.661269 -1.04324 -1.11131
-0.634762 -0.824682 -0.948262
-0.918939 -0.88082 -1.20299
-0.372291 -1.21874 -0.975902
-2.58019 -0.607671 -1.35187
-2.87306 -0.523565 -1.25403
-2.34672 -0.40951 -1.40023
-2.67291 -0.281842 -1.3442
--4.46605 2.6595 -0.0750197
-3.64734 -0.497828 0.857082
-3.52848 -0.351629 1.10692
-3.28093 -0.491017 1.22485
--0.213742 -2.13849 -0.0684245
--1.48472 -0.937236 -0.902424
--1.56183 -0.668097 -0.857501
-1.63334 1.38087 0.535899
-1.63206 1.44375 -0.0133946
--2.48138 -2.03242 0.336024
--1.2438 -1.85587 -0.27945
--1.68491 -1.80091 -0.719222
--1.41968 -1.70717 -0.658728
-2.95214 -0.959692 1.21211
-2.75378 -0.766303 1.38522
-4.66517 5.16481 1.88339
-1.87003 -0.939994 1.47548
-1.86338 -1.26014 1.44671
-2.1231 -0.721096 1.50286
-1.82562 -0.617931 1.47843
--1.34774 -1.30235 0.793023
--1.14457 -1.46044 0.574023
--1.45534 -0.113742 0.557684
-1.79229 1.53257 0.740421
-3.43772 0.802948 1.61639
-3.20445 0.640149 1.6245
-3.56751 0.536357 1.5004
-1.59329 0.376284 1.21677
-1.73238 0.635661 1.2334
-5.22833 6.33029 -0.43389
-4.96776 6.38157 -0.23813
-5.1791 6.547 -0.200233
-5.44141 6.49044 -0.364217
-5.51654 6.24094 -0.571262
-2.92746 3.66704 0.275867
-6.34654 6.54281 1.43326
-3.25039 -1.5602 0.11322
-2.85944 -2.23279 -0.0732012
-4.38275 2.07604 -0.991394
-4.09042 2.18951 -1.09581
-5.75814 4.29225 1.89287
-2.74832 2.85199 -0.505114
-3.68766 4.82552 0.0631025
-3.83732 5.08283 0.0925874
-3.69807 4.9538 0.298257
-1.55969 0.266167 -1.0613
-2.91261 0.661908 1.64556
-3.02363 0.943336 1.67299
-2.71551 0.953587 1.63465
-2.60253 0.688273 1.61557
-2.74231 0.398447 1.61799
-6.48291 4.13995 1.12826
-6.70707 4.56524 1.22483
-0.504343 -0.578583 0.460941
-0.0467313 -1.11571 -0.419416
-0.169507 -1.20597 -0.739227
--0.0723879 -1.34365 -0.513731
--0.177271 -1.31162 -0.246719
-4.90379 6.17759 -0.356758
-5.3405 6.02825 -0.644789
-2.78225 1.00994 -1.2548
-3.13091 -1.69876 -0.320607
-4.47499 4.07246 1.94158
-0.412326 -0.980694 -0.828668
-3.34711 3.95865 -0.327486
-3.37465 -1.32531 0.249912
-3.19526 -1.53907 0.43947
--2.2061 0.251646 -0.857804
-0.247761 -2.9145 -0.0117359
-0.455752 -3.07293 0.163174
-0.219303 -2.8124 0.28056
--1.48099 -1.50251 -0.829242
-5.93164 3.68532 -0.40056
-6.05283 3.4355 -0.0316498
-6.79265 5.63829 1.61471
-6.6083 5.84948 1.74583
-5.951 6.69825 -0.100776
-5.75294 6.59186 -0.28301
-5.71199 6.79355 0.0184065
-6.05111 6.49981 -0.316511
--0.999869 -1.56258 0.343525
-2.67989 -0.484584 1.48402
-2.39535 -0.594343 1.50711
-6.29584 6.36949 1.66271
-6.57645 6.28739 1.50741
-6.01081 6.43817 1.73173
-6.13006 6.19322 1.87146
-6.45407 6.10996 1.74697
-0.730679 -0.395163 0.688005
-2.87083 0.71092 -1.29382
-3.12719 0.869261 -1.26455
-3.02126 0.42801 -1.28565
-2.57405 0.67679 -1.28791
-4.12177 0.651651 -0.747676
-0.586553 -2.46589 -1.23518
-1.89981 0.176955 1.44263
-0.555262 -0.703911 0.683419
-3.34187 0.283585 -1.17247
-6.18166 6.82179 0.350148
-6.16875 6.72622 0.0688665
-3.82576 0.111321 1.13027
-5.74637 3.87107 -0.634074
-3.65573 -0.864897 -0.0280244
--2.03556 -0.58493 -1.00781
--0.962678 -1.58874 -0.308596
--1.18427 -1.67338 -0.492639
--0.787314 -1.42904 -0.102052
--1.0209 -1.73883 -0.101643
--1.37145 -1.59448 0.686084
--1.23301 -1.73376 0.442084
-4.84478 2.5234 1.65528
-6.46945 3.96742 0.835967
-6.62786 4.19802 0.655412
-4.71108 3.26124 -0.986653
-1.30906 -1.7287 1.38482
-1.61143 -1.80982 1.38709
-1.54339 -1.48862 1.4185
-1.29118 -2.01526 1.36748
-4.65175 6.3784 0.141357
-4.82002 6.59405 0.263494
-4.85959 6.47672 -0.0217641
-4.69028 6.24067 -0.0947652
-4.4889 6.1068 0.083698
-4.40184 3.33694 -1.02265
--1.56747 0.433475 -0.0436031
--1.63338 0.389874 -0.302603
--0.197666 -1.59359 -0.459092
--0.0779926 -1.7566 -0.692614
-1.4817 -0.365115 1.34121
-5.89633 6.08441 1.98954
-6.27472 5.93005 1.93426
-4.01904 0.114727 0.901652
-3.75072 -0.182644 0.995939
-2.45719 2.54729 0.980497
-0.693332 -0.804017 0.916064
-1.1272 0.176144 -0.715731
-3.00945 -1.5491 -0.759985
-3.18123 -1.20069 -0.769402
-0.0274662 -1.46365 -0.748285
--2.56225 -2.0567 0.0780375
-1.58256 -1.2015 1.43451
-3.05691 -1.88918 -0.116947
-3.98267 2.93008 -1.0623
-4.6792 6.03583 -0.248493
-2.43685 0.363819 1.5864
-3.70348 3.52556 1.71342
-1.83603 0.411313 1.36829
-5.65818 4.66438 2.02439
-3.8853 5.05031 1.16876
-4.65334 0.869003 0.51696
-6.53091 4.59908 -0.233095
-6.75779 6.01931 1.50915
-6.63874 6.43303 1.24419
-3.60485 2.39428 1.79237
-3.33376 2.35303 1.72613
-5.03487 6.65485 0.0779902
-5.29225 6.72323 -0.00264884
-0.682554 -1.77132 1.21017
-5.51032 6.67496 -0.162077
--1.35356 -1.96607 -0.0531971
--1.33195 -1.92089 0.21685
--1.4832 -1.88243 0.477699
-5.73332 6.39403 -0.474629
-2.97807 1.23731 1.6815
-3.50333 4.35091 1.14806
-1.24969 -2.30845 1.31772
-1.48173 -2.51244 1.2417
-1.55307 -2.18502 1.33192
-0.431625 -2.95125 0.442724
-2.07865 -0.396464 1.52085
-4.21847 1.47618 -0.959538
-3.93133 1.58264 -1.1044
-4.21127 1.13045 -0.866204
-3.95771 1.26871 -1.05316
-4.82686 1.23036 -0.0898065
-4.61541 0.865908 -0.120677
-4.78625 1.39445 -0.375139
-4.20963 1.65646 1.62192
-4.45 1.51805 1.43825
-3.9058 5.31517 0.79878
-6.26591 3.9462 1.29562
-6.53298 6.28967 -0.20737
-6.53832 6.5005 0.0566181
-5.2032 1.76706 0.403345
-5.13831 1.71867 0.0509462
-5.12024 1.87673 -0.232021
-5.28893 2.02777 -0.0236116
-2.50009 0.962039 -1.21678
-2.03612 0.676161 -1.14653
-5.75137 6.29458 1.88841
-6.15442 3.93536 -0.286305
--1.09909 -1.78527 0.138912
--0.86237 -1.54507 0.114611
-5.17196 6.2783 1.78999
-4.97714 5.96315 1.8617
-4.0028 5.50798 0.687783
-3.98686 5.46925 0.434364
-3.81488 4.81064 1.26534
-4.50567 4.8653 1.86085
-2.62118 2.36918 1.30126
-4.28542 4.64589 1.78728
-4.33502 4.36976 1.86662
-4.5518 4.60332 1.92335
-4.04779 3.78449 -0.895859
-3.9688 4.04129 -0.780688
-4.29203 3.95453 -0.916237
-6.2876 6.81621 0.640181
-3.68368 3.79203 1.63444
-4.81931 4.65532 2.00249
-1.88246 -1.74879 -1.47807
-4.76888 6.62329 0.57421
-1.12509 -3.16951 -0.84588
-1.90506 1.29572 1.09971
-2.15641 1.36484 1.30612
-4.61852 4.32858 1.96643
-6.7159 6.48222 0.952146
-4.12571 5.62118 0.224686
-3.98719 5.36739 0.167796
-1.34817 -2.00593 -1.55841
-3.05651 3.84653 0.148626
-3.1696 3.89738 -0.0939009
-5.75799 6.68102 1.50991
-1.79773 0.653071 -1.02854
-2.29958 2.10351 1.08738
--0.128184 -1.90268 0.439787
-3.26969 2.06654 1.72671
-5.19114 6.66123 1.38853
-5.91983 5.24911 2.09809
-3.86438 -0.399574 -0.28046
-3.70682 -0.53187 -0.484605
-3.78908 -0.274399 -0.578751
-2.44256 2.32066 1.13015
--1.55262 -0.424198 -0.738876
-6.05052 5.80848 2.05129
-2.07142 0.401857 -1.24737
-4.02043 1.88971 -1.1004
-3.71078 1.88293 -1.16101
-3.84766 5.21151 0.332386
-1.77662 -0.317695 1.45267
-0.989911 -1.94255 1.32892
-2.41566 0.976127 1.54442
-2.33499 0.63801 1.55087
-5.49068 4.38816 1.99693
-4.95415 1.60811 -0.276694
-5.80811 6.08693 -0.657578
-5.8141 3.47802 1.46329
-5.1395 5.46839 -0.750583
-5.67682 5.37944 -0.807399
-3.34488 2.64026 1.69784
-0.23951 -1.48039 -1.0031
-3.39468 4.10375 1.18297
-5.18786 4.71238 -0.881035
-5.34286 4.36839 -0.87583
-6.67348 4.35049 0.962775
-4.7061 1.52652 1.2247
-6.2992 6.54826 -0.12266
-6.5045 6.67914 0.867196
-3.99441 5.21358 -0.0625023
-4.1803 5.3428 -0.213286
-4.06848 5.54374 0.950084
-6.85965 4.62002 0.860343
-6.42626 6.67904 0.269565
-1.00366 -3.2753 -0.567987
-1.60287 1.31145 -0.22993
-6.01536 5.53762 2.09694
-4.62302 1.213 1.0716
-4.68684 1.06266 0.793353
-6.41069 5.6685 1.9289
-1.01531 -2.64462 -1.33261
-1.16134 -2.37991 -1.47818
-1.27247 -2.99597 -1.09768
-1.0272 -2.88095 -1.16509
-0.586194 -2.92571 0.674941
-1.43883 -3.16763 -0.87223
-1.05392 -0.07426 -0.833896
-0.831701 -2.37767 -1.39552
--0.178126 -1.37501 0.202387
-2.10804 1.10872 1.35497
-1.80263 0.372686 -1.15221
-1.54626 -0.628755 1.40473
--0.821186 -1.21034 -0.252178
-6.25101 5.59041 -0.675114
-4.29624 2.96824 1.88425
-2.96901 -1.34288 -0.937122
<title>MathGL 2.0</title>
</head><body>
-<table style="width: 100%;" cellspacing="10">
-<tr><td style="width: 125px;">
-<img style="border: 0px solid ; width: 100px; height: 50px;" src="emblem_sm.png"></td>
-<td><h1 style="text-align: left;">MathGL – library for scientific data visualization</h1>
-<hr style="width: 100%; height: 2px;"></td></tr>
+<h1><a target="main" href="web_en/web_en_1.html"><img border="0" align="left" hspace="30" vspace="0" src="emblem_sm.png"></a> MathGL – library for scientific data visualization</h1>
-</body>
\ No newline at end of file
+</body>
<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="mgl_web_en/mathgl_en.html"><b>Documentation</b></a></p>
+<a target="main" href="doc_en/doc_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;">
<b>MathGL</b>
</td></tr>
<tr><td style="padding-left: 5px">
- <a href="http://groups.google.com/group/mathgl">Visit this group</a>
+ <a target=_blank href="http://groups.google.com/group/mathgl">Visit this group</a>
</td></tr>
</table></p>
-</body>
\ No newline at end of file
+</body>
<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="mathgl_en/mathgl_en.html"><b>Documentation</b></a></p>
+<a target="main" href="doc_en/doc_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;">
<a target="main" href="web_ru/web_ru_4.html"><b>Примеры</b></a></p>
<a target="main" href="web_ru/web_ru_5.html"><b>Скрипты MGL</b></a></p>
<a target="main" href="web_ru/web_ru_6.html"><b>Загрузка</b></a></p>
-<a target="main" href="mathgl_ru/mathgl_ru.html"><b>Документация</b></a></p>
+<a target="main" href="doc_ru/doc_ru.html"><b>Документация</b></a></p>
<a target="main" href="web_ru/web_ru_8.html"><b>Другие проекты</b></a></p>
<hr style="width: 100%; height: 1px;">
\input texinfo
@setfilename mgl_web_en.info
-@set VERSION 2.0
+@set VERSION 2.0.2
@settitle MathGL @value{VERSION}
@syncodeindex pg cp
@comment %**end of header
" hours, number of visitors during 24 hours and during today' "+
"border=0 width=88 height=31><\/a>")//--></script><!--/LiveInternet-->
-<a href="http://sourceforge.net"><img src="http://sflogo.sourceforge.net/sflogo.php?group_id=152187&type=2" alt="SourceForge.net Logo" border="0" height="37" width="125"></a>
+<a
target=_blank href="http://sourceforge.net"><img src="http://sflogo.sourceforge.net/sflogo.php?group_id=152187&type=2" alt="SourceForge.net Logo" border="0" height="37" width="125"></a>
-<a href="http://www.thefreecountry.com/"> <img src="http://www.thefreecountry.com/images/tfc88x31green.gif" alt="thefreecountry.com: Free Programmers' Resources, Free Webmasters' Resources, Free Security Resources, Free Software" border="0" height="31" width="88"></a>
+<a
target=_blank href="http://www.thefreecountry.com/"> <img src="http://www.thefreecountry.com/images/tfc88x31green.gif" alt="thefreecountry.com: Free Programmers' Resources, Free Webmasters' Resources, Free Security Resources, Free Software" border="0" height="31" width="88"></a>
-<a href="http://sourceforge.net/donate/index.php?group_id=152187"><img src="http://images.sourceforge.net/images/project-support.jpg" width="88" height="32" border="0" alt="Support This Project" /> </a>
+<a
target=_blank href="http://sourceforge.net/donate/index.php?group_id=152187"><img src="http://images.sourceforge.net/images/project-support.jpg" width="88" height="32" border="0" alt="Support This Project" /> </a>
@end html
@end macro
@macro fig {plot,text}
-@uref{../\text\, @image{../small/\plot\_sm,3cm, , , .png}}
+@uref{../\text\, @image{../small/\plot\-sm,3cm, , , .png}}
@end macro
@end ifhtml
@macro external {}
@end macro
@macro fig {plot,text}
-@uref{http://mathgl.sourceforge.net/\text\, @image{small/\plot\_sm,3cm, , , .png}}
+@uref{http://mathgl.sourceforge.net/\text\, @image{small/\plot\-sm,3cm, , , .png}}
@end macro
@end ifnothtml
@strong{Latest news}
@itemize
+@item @emph{24 May 2012.}
+New version (v.@value{VERSION}) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are speeding up and minor bugfixes and improvements, which partially denoted @ref{News, here}.
@item @emph{12 April 2012.}
New version (v.2.0) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are a lot of new features, which partially denoted @ref{News, here}.
@end itemize
@section News
@itemize
+
+@item
+@strong{24 May 2012.}
+New version (v.2.0.2) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are speeding up and minor bugfixes and improvements:
+@itemize @bullet
+@item
+Add 'U' style for Axis() which disable ticks rotation.
+@item
+Improve speed of drawing
+@item
+Add reading 3d data files using mglData::ReadMat()
+@item
+Exclude unnecessary dependencies/inclusions
+@item
+Improve build system: add multithreading; add install for Octave; separate enable-doc option from enable-all
+@item
+Minor bugfixes
+@end itemize
+
@item
@strong{12 April 2012.}
New version (v.2.0) of @uref{http://sourceforge.net/projects/mathgl, MathGL} is released. There are a lot of new features, which partially denoted below.
@anchor{1D plotting}
@subsection Examples of graphics for 1d arrays
-@fig{plot, doc_en/mathgl_en_32.html#Plot-sample}
-@fig{radar, doc_en/mathgl_en_33.html#Radar-sample}
-@fig{step, doc_en/mathgl_en_34.html#Step-sample}
-@fig{tens, doc_en/mathgl_en_35.html#Tens-sample}
+@fig{plot, doc_en/doc_en_32.html#Plot-sample}
+@fig{radar, doc_en/doc_en_33.html#Radar-sample}
+@fig{step, doc_en/doc_en_34.html#Step-sample}
+@fig{tens, doc_en/doc_en_35.html#Tens-sample}
-@fig{area, doc_en/mathgl_en_36.html#Area-sample}
-@fig{region, doc_en/mathgl_en_37.html#Region-sample}
-@fig{stem, doc_en/mathgl_en_38.html#Stem-sample}
-@fig{torus, doc_en/mathgl_en_51.html#Torus-sample}
+@fig{area, doc_en/doc_en_36.html#Area-sample}
+@fig{region, doc_en/doc_en_37.html#Region-sample}
+@fig{stem, doc_en/doc_en_38.html#Stem-sample}
+@fig{torus, doc_en/doc_en_51.html#Torus-sample}
-@fig{bars, doc_en/mathgl_en_39.html#Bars-sample}
-@fig{barh, doc_en/mathgl_en_40.html#Barh-sample}
-@fig{cones, doc_en/mathgl_en_41.html#Cones-sample}
-@fig{chart, doc_en/mathgl_en_42.html#Chart-sample}
+@fig{bars, doc_en/doc_en_39.html#Bars-sample}
+@fig{barh, doc_en/doc_en_40.html#Barh-sample}
+@fig{cones, doc_en/doc_en_41.html#Cones-sample}
+@fig{chart, doc_en/doc_en_42.html#Chart-sample}
-@fig{boxplot, doc_en/mathgl_en_43.html#BoxPlot-sample}
-@fig{candle, doc_en/mathgl_en_44.html#Candle-sample}
-@fig{tube, doc_en/mathgl_en_49.html#Tube-sample}
-@fig{tape, doc_en/mathgl_en_50.html#Tape-sample}
+@fig{boxplot, doc_en/doc_en_43.html#BoxPlot-sample}
+@fig{candle, doc_en/doc_en_44.html#Candle-sample}
+@fig{tube, doc_en/doc_en_49.html#Tube-sample}
+@fig{tape, doc_en/doc_en_50.html#Tape-sample}
-@fig{error, doc_en/mathgl_en_45.html#Error-sample}
-@fig{mark, doc_en/mathgl_en_46.html#Mark-sample}
-@fig{textmark, doc_en/mathgl_en_47.html#TextMark-sample}
-@fig{label, doc_en/mathgl_en_48.html#Label-sample}
+@fig{error, doc_en/doc_en_45.html#Error-sample}
+@fig{mark, doc_en/doc_en_46.html#Mark-sample}
+@fig{textmark, doc_en/doc_en_47.html#TextMark-sample}
+@fig{label, doc_en/doc_en_48.html#Label-sample}
@anchor{2D plotting}
@subsection Examples of graphics for 2d arrays
-@fig{surf, doc_en/mathgl_en_53.html#Surf-sample}
-@fig{surfc, doc_en/mathgl_en_54.html#SurfC-sample}
-@fig{surfa, doc_en/mathgl_en_55.html#SurfA-sample}
-@fig{mesh, doc_en/mathgl_en_56.html#Mesh-sample}
+@fig{surf, doc_en/doc_en_53.html#Surf-sample}
+@fig{surfc, doc_en/doc_en_54.html#SurfC-sample}
+@fig{surfa, doc_en/doc_en_55.html#SurfA-sample}
+@fig{mesh, doc_en/doc_en_56.html#Mesh-sample}
-@fig{fall, doc_en/mathgl_en_57.html#Fall-sample}
-@fig{belt, doc_en/mathgl_en_58.html#Belt-sample}
-@fig{boxs, doc_en/mathgl_en_59.html#Boxs-sample}
-@fig{axial, doc_en/mathgl_en_67.html#Axial-sample}
+@fig{fall, doc_en/doc_en_57.html#Fall-sample}
+@fig{belt, doc_en/doc_en_58.html#Belt-sample}
+@fig{boxs, doc_en/doc_en_59.html#Boxs-sample}
+@fig{axial, doc_en/doc_en_67.html#Axial-sample}
-@fig{dens, doc_en/mathgl_en_62.html#Dens-sample}
-@fig{tile, doc_en/mathgl_en_60.html#Tile-sample}
-@fig{tiles, doc_en/mathgl_en_61.html#TileS-sample}
-@fig{grad, doc_en/mathgl_en_68.html#Grad-sample}
+@fig{dens, doc_en/doc_en_62.html#Dens-sample}
+@fig{tile, doc_en/doc_en_60.html#Tile-sample}
+@fig{tiles, doc_en/doc_en_61.html#TileS-sample}
+@fig{grad, doc_en/doc_en_68.html#Grad-sample}
-@fig{cont, doc_en/mathgl_en_63.html#Cont-sample}
-@fig{contf, doc_en/mathgl_en_64.html#ContF-sample}
-@fig{contd, doc_en/mathgl_en_65.html#ContD-sample}
-@fig{contv, doc_en/mathgl_en_66.html#ContV-sample}
+@fig{cont, doc_en/doc_en_63.html#Cont-sample}
+@fig{contf, doc_en/doc_en_64.html#ContF-sample}
+@fig{contd, doc_en/doc_en_65.html#ContD-sample}
+@fig{contv, doc_en/doc_en_66.html#ContV-sample}
@anchor{3D plotting}
@subsection Examples of graphics for 3d arrays
-@fig{surf3, doc_en/mathgl_en_70.html#Surf3-sample}
-@fig{surf3c, doc_en/mathgl_en_71.html#Surf3C-sample}
-@fig{surf3a, doc_en/mathgl_en_72.html#Surf3A-sample}
-@fig{cloud, doc_en/mathgl_en_73.html#Cloud-sample}
+@fig{surf3, doc_en/doc_en_70.html#Surf3-sample}
+@fig{surf3c, doc_en/doc_en_71.html#Surf3C-sample}
+@fig{surf3a, doc_en/doc_en_72.html#Surf3A-sample}
+@fig{cloud, doc_en/doc_en_73.html#Cloud-sample}
-@fig{densa, doc_en/mathgl_en_74.html#Dens3-sample}
-@fig{conta, doc_en/mathgl_en_75.html#Cont3-sample}
-@fig{contfa, doc_en/mathgl_en_76.html#ContF3-sample}
-@fig{dots, doc_en/mathgl_en_81.html#Dots-sample}
+@fig{densa, doc_en/doc_en_74.html#Dens3-sample}
+@fig{conta, doc_en/doc_en_75.html#Cont3-sample}
+@fig{contfa, doc_en/doc_en_76.html#ContF3-sample}
+@fig{dots, doc_en/doc_en_81.html#Dots-sample}
-@fig{dens_xyz, doc_en/mathgl_en_77.html#Dens-projection-sample}
-@fig{cont_xyz, doc_en/mathgl_en_78.html#Cont-projection-sample}
-@fig{contf_xyz, doc_en/mathgl_en_79.html#ContF-projection-sample}
-@fig{triplot, doc_en/mathgl_en_80.html#TriPlot-and-QuadPlot}
+@fig{dens_xyz, doc_en/doc_en_77.html#Dens-projection-sample}
+@fig{cont_xyz, doc_en/doc_en_78.html#Cont-projection-sample}
+@fig{contf_xyz, doc_en/doc_en_79.html#ContF-projection-sample}
+@fig{triplot, doc_en/doc_en_80.html#TriPlot-and-QuadPlot}
@anchor{Vector fields}
@subsection Examples of graphics for vector fields
-@fig{vect, doc_en/mathgl_en_83.html#Vect-sample}
-@fig{traj, doc_en/mathgl_en_84.html#Tra-sjample}
-@fig{flow, doc_en/mathgl_en_85.html#Flow-sample}
-@fig{pipe, doc_en/mathgl_en_86.html#Pipe-sample}
+@fig{vect, doc_en/doc_en_83.html#Vect-sample}
+@fig{traj, doc_en/doc_en_84.html#Tra-sjample}
+@fig{flow, doc_en/doc_en_85.html#Flow-sample}
+@fig{pipe, doc_en/doc_en_86.html#Pipe-sample}
@anchor{Extra samples}
@subsection Examples of additional features
-@fig{inplot, doc_en/mathgl_en_17.html#Subplots}
-@fig{axis, doc_en/mathgl_en_18.html#Axis-and-ticks}
-@fig{ticks, doc_en/mathgl_en_18.html#Axis-and-ticks}
-@fig{loglog, doc_en/mathgl_en_18.html#Axis-and-ticks}
-
-@fig{curvcoor, doc_en/mathgl_en_19.html#Curvilinear-coordinates}
-@fig{colorbar, doc_en/mathgl_en_20.html#Colorbars}
-@fig{box, doc_en/mathgl_en_21.html#Bounding-box}
-@fig{ternary, doc_en/mathgl_en_22.html#Ternary-axis}
-
-@fig{text, doc_en/mathgl_en_23.html#Text-features}
-@fig{legend, doc_en/mathgl_en_24.html#Legend-sample}
-@fig{cut, doc_en/mathgl_en_25.html#Cutting-sample}
-@fig{alpha, doc_en/mathgl_en_90.html#Transparency-and-lighting}
-
-@fig{type0, doc_en/mathgl_en_91.html#Types-of-transparency}
-@fig{type1, doc_en/mathgl_en_91.html#Types-of-transparency}
-@fig{type2, doc_en/mathgl_en_91.html#Types-of-transparency}
-@fig{fog, doc_en/mathgl_en_92.html#Adding-fog}
-
-@fig{combined, doc_en/mathgl_en_89.html#g_t_0060_0060Compound_0027_0027-graphics}
-@fig{several_light, doc_en/mathgl_en_93.html#Several-light-sources}
-@fig{stereo, doc_en/mathgl_en_102.html#Stereo-image}
-@fig{primitives, doc_en/mathgl_en_94.html#Using-primitives}
-
-@fig{stfa, doc_en/mathgl_en_95.html#STFA-sample}
-@fig{dat_diff, doc_en/mathgl_en_29.html#Change-data}
-@fig{dat_extra, doc_en/mathgl_en_29.html#Change-data}
-@fig{map, doc_en/mathgl_en_96.html#Mapping-visualization}
-
-@fig{hist, doc_en/mathgl_en_97.html#Making-histogram}
-@fig{fit, doc_en/mathgl_en_98.html#Nonlinear-fitting-sample}
-@fig{pde, doc_en/mathgl_en_99.html#PDE-solving-hints}
-@fig{parser, doc_en/mathgl_en_100.html#MGL-parser-using}
+@fig{inplot, doc_en/doc_en_17.html#Subplots}
+@fig{axis, doc_en/doc_en_18.html#Axis-and-ticks}
+@fig{ticks, doc_en/doc_en_18.html#Axis-and-ticks}
+@fig{loglog, doc_en/doc_en_18.html#Axis-and-ticks}
+
+@fig{curvcoor, doc_en/doc_en_19.html#Curvilinear-coordinates}
+@fig{colorbar, doc_en/doc_en_20.html#Colorbars}
+@fig{box, doc_en/doc_en_21.html#Bounding-box}
+@fig{ternary, doc_en/doc_en_22.html#Ternary-axis}
+
+@fig{text, doc_en/doc_en_23.html#Text-features}
+@fig{legend, doc_en/doc_en_24.html#Legend-sample}
+@fig{cut, doc_en/doc_en_25.html#Cutting-sample}
+@fig{alpha, doc_en/doc_en_90.html#Transparency-and-lighting}
+
+@fig{type0, doc_en/doc_en_91.html#Types-of-transparency}
+@fig{type1, doc_en/doc_en_91.html#Types-of-transparency}
+@fig{type2, doc_en/doc_en_91.html#Types-of-transparency}
+@fig{fog, doc_en/doc_en_92.html#Adding-fog}
+
+@fig{combined, doc_en/doc_en_89.html#g_t_0060_0060Compound_0027_0027-graphics}
+@fig{several_light, doc_en/doc_en_93.html#Several-light-sources}
+@fig{stereo, doc_en/doc_en_102.html#Stereo-image}
+@fig{primitives, doc_en/doc_en_94.html#Using-primitives}
+
+@fig{stfa, doc_en/doc_en_95.html#STFA-sample}
+@fig{dat_diff, doc_en/doc_en_29.html#Change-data}
+@fig{dat_extra, doc_en/doc_en_29.html#Change-data}
+@fig{map, doc_en/doc_en_96.html#Mapping-visualization}
+
+@fig{hist, doc_en/doc_en_97.html#Making-histogram}
+@fig{fit, doc_en/doc_en_98.html#Nonlinear-fitting-sample}
+@fig{pde, doc_en/doc_en_99.html#PDE-solving-hints}
+@fig{parser, doc_en/doc_en_100.html#MGL-parser-using}
@external
Command may have several set of possible arguments (for example, @code{plot ydat} and @code{plot xdat ydat}). All command arguments for a selected set must be specified. However, some arguments can have default values. These argument are printed in [], like @code{text ydat ['stl'='']} or @code{text x y 'txt' ['fnt'='' size=-1]}. At this, the record @code{[arg1 arg2 arg3 ...]} means @code{[arg1 [arg2 [arg3 ...]]]}, i.e. you can omit only tailing arguments if you agree with its default values. For example, @code{text x y 'txt' '' 1} or @code{text x y 'txt' ''} is correct, but @code{text x y 'txt' 1} is incorrect (argument @code{'fnt'} is missed).
-For more details see @uref{../doc_en/mathgl_en_166.html#MGL-scripts, MathGL documentation}
+For more details see @uref{../doc_en/doc_en_166.html#MGL-scripts, MathGL documentation}
@external
@node Download, Other projects, MGL scripts, Top
@section Download
-@strong{Stable version (v.2.0)}
+@strong{Stable version (v.@value{VERSION})}
You may download current version of MathGL for following configurations:
@itemize @bullet
@item
-@uref{http://downloads.sourceforge.net/mathgl/mathgl-2.0.tar.gz,source} file with autoconf/automake script.
+@uref{http://downloads.sourceforge.net/mathgl/mathgl-@value{VERSION}.tar.gz,source} file with cmake build system.
+@item
+@uref{http://downloads.sourceforge.net/mathgl/mathgl-@value{VERSION}-mingw.i686.7z,Win32 GPL} binaries for MinGW (build for i686)
@item
-@uref{http://downloads.sourceforge.net/mathgl/mathgl-2.0-mingw.i686.zip,Win32 GPL} binaries for MinGW (build for i686)
+@uref{http://downloads.sourceforge.net/mathgl/mathgl-@value{VERSION}.LGPL-mingw.i686.7z,Win32 LGPL} binaries for MinGW (build for i686, no GSL and HDF5 support)
@item
-@uref{http://downloads.sourceforge.net/mathgl/mathgl-2.0.LGPL-mingw.i686.zip,Win32 LGPL} binaries for MinGW (build for i686, no GSL and HDF5 support)
+@uref{http://downloads.sourceforge.net/mathgl/mathgl-@value{VERSION}-1.DevPack,DevPak} package for Dev-C++ or Code::Blocks (GPL version)
@item
-@uref{http://downloads.sourceforge.net/mathgl/mathgl-2.0-1.DevPack,DevPak} package for Dev-C++ or Code::Blocks (GPL version)
+@uref{http://downloads.sourceforge.net/mathgl/mathgl-@value{VERSION}.eng.pdf,PDF} documentation in English
@item
-@uref{http://downloads.sourceforge.net/mathgl/mathgl-2.0.eng.pdf,PDF} documentation in English
+@uref{http://downloads.sourceforge.net/mathgl/mgl_scripts-@value{VERSION}.7z,utilities} with all required DLL files (build for i686)
@c HTML documentation in English
@c HTML documentation in Russian
@c @item
@end html
@end macro
@macro fig {plot,text}
-@uref{../\text\, @image{../small/\plot\_sm,3cm, , , .png}}
+@uref{../\text\, @image{../small/\plot\-sm,3cm, , , .png}}
@end macro
@end ifhtml
@macro external {}
@end macro
@macro fig {plot,text}
-@uref{http://mathgl.sourceforge.net/\text\, @image{small/\plot\_sm,3cm, , , .png}}
+@uref{http://mathgl.sourceforge.net/\text\, @image{small/\plot\-sm,3cm, , , .png}}
@end macro
@end ifnothtml
You may download current version of MathGL for following configurations:
@itemize @bullet
@item
-@uref{http://downloads.sourceforge.net/mathgl/mathgl-2.0.tar.gz,source} file with autoconf/automake script.
+@uref{http://downloads.sourceforge.net/mathgl/mathgl-2.0.tar.gz,source} file with cmake build system.
@item
@uref{http://downloads.sourceforge.net/mathgl/mathgl-2.0-mingw.i686.zip,Win32 GPL} binaries for MinGW (build for i686)
@item
@end html
@end macro
@macro fig {plot,text}
-@uref{../\text\, @image{../small/\plot\_sm,3cm, , , .png}}
+@uref{../\text\, @image{../small/\plot\-sm,3cm, , , .png}}
@end macro
@end ifhtml
@macro external {}
@end macro
@macro fig {plot,text}
-@uref{http://mathgl.sourceforge.net/\text\, @image{small/\plot\_sm,3cm, , , .png}}
+@uref{http://mathgl.sourceforge.net/\text\, @image{small/\plot\-sm,3cm, , , .png}}
@end macro
@end ifnothtml
You may download current version of MathGL for following configurations:
@itemize @bullet
@item
-@uref{http://downloads.sourceforge.net/mathgl/mathgl-2.0.tar.gz,source} file with autoconf/automake script.
+@uref{http://downloads.sourceforge.net/mathgl/mathgl-2.0.tar.gz,source} file with cmake build system.
@item
@uref{http://downloads.sourceforge.net/mathgl/mathgl-2.0-mingw.i686.zip,Win32 GPL} binaries for MinGW (build for i686)
@item
There are set of ``window'' classes for making a window with MathGL graphics: @code{mglWindow} and @code{mglGLUT} for whole window, @code{Fl_MathGL} and @code{QMathGL} as widgets. All these classes allow user to show, rotate, export, and change view of the plot using keyboard. Most of them (except @code{mglGLUT}) also have toolbar and menu for simplifying plot manipulation. All window classes have mostly the same set of functions.
-For callback drawing you can use: @code{NULL} pointer if you'll update plot manually, global function of type @code{int draw(@code{HMGL} gr, @code{void *}p)} or @code{int draw(@code{mglGraph *}gr)}, or instance of class derived from @code{mglDraw} class. This class is defined in @code{#include <mgl2/window.h>} and have only 2 methods:
+For drawing you can use: @code{NULL} pointer if you'll update plot manually, global callback function of type @code{int draw(@code{HMGL} gr, @code{void *}p)} or @code{int draw(@code{mglGraph *}gr)}, or instance of class derived from @code{mglDraw} class. This class is defined in @code{#include <mgl2/window.h>} and have only 2 methods:
@verbatim
class mglDraw
{
@c ------------------------------------------------------------------
+@external
@node mglWindow class, Fl_MathGL class, , Widget classes
@section mglWindow class
@cindex mglWindow
@cindex window
@c @cindex mglDraw
-This class is derived from mglGraph class (@pxref{MathGL core}). It provide methods for handling window with MathGL graphics.
+This class is derived from mglGraph class (see @ref{MathGL core}). It is defined in @code{#include <mgl2/window.h>}. It provide methods for handling window with MathGL graphics.
@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}, @code{void} (*reload)(@code{HMGL} gr, @code{void *}p)=0)
Run/stop slideshow (animation) of frames.
@end deftypefn
-@deftypefn {Method on @code{mglWindow}} @code{void} SetDelay (@code{float} dt)
+@deftypefn {Method on @code{mglWindow}} @code{void} SetDelay (@code{mreal} dt)
@deftypefnx {C function} @code{int} mgl_wnd_set_delay (@code{HMGL} gr, @code{int} dt)
Sets delay for animation in seconds. Default value is 1 sec.
@end deftypefn
@end deftypefn
@deftypefn {Method on @code{mglWindow}} @code{mglPoint} LastMousePos ()
-@deftypefnx {C function} @code{int} mgl_get_last_mouse_pos (@code{HMGL} gr, @code{float *}x, @code{float *}y, @code{float *}z)
+@deftypefnx {C function} @code{int} mgl_get_last_mouse_pos (@code{HMGL} gr, @code{mreal *}x, @code{mreal *}y, @code{mreal *}z)
Gets last position of mouse click.
@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Fl_MathGL class, QMathGL class, mglWindow class, Widget classes
@section Fl_MathGL class
@cindex Fl_MathGL
@cindex widgets
-Class is FLTK widget which display MathGL graphics (defined in @code{#include <mgl2/fltk.h>}).
+Class is FLTK widget which display MathGL graphics. It is defined in @code{#include <mgl2/fltk.h>}.
@fig{fltk, Example of FLTK window with MathGL plot.}
@deftypemethod Fl_MathGL @code{void} set_draw (@code{int} (*draw)(@code{HMGL} gr, @code{void *}p))
@deftypemethodx Fl_MathGL @code{void} set_draw (@code{int} (*draw)(@code{mglGraph *}gr))
@deftypemethodx Fl_MathGL @code{void} set_draw (@code{mglDraw *}draw)
-Sets drawing function as global function as one from a class @code{mglDraw}. There is support of a list of plots (frames). So as one can prepare a set of frames at first and redraw it fast later (but it requires more memory). Function should return positive number of frames for the list or zero if it will plot directly. Parameter @var{par} contains pointer to data for the plotting function @var{draw}.
+Sets drawing function as global function or as one from a class @code{mglDraw}. There is support of a list of plots (frames). So as one can prepare a set of frames at first and redraw it fast later (but it requires more memory). Function should return positive number of frames for the list or zero if it will plot directly. Parameter @var{par} contains pointer to data for the plotting function @var{draw}.
@end deftypemethod
@deftypemethod Fl_MathGL @code{void} update ()
Update (redraw) plot.
@end deftypemethod
-@deftypemethod Fl_MathGL @code{void} set_angle (@code{float} t, @code{float} p)
+@deftypemethod Fl_MathGL @code{void} set_angle (@code{mreal} t, @code{mreal} p)
Set angles for additional plot rotation
@end deftypemethod
@deftypemethod Fl_MathGL @code{void} set_flag (@code{int} f)
@var{r}=@code{true} allow rotation/shifting/perspective and so on.
@end deftypemethod
-@deftypemethod Fl_MathGL @code{void} set_zoom (@code{float} X1, @code{float} Y1, @code{float} X2, @code{float} Y2)
+@deftypemethod Fl_MathGL @code{void} set_zoom (@code{mreal} X1, @code{mreal} Y1, @code{mreal} X2, @code{mreal} Y2)
Set zoom in/out region
@end deftypemethod
-@deftypemethod Fl_MathGL @code{void} get_zoom (@code{float *}X1, @code{float *}Y1, @code{float *}X2, @code{float *}Y2)
+@deftypemethod Fl_MathGL @code{void} get_zoom (@code{mreal *}X1, @code{mreal *}Y1, @code{mreal *}X2, @code{mreal *}Y2)
Get zoom in/out region
@end deftypemethod
@deftypemethod Fl_MathGL @code{void} set_graph (@code{mglCanvas *}gr)
@deftypemethodx Fl_MathGL @code{void} set_graph (@code{mglGraph *}gr)
-Set new grapher instead of built-in one. Note that Fl_MathGL will automatically delete this object at destruction or at new @code{setGraph()} call.
+Set new grapher instead of built-in one. Note that Fl_MathGL will automatically delete this object at destruction or at new @code{set_graph()} call.
@end deftypemethod
@deftypemethod Fl_MathGL @code{HMGL} get_graph ()
Get pointer to grapher.
@end deftypecv
@c ------------------------------------------------------------------
+@external
@node QMathGL class, , Fl_MathGL class, Widget classes
@section QMathGL class
@cindex QMathGL
@cindex widgets
-Class is Qt widget which display MathGL graphics (defined in @code{#include <mgl2/qt.h>}).
+Class is Qt widget which display MathGL graphics. It is defined in @code{#include <mgl2/qt.h>}.
@fig{qt, Example of Qt window with MathGL plot.}
Sets drawing functions from a class inherited from @code{mglDraw}.
@end deftypemethod
@deftypemethod QMathGL @code{void} setDraw (@code{int (*}draw)(@code{mglBase *}gr, @code{void *}p), @code{void *}par=@code{NULL})
-@deftypemethodx QMathGL @code{void} setDraw (@code{int (*}draw)(@code{mglGraph *}gr, @code{void *}p))
+@deftypemethodx QMathGL @code{void} setDraw (@code{int (*}draw)(@code{mglGraph *}gr))
Sets the drawing function @var{draw}. There is support of a list of plots (frames). So as one can prepare a set of frames at first and redraw it fast later (but it requires more memory). Function should return positive number of frames for the list or zero if it will plot directly. Parameter @var{par} contains pointer to data for the plotting function @var{draw}.
@end deftypemethod
@deftypemethod QMathGL @code{void} setGraph (@code{mglCanvas *}gr)
@deftypemethodx QMathGL @code{void} setGraph (@code{mglGraph *}gr)
-Set pointer to external grapher (instead of built-in @code{mglCanvas}). Note that QMathGL will automatically delete this object at destruction or at new @code{setGraph()} call.
+Set pointer to external grapher (instead of built-in one). Note that QMathGL will automatically delete this object at destruction or at new @code{setGraph()} call.
@end deftypemethod
@deftypemethod QMathGL @code{HMGL} getGraph ()
Get pointer to grapher.
@c @deftypefn {Slot on @code{QMathGL}} @code{void} reload ()
@c Reload data and redraw graphics.
@c @end deftypefn
+
@deftypefn {Slot on @code{QMathGL}} @code{void} exportPNG (@code{QString} fname=@code{""})
Export current picture to PNG file.
@end deftypefn
Rotation changed (by toolbar).
@end deftypefn
-@deftypefn {Signal on @code{QMathGL}} @code{void} mouseClick (@code{float} x, @code{float} y, @code{float} z)
+@deftypefn {Signal on @code{QMathGL}} @code{void} mouseClick (@code{mreal} x, @code{mreal} y, @code{mreal} z)
Mouse click take place at position @{x,y,z@}.
@end deftypefn
@deftypefn {Signal on @code{QMathGL}} @code{void} frameChanged (@code{int} val)
Allow auto resizing (default is false).
@end deftypecv
+@external
+
@c ------------------------------------------------------------------
@chapter ``Оконные'' классы
-@cindex mglGraphFLTK
-@cindex mglGraphQT
-@cindex mglGraphGLUT
+@cindex mglWindow
+@cindex mglGLUT
@cindex Fl_MathGL
@cindex QMathGL
@cindex window
@cindex widgets
-Есть целый набор ``оконных'' классов для создания окон с графикой MathGL: @code{mglGraphFLTK}, @code{mglGraphQT}, @code{mglGraphGLUT}. Все эти классы позволяют пользователю просмотривать, вращать, экспортировать рисунок. Большинство из них (кроме @code{mglGraphGLUT}) являются наследниками класса @code{mglGraphZB} и используют ``присоединенный'' класс для центрального виджета окна. Все оконные классы имеют схожий набор функций (@pxref{mglGraphAB class}). Ниже приведен список классов с краткими комментариями.
+Есть целый набор ``оконных'' классов для создания окон с графикой MathGL: @code{mglWindow} и @code{mglGLUT} для окон целиком, @code{Fl_MathGL} и @code{QMathGL} для виджетов. Все эти классы позволяют пользователю просмотривать, вращать, экспортировать рисунок. Большинство из них (кроме @code{mglGLUT}) имеют панель инструментов для упрощения изменения графика. Все оконные классы имеют схожий набор функций. Ниже приведен список классов с краткими комментариями.
-@deftp {Class} mglGraphFLTK
-Создает окно используя библиотеку FLTK. Окно имеет панель инструментов и меню для упрощения действий с графиками. ``Присоединенный'' класс элемента интерфейса -- @code{Fl_MathGL}. Класс определен в @code{#include <mgl2/mgl_fltk.h>}.
-@end deftp
+Для рисования можно использовать: указатель @code{NULL} если планируется обновлять график вручную, глобальную функцию типа @code{int draw(@code{HMGL} gr, @code{void *}p)} или @code{int draw(@code{mglGraph *}gr)}, или экземпляр класса, производного от @code{mglDraw}. Этот класс определен в @code{#include <mgl2/window.h>} и имеет только 2 метода:
+@verbatim
+class mglDraw
+{
+public:
+ virtual int Draw(mglGraph *) { return 0; };
+ virtual void Reload() {};
+};
+@end verbatim
+Вам следует наследовать свой класс от @code{mglDraw} и определить один или оба метода.
-@deftp {Class} Fl_MathGL
-Класс реализует элемент интерфейса FLTK для отображения графики MathGL. Класс определен в @code{#include <mgl2/fltk.h>}.
-@end deftp
+@menu
+* mglWindow class::
+* Fl_MathGL class::
+* QMathGL class::
+@end menu
-@float
-@image{fltk, 7cm}
-@caption{Пример окна FLTK с графикой MathGL.}
-@end float
-@deftp {Class} mglGraphQT
-Создает окно используя библиотеку Qt. Окно имеет панель инструментов и меню для упрощения действий с графиками. ``Присоединенный'' класс элемента интерфейса -- @code{QMathGL}. Класс определен в @code{#include <mgl2/mgl_qt.h>}.
-@end deftp
+@c ------------------------------------------------------------------
+@external
+@node mglWindow class, Fl_MathGL class, , Widget classes
+@section Класс mglWindow
+@cindex mglWindow
+@cindex window
+@c @cindex mglDraw
-@deftp {Class} QMathGL
-Класс реализует элемент интерфейса Qt для отображения графики MathGL. Класс определен в @code{#include <mgl2/qt.h>}.
-@end deftp
+Этот класс производный от класса mglGraph (см. @ref{MathGL core}). Он определен в @code{#include <mgl2/window.h>}. Класс содержит методы для создания и управления окном, содержащим графику MathGL.
-@float
-@image{qt, 7cm}
-@caption{Пример окна Qt с графикой MathGL.}
-@end float
+@deftypefn {Конструктор класса @code{mglWindow}} {} mglWindow (@code{const char *}title=@code{"MathGL"})
+@deftypefnx {Конструктор класса @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}, @code{void} (*reload)(@code{HMGL} gr, @code{void *}p)=0)
+@deftypefnx {Конструктор класса @code{mglWindow}} {} mglWindow (@code{int} (*draw)(@code{mglGraph *}gr), @code{const char *}title=@code{"MathGL"}, @code{int} kind=@code{0})
+@deftypefnx {Конструктор класса @code{mglWindow}} {} mglWindow (@code{mglDraw *}draw, @code{const char *}title=@code{"MathGL"}, @code{int} kind=@code{0})
+@deftypefnx {Функция С} @code{HMGL} mgl_create_graph_qt (@code{int} (*draw)(@code{HMGL} gr, @code{void *}p), @code{const char *}title, @code{void *}par, @code{void} (*reload)(@code{HMGL} gr, @code{void *}p))
+@deftypefnx {Функция С} @code{HMGL} mgl_create_graph_fltk (@code{int} (*draw)(@code{HMGL} gr, @code{void *}p), @code{const char *}title, @code{void *}par, @code{void} (*reload)(@code{HMGL} gr, @code{void *}p))
+@deftypefnx {Функция С} @code{HMGL} mgl_create_graph_glut (@code{int} (*draw)(@code{HMGL} gr, @code{void *}p), @code{const char *}title, @code{void *}par, @code{void} (*reload)(@code{HMGL} gr, @code{void *}p))
-@deftp {Class} mglGraphGLUT
-Создает окно используя библиотеку GLUT. Класс определен в @code{#include <mgl2/glut.h>}.
-@end deftp
+Создает окно для вывода графика. Параметр @var{draw} -- указатель (имя) функции рисования. Есть возможность создания нескольких кадров вначале (требует больше памяти) и их быстрая анимации в дальнейшем. В этом случае функция @var{draw} должна возвращать число кадров или ноль для рисования по запросу. Замечу, что @var{draw} может быть равна @code{NULL} для отображения статической (текущей) картинки. Параметр @var{title} задает заголовок окна. Параметр @var{par} содержит указатель на данные, передаваемые функции рисования @var{draw}. Параметр @var{kind} может иметь следующие значения: @samp{0} -- использовать окно FLTK, @samp{1} -- использовать окно Qt.
-@float
-@image{glut, 7cm}
-@caption{Пример окна GLUT с графикой MathGL.}
-@end float
+В окне просмотра можно использовать клавиши: 'a', 'd', 'w', 's' для вращения; ',', '.' для просмотра предыдущего и следующего кадров; 'r' для переключения прозрачности; 'f' для переключения оспещенности; 'x' для закрытия окна.
+@end deftypefn
-@menu
-* Fl_MathGL class::
-* QMathGL class::
-@end menu
+@deftypefn {Метод класса @code{mglWindow}} @code{int} RunThr ()
+@deftypefnx {Функция С} @code{int} mgl_fltk_thr ()
+Запускает цикл обработки сообщений в отдельном потоке. В данный момент работает только для окон FLTK.
+@end deftypefn
+
+@deftypefn {Метод класса @code{mglWindow}} @code{int} Run ()
+@deftypefnx {Функция С} @code{int} mgl_qt_run ()
+@deftypefnx {Функция С} @code{int} mgl_fltk_run ()
+Запускает цикл обработки сообщений. Обычно эта функция должна вызываться в отдельном потоке или последней функцией в @code{main()}.
+@end deftypefn
+
+@deftypefn {Метод класса @code{mglWindow}} @code{void} SetClickFunc (@code{void} (*func)(@code{HMGL} gr, @code{void *}p))
+@deftypefnx {Функция С} @code{void} mgl_set_click_func (@code{void} (*func)(@code{HMGL} gr, @code{void *}p))
+Устанавливает функцию, которая будет вызвана при щелчке мышью.
+@end deftypefn
+
+@deftypefn {Метод класса @code{mglWindow}} @code{void} ToggleAlpha ()
+@deftypefnx {Функция С} @code{int} mgl_wnd_toggle_alpha (@code{HMGL} gr)
+Включает/выключает прозрачность, но не перекрывает ее включение в пользовательской функции рисования.
+@end deftypefn
+@deftypefn {Метод класса @code{mglWindow}} @code{void} ToggleLight ()
+@deftypefnx {Функция С} @code{int} mgl_wnd_toggle_light (@code{HMGL} gr)
+Включает/выключает освещение, но не перекрывает его включение в пользовательской функции рисования.
+@end deftypefn
+@deftypefn {Метод класса @code{mglWindow}} @code{void} ToggleRotate ()
+@deftypefnx {Функция С} @code{int} mgl_wnd_toggle_rotate (@code{HMGL} gr)
+Включает/выключает вращение мышкой. Нажатая левая кнопка используется для вращения, средняя для сдвига, правая для приближения/перспективы.
+@end deftypefn
+@deftypefn {Метод класса @code{mglWindow}} @code{void} ToggleZoom ()
+@deftypefnx {Функция С} @code{int} mgl_wnd_toggle_zoom (@code{HMGL} gr)
+Включает/выключает приближение мышкой. Выделите прямоугольную область и она будет приближена.
+@end deftypefn
+@deftypefn {Метод класса @code{mglWindow}} @code{void} ToggleNo ()
+@deftypefnx {Функция С} @code{int} mgl_wnd_toggle_no (@code{HMGL} gr)
+Выключает вращение и приближение мышкой, а также восстанавливает исходный вид графика.
+@end deftypefn
+@deftypefn {Метод класса @code{mglWindow}} @code{void} Update ()
+@deftypefnx {Функция С} @code{int} mgl_wnd_update (@code{HMGL} gr)
+Обновляет содержимое окна. Функция полезна при ручном обновлении содержимого, пока долгий расчет идет в параллельном потоке.
+@end deftypefn
+@deftypefn {Метод класса @code{mglWindow}} @code{void} ReLoad ()
+@deftypefnx {Функция С} @code{int} mgl_wnd_reload (@code{HMGL} gr)
+Перегружает данные и обновляет рисунок. Функция также обновляет число кадров, которое создает функция рисования.
+@end deftypefn
+@deftypefn {Метод класса @code{mglWindow}} @code{void} Adjust ()
+@deftypefnx {Функция С} @code{int} mgl_wnd_adjust (@code{HMGL} gr)
+Подгоняет размер рисунка под размер окна.
+@end deftypefn
+@deftypefn {Метод класса @code{mglWindow}} @code{void} NextFrame ()
+@deftypefnx {Функция С} @code{int} mgl_wnd_next_frame (@code{HMGL} gr)
+Показывает следующий кадр, если он есть.
+@end deftypefn
+@deftypefn {Метод класса @code{mglWindow}} @code{void} PrevFrame ()
+@deftypefnx {Функция С} @code{int} mgl_wnd_prev_frame (@code{HMGL} gr)
+Показывает предыдущий кадр, если он есть.
+@end deftypefn
+@deftypefn {Метод класса @code{mglWindow}} @code{void} Animation ()
+@deftypefnx {Функция С} @code{int} mgl_wnd_animation (@code{HMGL} gr)
+Запускает/останавливает анимацию кадров.
+@end deftypefn
+
+@deftypefn {Метод класса @code{mglWindow}} @code{void} SetDelay (@code{mreal} dt)
+@deftypefnx {Функция С} @code{int} mgl_wnd_set_delay (@code{HMGL} gr, @code{int} dt)
+Задает задержку при анимации в секундах. По умолчанию интервал -- 1 секунда.
+@end deftypefn
+
+@deftypefn {Метод класса @code{mglWindow}} @code{void} Setup (@code{bool} clfupd=@code{true}, @code{bool} showpos=@code{false})
+@deftypefnx {Функция С} @code{int} mgl_setup_window (@code{HMGL} gr, @code{bool} clfupd, @code{bool} showpos)
+Включает/выключает:
+@itemize @bullet
+@item
+очистку рисунка перед Update();
+@item
+показ позиции щелчка мыши на рисунке.
+@end itemize
+@end deftypefn
+
+@deftypefn {Метод класса @code{mglWindow}} @code{mglPoint} LastMousePos ()
+@deftypefnx {Функция С} @code{int} mgl_get_last_mouse_pos (@code{HMGL} gr, @code{mreal *}x, @code{mreal *}y, @code{mreal *}z)
+Возвращает положение щелчка мыши.
+@end deftypefn
@c ------------------------------------------------------------------
+@external
@node Fl_MathGL class, QMathGL class, , Widget classes
@section Класс Fl_MathGL
@cindex Fl_MathGL
@cindex widgets
-Класс реализует элемент интерфейса FLTK для отображения графики MathGL (определен в @code{#include <mgl2/fltk.h>}).
+Класс реализует элемент интерфейса FLTK для отображения графики MathGL. Он определен в @code{#include <mgl2/fltk.h>}.
-@deftypemethod Fl_MathGL @code{void} set_draw (@code{mglDraw *}dr)
-Задает функцию рисования из класса производного от @code{mglDraw}.
+@fig{fltk, Пример окна FLTK с графикой MathGL.}
+
+@deftypemethod Fl_MathGL @code{void} set_draw (@code{int} (*draw)(@code{HMGL} gr, @code{void *}p))
+@deftypemethodx Fl_MathGL @code{void} set_draw (@code{int} (*draw)(@code{mglGraph *}gr))
+@deftypemethodx Fl_MathGL @code{void} set_draw (@code{mglDraw *}draw)
+Устанавливает функцию рисования как глобальную функцию или как функцию член класса, производного от @code{mglDraw}. Поддерживается список графиков (кадров), так что можно вначале их нарисовать (требует довольно много памяти), а потом достаточно быстро отображать. Функция должна возвращать положительное число создаваемых кадров или ноль для непосредственного рисования. Параметр @var{par} содержит указатель на данные пользователя, передаваемый функции рисования @var{draw}.
@end deftypemethod
-@deftypemethod Fl_MathGL @code{void} update (@code{mglGraph *}gr=@code{NULL})
-Обновляет (перерисовывает) график, используя экземпляр класса @var{gr} (по умолчанию встроенный).
+@deftypemethod Fl_MathGL @code{void} update ()
+Обновляет (перерисовывает) график.
@end deftypemethod
-@deftypemethod Fl_MathGL @code{void} set_angle (@code{float} t, @code{float} p)
+@deftypemethod Fl_MathGL @code{void} set_angle (@code{mreal} t, @code{mreal} p)
Задает углы для дополнительного вращения графика.
@end deftypemethod
-@deftypemethod Fl_MathGL @code{void} set_state (@code{int} f)
+@deftypemethod Fl_MathGL @code{void} set_flag (@code{int} f)
Задает битовые флаги для: 1 - прозрачности, 2 - освещения.
@end deftypemethod
@deftypemethod Fl_MathGL @code{void} set_state (@code{bool} z, @code{bool} r)
Задает флаги обработки движений мыши: @var{z}=@code{true} -- разрешает приближение выделения, @var{r}=@code{true} разрешает вращение/сдвиг/приближение/перспективу.
@end deftypemethod
-@deftypemethod Fl_MathGL @code{void} set_zoom (@code{float} X1, @code{float} Y1, @code{float} X2, @code{float} Y2)
+
+@deftypemethod Fl_MathGL @code{void} set_zoom (@code{mreal} X1, @code{mreal} Y1, @code{mreal} X2, @code{mreal} Y2)
Задает область приближения.
@end deftypemethod
-@deftypemethod Fl_MathGL @code{void} get_zoom (@code{float *}X1, @code{float *}Y1, @code{float *}X2, @code{float *}Y2)
+@deftypemethod Fl_MathGL @code{void} get_zoom (@code{mreal *}X1, @code{mreal *}Y1, @code{mreal *}X2, @code{mreal *}Y2)
Возвращает область приближения.
@end deftypemethod
+
@deftypemethod Fl_MathGL @code{void} set_popup (@code{const Fl_Menu_Item *}pmenu, @code{Fl_Widget *}w, @code{void *}v)
Задает указатель на всплывающее меню.
@end deftypemethod
+
+@deftypemethod Fl_MathGL @code{void} set_graph (@code{mglCanvas *}gr)
+@deftypemethodx Fl_MathGL @code{void} set_graph (@code{mglGraph *}gr)
+Задает экземпляр класс для рисования вместо встроеного. Fl_MathGL автоматически удалит его при удалении виджета и при новом вызове @code{set_graph()}.
+@end deftypemethod
@deftypemethod Fl_MathGL @code{mglGraph *} get_graph ()
-Ð\92озвÑ\80аÑ\89аеÑ\82 Ñ\83казаÑ\82елÑ\8c на клаÑ\81Ñ\81, строящий графики.
+Ð\92озвÑ\80аÑ\89аеÑ\82 Ñ\83казаÑ\82елÑ\8c на обÑ\8aекÑ\82, строящий графики.
@end deftypemethod
@deftypecv {Widget option} Fl_MathGL @code{Fl_Valuator *} tet_val
@deftypecv {Widget option} Fl_MathGL @code{Fl_Valuator *} phi_val
Указатель на внешний элемент управления для изменения угла phi.
@end deftypecv
-@deftypecv {Widget option} Fl_MathGL @code{mglGraphAB *} graph
-Указатель на экземпляр класса для построения графиков.
-@end deftypecv
-@deftypecv {Widget option} Fl_MathGL @code{void *} draw_par
-Параметр для функции рисования.
-@end deftypecv
-@deftypecv {Widget option} Fl_MathGL @code{int (*} draw_func @code{)(mglGraph *gr, void *par)}
-Указатель на функцию рисования.
-@end deftypecv
@c ------------------------------------------------------------------
+@external
@node QMathGL class, , Fl_MathGL class, Widget classes
-@section QMathGL class
+@section Класс QMathGL
@cindex QMathGL
@cindex widgets
-Класс реализует элемент интерфейса Qt для отображения графики MathGL (определен в @code{#include <mgl2/qt.h>}).
+Класс реализует элемент интерфейса Qt для отображения графики MathGL. Он определен в @code{#include <mgl2/qt.h>}.
+
+@fig{qt, Пример окна Qt с графикой MathGL.}
@deftypemethod QMathGL @code{void} setDraw (@code{mglDraw *}dr)
Задает функцию рисования из класса производного от @code{mglDraw}.
@end deftypemethod
-@deftypemethod QMathGL @code{void} setDraw (@code{int (*}draw)(@code{mglGraph *}gr, @code{void *}p), @code{void *}par=@code{NULL})
-Задает функцию рисования @var{draw} и укзатель @var{par} на параметр для нее.
+@deftypemethod QMathGL @code{void} setDraw (@code{int (*}draw)(@code{mglBase *}gr, @code{void *}p), @code{void *}par=@code{NULL})
+@deftypemethodx QMathGL @code{void} setDraw (@code{int (*}draw)(@code{mglGraph *}gr))
+Задает функцию рисования @var{draw}. Поддерживается список графиков (кадров), так что можно вначале их нарисовать (требует довольно много памяти), а потом достаточно быстро отображать. Функция должна возвращать положительное число создаваемых кадров или ноль для непосредственного рисования. Параметр @var{par} содержит указатель на данные пользователя, передаваемый функции рисования @var{draw}.
@end deftypemethod
-@deftypemethod QMathGL @code{void} setGraph (@code{mglGraphAB *}gr)
-Устанавливает указатель на внешний экземпляр класса для рисования (вместо встроенного @code{mglGraphZB}). Отмечу, что QMathGL автоматически удалит этот объект при удалении элемента интерфейса или при новом вызове @code{setGraph()}.
+@deftypemethod QMathGL @code{void} setGraph (@code{mglCanvas *}gr)
+@deftypemethodx QMathGL @code{void} setGraph (@code{mglGraph *}gr)
+Устанавливает указатель на внешний экземпляр класса для рисования (вместо встроенного). Отмечу, что QMathGL автоматически удалит этот объект при удалении элемента интерфейса или при новом вызове @code{setGraph()}.
+@end deftypemethod
+@deftypemethod QMathGL @code{HMGL} getGraph ()
+Возвращает указатель на объект, строящий графики.
@end deftypemethod
@deftypemethod QMathGL @code{void} setPopup (@code{QMenu *}p)
Возвращает состояние переключателя вращения мышью.
@end deftypemethod
-@defop Slot QMathGL @code{void} refresh ()
+
+@deftypefn {Slot on @code{QMathGL}} @code{void} refresh ()
Перерисовывает (обновляет) элемент управления без вызова функции рисования.
-@end defop
-@defop Slot QMathGL @code{void} update (@code{mglGraph *}gr=@code{NULL})
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} update ()
Обновляет рисунок путем вызова функции рисования.
-@end defop
-@defop Slot QMathGL @code{void} copy ()
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} copy ()
Копирует график в буфер обмена.
-@end defop
-@defop Slot QMathGL @code{void} setPer (@code{int} val)
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} copyClickCoor ()
+Копирует координаты щелчка мышью (как текст).
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} print ()
+Печатает текущий рисунок.
+@end deftypefn
+
+@deftypefn {Slot on @code{QMathGL}} @code{void} stop ()
+Посылает сигнал остановки рисования.
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} adjust ()
+Подгоняет размер картинки под размер окна.
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} nextSlide ()
+Показывает следующий кадр.
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} prevSlide ()
+Показывает предыдущий кадр.
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} animation (@code{bool} st=@code{true})
+Запускает анимацию.
+@end deftypefn
+
+@deftypefn {Slot on @code{QMathGL}} @code{void} setPer (@code{int} val)
Задает величину перспективы.
-@end defop
-@defop Slot QMathGL @code{void} setPhi (@code{int} val)
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} setPhi (@code{int} val)
Задает величину угла Phi.
-@end defop
-@defop Slot QMathGL @code{void} setTet (@code{int} val)
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} setTet (@code{int} val)
Задает величину угла Theta.
-@end defop
-@defop Slot QMathGL @code{void} setAlpha (@code{bool} val)
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} setAlpha (@code{bool} val)
Включает/выключает прозрачность.
-@end defop
-@defop Slot QMathGL @code{void} setLight (@code{bool} val)
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} setLight (@code{bool} val)
Включает/выключает освещение.
-@end defop
-@defop Slot QMathGL @code{void} setZoom (@code{bool} val)
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} setGrid (@code{bool} val)
+Включает/выключает рисование сетки абсолютных координат на графике.
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} setZoom (@code{bool} val)
Включает/выключает приближение мышью.
-@end defop
-@defop Slot QMathGL @code{void} setRotate (@code{bool} val)
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} setRotate (@code{bool} val)
Включает/выключает вращение мышью.
-@end defop
-@defop Slot QMathGL @code{void} zoomIn ()
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} zoomIn ()
Приблиажет график.
-@end defop
-@defop Slot QMathGL @code{void} zoomOut ()
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} zoomOut ()
Отдаляет график.
-@end defop
-@defop Slot QMathGL @code{void} restore ()
-Восстанавливает приближение и поворот графика в значения по умолчанию.
-@end defop
-@defop Slot QMathGL @code{void} reload ()
-Обновляет данные и перерисовывает график.
-@end defop
-@defop Slot QMathGL @code{void} shiftLeft ()
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} shiftLeft ()
Сдвигает график влево.
-@end defop
-@defop Slot QMathGL @code{void} shiftRight ()
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} shiftRight ()
Сдвигает график вправо.
-@end defop
-@defop Slot QMathGL @code{void}shiftUp ()
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void}shiftUp ()
Сдвигает график вверх.
-@end defop
-@defop Slot QMathGL @code{void} shiftDown ()
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} shiftDown ()
Сдвигает график вниз.
-@end defop
-@defop Slot QMathGL @code{void} exportPNG (@code{QString} fname=@code{""})
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} restore ()
+Восстанавливает приближение и поворот графика в значения по умолчанию.
+@end deftypefn
+@c @deftypefn {Slot on @code{QMathGL}} @code{void} reload ()
+@c Обновляет данные и перерисовывает график.
+@c @end deftypefn
+
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportPNG (@code{QString} fname=@code{""})
Сохраняет текущий рисунок в PNG файл.
-@end defop
-@defop Slot QMathGL @code{void} exportPNGs (@code{QString} fname=@code{""})
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportPNGs (@code{QString} fname=@code{""})
Сохраняет текущий рисунок в PNG файл без прозрачности.
-@end defop
-@defop Slot QMathGL @code{void} exportJPG (@code{QString} fname=@code{""})
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportJPG (@code{QString} fname=@code{""})
Сохраняет текущий рисунок в JPEG файл.
-@end defop
-@defop Slot QMathGL @code{void} exportBPS (@code{QString} fname=@code{""})
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportBPS (@code{QString} fname=@code{""})
Сохраняет текущий рисунок в растровый EPS файл.
-Export current picture to bitmap EPS file.
-@end defop
-@defop Slot QMathGL @code{void} exportEPS (@code{QString} fname=@code{""})
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportEPS (@code{QString} fname=@code{""})
Сохраняет текущий рисунок в векторный EPS файл.
-@end defop
-@defop Slot QMathGL @code{void} exportSVG (@code{QString} fname=@code{""})
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportSVG (@code{QString} fname=@code{""})
Сохраняет текущий рисунок в векторный SVG файл.
-@end defop
-@defop Slot QMathGL @code{void} exportIDTF (@code{QString} fname=@code{""})
-Сохраняет текущий рисунок в IDTF файл.
-@end defop
-@defop Slot QMathGL @code{void} setMGLFont (@code{QString} path)
+@end deftypefn
+
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportGIF (@code{QString} fname=@code{""})
+Сохраняет текущий рисунок в GIF файл.
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportTEX (@code{QString} fname=@code{""})
+Сохраняет текущий рисунок в векторный LaTeX/Tikz файл.
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportTGA (@code{QString} fname=@code{""})
+Сохраняет текущий рисунок в TGA файл.
+@end deftypefn
+
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportXYZ (@code{QString} fname=@code{""})
+Сохраняет текущий рисунок в векторный XYZ/XYZL/XYZF файл.
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportOBJ (@code{QString} fname=@code{""})
+Сохраняет текущий рисунок в векторный OBJ/MTL файл.
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportSTL (@code{QString} fname=@code{""})
+Сохраняет текущий рисунок в векторный STL файл.
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportOFF (@code{QString} fname=@code{""})
+Сохраняет текущий рисунок в векторный OFF файл.
+@end deftypefn
+@c @deftypefn {Slot on @code{QMathGL}} @code{void} exportX3D (@code{QString} fname=@code{""})
+@c Сохраняет текущий рисунок в векторный X3D файл.
+@c @end deftypefn
+
+@deftypefn {Slot on @code{QMathGL}} @code{void} exportIDTF (@code{QString} fname=@code{""})
+Сохраняет текущий рисунок в векторный IDTF файл.
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} setMGLFont (@code{QString} path)
Восстанавливает (@var{path}=@code{""}) или загружает файлы шрифтов.
-@end defop
-@defop Slot QMathGL @code{void} print ()
-Печатает текущий рисунок.
-@end defop
-@defop Slot QMathGL @code{void} adjust ()
-Подгоняет размер картинки под размер окна. Функция выполняется только если graph -- экземпляр класса mglGraphQT.
-@end defop
-@defop Slot QMathGL @code{void} nextSlide ()
-Показывает следующий кадр. Функция выполняется только если graph -- экземпляр класса mglGraphQT.
-@end defop
-@defop Slot QMathGL @code{void} prevSlide ()
-Показывает предыдущий кадр. Функция выполняется только если graph -- экземпляр класса mglGraphQT.
-@end defop
-@defop Slot QMathGL @code{void} animation (@code{bool} st=@code{true})
-Запускает анимацию. Функция выполняется только если graph -- экземпляр класса mglGraphQT.
-@end defop
-@defop Slot QMathGL @code{void} about ()
+@end deftypefn
+
+@deftypefn {Slot on @code{QMathGL}} @code{void} about ()
Показывает информацию о программе.
-@end defop
-@defop Slot QMathGL @code{void} aboutQt ()
+@end deftypefn
+@deftypefn {Slot on @code{QMathGL}} @code{void} aboutQt ()
Показывает информацию о версии Qt.
-@end defop
+@end deftypefn
-@defop Signal QMathGL @code{void} phiChanged (@code{int} val)
+@deftypefn {Signal on @code{QMathGL}} @code{void} phiChanged (@code{int} val)
Угол Phi изменен.
-@end defop
-@defop Signal QMathGL @code{void} tetChanged (@code{int} val)
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} tetChanged (@code{int} val)
Угол Tet изменен.
-@end defop
-@defop Signal QMathGL @code{void} perChanged (@code{int} val)
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} perChanged (@code{int} val)
Перспектива изменена.
-@end defop
-@defop Signal QMathGL @code{void} alphaChanged (@code{bool} val)
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} alphaChanged (@code{bool} val)
Прозрачность изменена.
-@end defop
-@defop Signal QMathGL @code{void} lightChanged (@code{bool} val)
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} lightChanged (@code{bool} val)
Освещение изменено.
-@end defop
-@defop Signal QMathGL @code{void} zoomChanged (@code{bool} val)
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} gridChanged (@code{bool} val)
+Рисование сетки изменено.
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} zoomChanged (@code{bool} val)
Режим приближения мышью изменен.
-@end defop
-@defop Signal QMathGL @code{void} rotateChanged (@code{bool} val)
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} rotateChanged (@code{bool} val)
Режим вращения мышью изменен.
-@end defop
+@end deftypefn
+
+@deftypefn {Signal on @code{QMathGL}} @code{void} mouseClick (@code{mreal} x, @code{mreal} y, @code{mreal} z)
+Был щелчок мышью в точке @{x,y,z@}.
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} frameChanged (@code{int} val)
+Требуется новый кадр для отображения.
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} showWarn (@code{QString} warn)
+Есть предупреждения.
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} posChanged (@code{QString} pos)
+Положение щелчка мышью изменилось.
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} objChanged (@code{int} id)
+Изменился id объекта на графике (из-за щелчка мышью).
+@end deftypefn
+@deftypefn {Signal on @code{QMathGL}} @code{void} refreshData ()
+Данные могли измениться (рисование завершено).
+@end deftypefn
-@deftypecv {Widget option} QMathGL @code{QString} appName
+
+@deftypecv {QMathGL option} QMathGL @code{QString} appName
Имя приложения для окон сообщений.
@end deftypecv
-@deftypecv {Widget option} QMathGL @code{bool} autoResize
+@deftypecv {QMathGL option} QMathGL @code{bool} autoResize
Разрешить изменять размер рисунка (по умолчанию false).
@end deftypecv
-@deftypecv {Widget option} QMathGL @code{int} animDelay
-Задержка анимации в мсек.
-@end deftypecv
+@external
--- /dev/null
+http://ubuntuforums.org/showthread.php?t=1862084
+Device 0 (VID=0502 and PID=337d) is UNKNOWN.
+
+============= NEW =============
+
+0. Check RunThr() in python/octave
+
+2. Use Hershey as built-in font ?!!
+3. Import/Export via GIF (as 3d data) ???
+4. Read DICOM files ???
+5. Export to JavaScript (WebGL)
+6. GTK and WX window/widgets
+7. Labels at TriCont()
+
+9. Save primitives for frames (not bitmap) ??? -- see MGL_USEDRWDAT
+10. Enable several fonts at the same picture
+11. Table(mreal x, mreal y, HCDT dat, char *xlabels, char *ylabels, char *stl) -- draw table with values (+ auto reduce font size?)
+
+12. Parallelization of drawing (MathGL level) -- bug with primitives drawing --> pixel.cpp
+14. Axis -- projection (ternary + quaternary)
+15. Examples of animation, u3d, x3d, js and so on
+
+17. curved text (in new sample) look not so good
+18. emulate fog in EPS/SVG
+
+20. Add mglDataC for complex data -- main diff is reading/saving data
+21. MGL testing system ???
+22. Export to X3D
+23. Try libtcc (TinyCC) as alternative to MGL -- in mgllab???
+24. Use OI & Z for determining {x,y,z} from {xs,ys}. Try to find closest.
+25. More accurate intersections in Region
+26. Add flag for drawing 3d arrows instead of 2d (S,D -- cube, T -- sq.pyramid, I -- square, O -- sphere???, A,K,V -- ???)
+
+28. Add extra texture in Error -- for handling transparency of "marks" ???
+29. Textual colors, like "{0xFF00FF}" ?!?
+30. Auto axis range for formulas, like AutoRange("y(x)") or AutoRange('x',"x(t)").
+31. Add Vect3 for vectors on slice
+
+33. Check feature:
+* dash for rect, ellipse boundary
+
+34. Hotkeys
+35. Check disabling completer in UDAV
+36. Add line numbers in editor.
+
+37. Center ticks labels + check gap for axis labels (at axis rotation)
+
+============= DOCS =============
+
+0. Option sample (_mirror)
+1. Add back-references from samples
+
+2. Text about UDAV
+3. Add FAQ about MPEG/GIF and PDF
+
+============= UDAV =============
+
+01. Dialog for data input
+-----------------------------------------------
+| [Data name |V|] |
+| [x1] [x2] [func] {ADD} |
+| [y1] [y2] [suf|V] {ADD} |
+| [z1] [z2] [oper|V] [dir] {ADD} |
+| Reuslt [ ] |
+| {Cancel} {OK} |
+-----------------------------------------------
+Ranges can be inverted.
+Remove other setting if data name is changed.
+
+02. Double click -> jump to string + setup dialog (optionally)
+03. Dialog for InPlot(s):
+{SubPlot,MultiPlot} -- enable rotate,aspect,title
+{ColumnPlot} -- enable rotate,several
+{StickPlot} -- enable several
+{InPlot} -- enable rotate,aspect,title
+
+04. Group/ungroup if command in single line, separated by ':'
+05. Hide plot/group by putting "#h " at beginning of line
+06. Annotation of plot/group -- comment before it
+09. Data change via menu/toolbar -- save to internal script => enable undo + save initial array(?)
+10. Add primitives by mouse at beginning of script + change its size/position by mouse + "attraction" points
+11. Drag&drop plot/group between inplots
+12. Create default plot dependently of selected row/column/range in data table
+13. Show plot at creation stage (if option is enabled -- can be size_t process!!!)
+14. Rotate/perspective/lighting/... of primitive list (without script re-execution)
+
+15. QTreeWidgetItem -- ICON (if,for,once,subplot,...); Cmd text; LINE - POS in group/line. After editing/changing --> put text to editor.
+
+17. Setupable hot-keys ?!?
+18. Insert just filename (without path) by demand
+
+============= UNSURE ===========
+
+1. Problem with \calB and so on (\calH, ...) -- they are present only in italic font :(.
+2. create PWT fonts
+3. \dfrac for normal size and centering (sample \big\big{\frac{1}{2}}) ???
+4. "Cut off" curves if text is printed inside it (for contour labels) ?!?
+5. String variables in MGL + readstr command.
+6. Pool of threads for speeding up ???
+7. Drops as mglPrim -- not accurate but smaller memory and faster
+8. Text aspect ratio in OpenGL mode
set(udav_rc udav.qrc)
+if(WIN32)
+ set(udav_src ${udav_src} udav.rc)
+endif(WIN32)
+
if(MGL_HAVE_GSL)
# target_link_libraries(mgl ${GSL_LIB} ${GSL_CBLAS_LIB} )
include_directories(${GSL_INCLUDE_DIR})
TARGETS udav
RUNTIME DESTINATION bin
)
+install(FILES UDAV.desktop DESTINATION ${CMAKE_INSTALL_PREFIX}/share/applications/)
+install(FILES udav.png DESTINATION ${CMAKE_INSTALL_PREFIX}/share/pixmaps/)
+#install(FILES udav_ru.qm DESTINATION ${CMAKE_INSTALL_PREFIX}/share/udav/)
endif(MGL_HAVE_QT)
--- /dev/null
+[Desktop Entry]
+Encoding=UTF-8
+Version=1.0
+Type=Application
+Terminal=false
+Icon=udav.png
+Name=UDAV
+Exec=udav
+Comment=Data handling and plotting tool
+Comment[en_US]=Data handling and plotting tool
+Comment[ru_RU]=Обработка и отображение данных
+Categories=Education;Science;Math;
{\r
res = "";\r
QString s;\r
- float x, x2=p2->text().toDouble(), dx=dp->text().toDouble();\r
+ double x, x2=p2->text().toDouble(), dx=dp->text().toDouble();\r
for(x=p1->text().toDouble();x<x2;x+=dx)\r
res = res+QString::number(x,'g',4)+"\n";\r
accept();\r
#include "xpm/table.xpm"
//-----------------------------------------------------------------------------
extern mglParser parser;
-class MainWindow;
void updateDataItems();
-void addDataPanel(MainWindow *wnd, QWidget *w, QString name);
+void addDataPanel(QWidget *wnd, QWidget *w, QString name);
void deleteDat(void *o) { if(o) delete ((DatPanel *)o); }
void refreshData(QWidget *w) { ((DatPanel *)w)->refresh(); }
//-----------------------------------------------------------------------------
-QWidget *newDataWnd(InfoDialog *inf, MainWindow *wnd, mglVar *v)
+QWidget *newDataWnd(InfoDialog *inf, QWidget *wnd, mglVar *v)
{
DatPanel *t = new DatPanel(inf);
if(v) t->setVar(v);
if(ny!=var->d.ny) { ny = var->d.ny; tab->setRowCount(ny); rc=true; }
if(kz>=var->d.nz) { kz = 0; emit sliceChanged(0); }
if(nz!=var->d.ny) { nz = var->d.nz; emit nzChanged(nz); }
- id = QString(var->d.id);
+ id = QString(var->d.id.c_str());
if(nz==1 && ny>1 && !id.isEmpty())
{
QStringList head;
tab->setHorizontalHeaderLabels(head);
}
register long i,j,m=var->s.length();
- register float f;
+ register mreal f;
QString s,d;
if(rc)
{
{
if(!var || r<0 || c<0 || r>=ny || c>=nx || !ready) return;
QString s = tab->item(r,c)->text().toLower();
- float f;
+ mreal f;
f = s=="nan" ? NAN : s.toDouble();
if(f!=var->d.GetVal(c,r,kz))
{
void raisePanel(QWidget *w);
//-----------------------------------------------------------------------------
QWidget *createHlpPanel(QWidget *p) { return new HelpPanel(p); }
-void showHelpMGL(QWidget *hlp,QString s){ ((HelpPanel *)hlp)->showHelp(s); }
+void showHelpMGL(QWidget *p,QString s)
+{
+ HelpPanel *hlp = dynamic_cast<HelpPanel *>(p);
+ if(hlp) hlp->showHelp(s);
+}
//void showExMGL(QWidget *hlp) { ((HelpPanel *)hlp)->showExamples(); }
//-----------------------------------------------------------------------------
HelpPanel::HelpPanel(QWidget *parent) : QWidget(parent)
}
//-----------------------------------------------------------------------------
void udavShowHint(QWidget *p)
-{
- HintDialog *hd = new HintDialog(p);
- hd->exec();
-}
+{ HintDialog *hd = new HintDialog(p); hd->exec(); }
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
extern bool mglAutoSave;
extern mglParser parser;
-QWidget *newDataWnd(InfoDialog *inf, MainWindow *wnd, mglVar *v);
+QWidget *newDataWnd(InfoDialog *inf, QWidget *wnd, mglVar *v);
void refreshData(QWidget *w);
//-----------------------------------------------------------------------------
QWidget *createMemPanel(QWidget *p) // NOTE: parent should be MainWindow
{
MemPanel *m = new MemPanel(p);
- m->wnd = (MainWindow *)p;
+ m->wnd = p; return m;
}
//-----------------------------------------------------------------------------
void refreshMemPanel(QWidget *p)
it = new QTableWidgetItem(s);
tab->setItem(n,1,it); it->setFlags(flags);
it->setTextAlignment(Qt::AlignHCenter|Qt::AlignVCenter);
- s.sprintf("%12ld", v->d.nx*v->d.ny*v->d.nz*sizeof(float));
+ s.sprintf("%12ld", v->d.nx*v->d.ny*v->d.nz*sizeof(mreal));
it = new QTableWidgetItem(s);
tab->setItem(n,2,it); it->setFlags(flags);
it->setTextAlignment(Qt::AlignRight|Qt::AlignVCenter);
class mglVar;
class InfoDialog;
class QTableWidget;
-class MainWindow;
//-----------------------------------------------------------------------------
class MemPanel : public QWidget
{
Q_OBJECT
public:
- MainWindow *wnd;
+ QWidget *wnd;
MemPanel(QWidget *parent = 0);
public slots:
void refresh(); ///< refresh list of variables
{
if(mglAutoSave) save();
raisePanel(this);
+ emit clearWarn();
QTime t; t.start();
draw->text=textMGL->toPlainText();
draw->line=curPos; mgl->update();
oo->addAction(tr("vector EPS"), mgl, SLOT(exportEPS()),Qt::META+Qt::Key_E);
oo->addAction(tr("SVG"), mgl, SLOT(exportSVG()),Qt::META+Qt::Key_S);
// oo->addAction(tr("C++"), mgl, SLOT(exportCPP())); // TODO: Add later
- oo->addAction(tr("IDTF"), mgl, SLOT(exportIDTF()));
+// oo->addAction(tr("IDTF"), mgl, SLOT(exportIDTF()));
o->addMenu(oo);
popup->addMenu(oo);
}
void setStatus(const QString &);
void animSwitch(bool);
void giveFocus();
+ void clearWarn();
private slots:
void animText(const QString &);
case 3: nx=dims[2]; ny=dims[1]; nz=dims[0]; break;
}
v->d.Create(nx, ny, nz);
+#if MGL_USE_DOUBLE
+ H5Dread(hd, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, v->d.a);
+#else
H5Dread(hd, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, v->d.a);
+#endif
}
}
H5Dclose(hd); H5Sclose(hs); H5Tclose(ht);
//-----------------------------------------------------------------------------
void TextEdit::setCompleter(QCompleter *completer)
{
+ if(!completer) return;
if(c) QObject::disconnect(c, 0, this, 0);
- c = completer; if(!c) return;
+ c = completer;
c->setWidget(this);
c->setCompletionMode(QCompleter::PopupCompletion);
c->setCaseSensitivity(Qt::CaseInsensitive);
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
+#ifdef WIN32
+#include <io.h>
+#include <direct.h>
+#else
#include <unistd.h>
+#endif
#include <QUrl>
#include <QFile>
#include <QMenuBar>
#include <QTextCodec>
#include <QTranslator>
//-----------------------------------------------------------------------------
+#if !defined(WIN32) && !defined(__APPLE__)
+#include <X11/Xlib.h>
+#endif
+//-----------------------------------------------------------------------------
#include "mgl2/parser.h"
#include "mgl2/qt.h"
#include "udav_wnd.h"
QWidget *createMemPanel(QWidget *p);
QWidget *createHlpPanel(QWidget *p);
void showHelpMGL(QWidget *hlp, QString s);
-void addDataPanel(MainWindow *wnd, QWidget *w, QString name) { wnd->addPanel(w, name); }
+void addDataPanel(QWidget *p, QWidget *w, QString name)
+{
+ MainWindow *wnd = dynamic_cast<MainWindow *>(p);
+ if(wnd) wnd->addPanel(w, name);
+}
//-----------------------------------------------------------------------------
#ifndef UDAV_DIR
#ifdef WIN32
//-----------------------------------------------------------------------------
int main(int argc, char **argv)
{
+// QCoreApplication::setAttribute(Qt::AA_X11InitThreads);
+#if !defined(WIN32) && !defined(__APPLE__)
+ // try to fix possible multi-threading errors
+ // must be placed before ANY window creation
+ XInitThreads();
+#endif
mgl_ask_func = mgl_ask_qt;
QApplication a(argc, argv);
QTranslator translator;
edit = new TextPanel(this); edit->graph = graph;
graph->textMGL = edit->edit;
connect(graph->mgl,SIGNAL(showWarn(QString)),mess,SLOT(setText(QString)));
+ connect(graph,SIGNAL(clearWarn()),mess,SLOT(clear()));
ltab->addTab(edit,QPixmap(":/xpm/text-x-generic.png"),tr("Script"));
calcWnd->setWidget(createCalcDlg(this, edit->edit));
int mgl_cmd_cmp(const void *a, const void *b);
void MainWindow::editPosChanged()
{
- register int i, n, m;
+ register int i, n;
QString text = edit->selection(), dlm(" #;:\t");
n = text.length();
for(i=0;i<n;i++) if(dlm.contains(text[i])) break;
- text.truncate(i); m = text.length();
+ text.truncate(i);
for(n=0;parser.Cmd[n].name[0];n++){}; // determine the number of symbols in parser
mglCommand tst, *rts; tst.name = text.toAscii().data();
* Free Software Foundation, Inc., *\r
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
***************************************************************************/\r
-#include <stdio.h>\r
-#include <string.h>\r
#include <locale.h>\r
#include <unistd.h>\r
#include "mgl2/mgl.h"\r
mglParse p(true);\r
char ch, buf[2048], iname[256]="", oname[256]="";\r
std::vector<std::wstring> var;\r
- \r
- register long i,n;\r
+\r
+ register size_t i, n;\r
while(1)\r
{\r
ch = getopt(argc, argv, "1:2:3:4:5:6:7:8:9:ho:L:C:A:");\r
n = str.find(L"##c ");\r
if(n!=std::string::npos)\r
{\r
- float v1,v2,dv,v;\r
- wscanf(str.c_str()+n+4,L"%g%g%g",&v1,&v2,&dv);\r
+ double v1,v2,dv,v;\r
+ wscanf(str.c_str()+n+4,L"%lg%lg%lg",&v1,&v2,&dv);\r
wchar_t ss[64];\r
for(v=v1;v<=v2;v+=dv)\r
{ mglprintf(ss,64,L"%g",v); var.push_back(ss); }\r
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
-#include <stdio.h>
-#include <string.h>
#include <locale.h>
#include <unistd.h>
#include "mgl2/window.h"
}
if(ch=='h') return 0;
- long i;
mgl_ask_func = mgl_ask_gets;
#if MGL_HAVE_QT
int kind=1; mgl_ask_func = mgl_ask_qt;
#include <FL/Fl_Double_Window.H>
#include <FL/fl_draw.H>
#include <FL/Fl_File_Chooser.H>
-#include <unistd.h>
-#include <wchar.h>
+//#include <unistd.h>
//-----------------------------------------------------------------------------
#ifdef USE_GETTEXT
#include <libintl.h>
void mgl_ask_fltk(const wchar_t *quest, wchar_t *res)
{
static char buf[1024];
+#if FL_MINOR_VERSION>=3
fl_utf8fromwc(buf, 1024, quest, wcslen(quest)+1);
const char *str = fl_input(buf,"");
fl_utf8towc(str, strlen(str)+1, res, 1024);
+#else
+ wcstombs(buf,quest,wcslen(quest)+1);
+ const char *str = fl_input(buf,"");
+ mbstowcs(res,str, strlen(str)+1);
+#endif
}
//-----------------------------------------------------------------------------
//
zoom = rotate = false;
flag=x0=y0=xe=ye=0;
tet_val = phi_val = 0;
- draw_par = 0; draw_func = 0;
+ draw_par = 0; draw_func = 0; draw_cl = 0;
}
//-----------------------------------------------------------------------------
Fl_MathGL::~Fl_MathGL() {}
//-----------------------------------------------------------------------------
void Fl_MathGL::update()
{
- if(draw_func)
+ if(draw_func || draw_cl)
{
if(gr->get(MGL_CLF_ON_UPD)) gr->DefaultPlotParam();
gr->ResetFrames();
if(tet_val) tet = tet_val->value();
if(phi_val) phi = phi_val->value();
gr->Zoom(x1,y1,x2,y2); gr->View(phi,tet);
- draw_func(gr, draw_par); // drawing itself
+ if(draw_func) draw_func(gr, draw_par); // drawing itself
+ else if(draw_cl) { mglGraph g(gr); draw_cl->Draw(&g); }
const char *buf = gr->Mess.c_str();
if(*buf) fl_message("%s",buf);
}
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
+mreal 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)
{
#include <OpenGL/gl.h>\r
#include <GLUT/glut.h>\r
#else\r
- #ifdef _MSC_VER\r
+ #if defined(_MSC_VER) || defined(__BORLANDC__)\r
#include <windows.h>\r
#include <GL/gl.h>\r
#include "glut.h"\r
#endif\r
#endif\r
\r
-#include <math.h>\r
-#include <string.h>\r
-#include <stdio.h>\r
-#include <stdlib.h>\r
-\r
#include "mgl2/glut.h"\r
\r
mglCanvasGLUT *_mgl_glwnd;\r
//-----------------------------------------------------------------------------\r
mglCanvasGLUT::~mglCanvasGLUT() { _mgl_glwnd = 0; }\r
//-----------------------------------------------------------------------------\r
-void mglCanvasGLUT::Window(int argc, char **argv,int (*draw)(mglBase *gr, void *p),const char *title, void *par, void (*reload)(void *p), bool maximize)\r
+void mglCanvasGLUT::Window(int argc, char **argv,int (*draw)(mglBase *gr, void *p),const char *title, void *par, void (*reload)(void *p), bool /*maximize*/)\r
{\r
NumFig=0; curr_fig=1; tt=0;\r
_mgl_glwnd = this;\r
#include <QPrintDialog>
#include <QFileDialog>
#include <QInputDialog>
-#include <stdio.h>
#include "mgl2/qt.h"
//-----------------------------------------------------------------------------
#if !defined(WIN32) && !defined(__APPLE__)
if(!isHidden()) QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
setlocale(LC_NUMERIC, "C"); // NOTE: I'm not sure what I should selocale manually???
if(draw_func) draw_func(gr, draw_par);
- else { mglGraph g(gr); draw->Draw(&g); }
+ else if(draw) { mglGraph g(gr); draw->Draw(&g); }
setlocale(LC_NUMERIC, "");
if(!isHidden()) QApplication::restoreOverrideCursor();
emit refreshData();
- QString buf = gr->Mess.c_str();
- emit showWarn(buf);
+ emit showWarn(gr->Mess.c_str());
mousePos="";
}
refresh();
oo->addAction(TR("LaTeX"), QMGL, SLOT(exportTEX()));
o->addMenu(oo); popup->addMenu(oo);
oo = new QMenu(TR("&Export as 3D ..."),Wnd);
- oo->addAction(TR("X3D"), QMGL, SLOT(exportX3D()));
+// oo->addAction(TR("X3D"), QMGL, SLOT(exportX3D()));
oo->addAction(TR("XYZ"), QMGL, SLOT(exportXYZ()));
oo->addAction(TR("OBJ"), QMGL, SLOT(exportOBJ()));
oo->addAction(TR("STL"), QMGL, SLOT(exportSTL()));
- oo->addAction(TR("IDTF"), QMGL, SLOT(exportIDTF()));
+// oo->addAction(TR("IDTF"), QMGL, SLOT(exportIDTF()));
o->addMenu(oo); popup->addMenu(oo);
o->addSeparator();
o = Wnd->menuBar()->addMenu(TR("&Help"));
o->addAction(TR("About"), QMGL, SLOT(about()));
o->addAction(TR("About &Qt"), QMGL, SLOT(aboutQt()));
+ return popup;
}
//-----------------------------------------------------------------------------
HMGL mgl_create_graph_qt(int (*draw)(HMGL gr, void *p), const char *title, void *par, void (*load)(void *p))
//-----------------------------------------------------------------------------\r
mglCanvasWnd::mglCanvasWnd() : mglCanvas()\r
{\r
- Setup(); LoadFunc=0; FuncPar=0; DrawFunc=0;\r
+ Setup(); LoadFunc=0; FuncPar=0; DrawFunc=0; ClickFunc=0;\r
GG = 0; NumFig = 0; CurFig = -1;\r
// set(MGL_USEDRWDAT); // TODO: experimental feature -- test later\r
}\r
{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->Setup(clf_upd, showpos); }\r
void mgl_set_click_func(HMGL gr, void (*func)(void *p))\r
{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr); if(g) g->ClickFunc = func; }\r
+void mgl_get_last_mouse_pos(HMGL gr, mreal *x, mreal *y, mreal *z)\r
+{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>(gr);\r
+ mglPoint p; if(g) p=g->GetMousePos();\r
+ *x=p.x; *y=p.y; *z=p.z; }\r
//-----------------------------------------------------------------------------\r
void mgl_wnd_toggle_alpha_(uintptr_t *gr)\r
{ mglCanvasWnd *g = dynamic_cast<mglCanvasWnd *>((HMGL)(*gr));\r
void mgl_setup_window_(uintptr_t *gr, int *clf_upd, int *showpos)\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
+void mgl_get_last_mouse_pos_(uintptr_t *gr, mreal *x, mreal *y, mreal *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
+ mglPoint p; if(g) p=g->GetMousePos();\r
*x=p.x; *y=p.y; *z=p.z; }\r
//-----------------------------------------------------------------------------\r
#if MGL_HAVE_FLTK==0\r
// mglDraw class handling\r
//\r
//-----------------------------------------------------------------------------\r
-int mgl_draw_class(mglBase *gr, void *p) // so stupid way to save mglDraw class inheritance :(\r
+int mgl_draw_class(HMGL gr, void *p) // so stupid way to save mglDraw class inheritance :(\r
{\r
mglGraph g(gr); mglWindow *w = (mglWindow *)p;\r
return (w && w->dr) ? w->dr->Draw(&g) : 0;\r
void mgl_click_class(void *p) // so stupid way to save mglDraw class inheritance :(\r
{ mglWindow *w = (mglWindow *)p; if(w && w->dr) w->dr->Click(); }\r
//-----------------------------------------------------------------------------\r
-int mgl_draw_graph(mglBase *gr, void *p)\r
+typedef int (*draw_func)(mglGraph *gr);\r
+int mgl_draw_graph(HMGL gr, void *p)\r
{\r
mglGraph g(gr);\r
draw_func func = (draw_func)(p);\r
projects / mathgl.git / commitdiff