diff --git a/3rdparty/ippicv/downloader.cmake b/3rdparty/ippicv/downloader.cmake index 3715214468..f25e5cc704 100644 --- a/3rdparty/ippicv/downloader.cmake +++ b/3rdparty/ippicv/downloader.cmake @@ -8,21 +8,21 @@ function(_icv_downloader) # Define actual ICV versions if(APPLE) - set(OPENCV_ICV_PACKAGE_NAME "ippicv_macosx_20140429.tgz") - set(OPENCV_ICV_PACKAGE_HASH "f2195a60829899983acd4a45794e1717") + set(OPENCV_ICV_PACKAGE_NAME "ippicv_macosx_20141027.tgz") + set(OPENCV_ICV_PACKAGE_HASH "9662fe0694a67e59491a0dcc82fa26e0") set(OPENCV_ICV_PLATFORM "macosx") set(OPENCV_ICV_PACKAGE_SUBDIR "/ippicv_osx") elseif(UNIX) if(ANDROID AND (NOT ANDROID_ABI STREQUAL x86)) return() endif() - set(OPENCV_ICV_PACKAGE_NAME "ippicv_linux_20140513.tgz") - set(OPENCV_ICV_PACKAGE_HASH "d80cb24f3a565113a9d6dc56344142f6") + set(OPENCV_ICV_PACKAGE_NAME "ippicv_linux_20141027.tgz") + set(OPENCV_ICV_PACKAGE_HASH "8b449a536a2157bcad08a2b9f266828b") set(OPENCV_ICV_PLATFORM "linux") set(OPENCV_ICV_PACKAGE_SUBDIR "/ippicv_lnx") elseif(WIN32 AND NOT ARM) - set(OPENCV_ICV_PACKAGE_NAME "ippicv_windows_20140429.zip") - set(OPENCV_ICV_PACKAGE_HASH "b5028a92224ec1fbc554010c52eb3ec8") + set(OPENCV_ICV_PACKAGE_NAME "ippicv_windows_20141027.zip") + set(OPENCV_ICV_PACKAGE_HASH "b59f865d1ba16e8c84124e19d78eec57") set(OPENCV_ICV_PLATFORM "windows") set(OPENCV_ICV_PACKAGE_SUBDIR "/ippicv_win") else() @@ -45,7 +45,7 @@ function(_icv_downloader) endif() endif() unset(OPENCV_ICV_PACKAGE_DOWNLOADED CACHE) - + set(OPENCV_ICV_PACKAGE_ARCHIVE "${CMAKE_CURRENT_LIST_DIR}/downloads/${OPENCV_ICV_PLATFORM}-${OPENCV_ICV_PACKAGE_HASH}/${OPENCV_ICV_PACKAGE_NAME}") get_filename_component(OPENCV_ICV_PACKAGE_ARCHIVE_DIR "${OPENCV_ICV_PACKAGE_ARCHIVE}" PATH) if(EXISTS "${OPENCV_ICV_PACKAGE_ARCHIVE}") @@ -56,7 +56,7 @@ function(_icv_downloader) file(REMOVE_RECURSE "${OPENCV_ICV_PACKAGE_ARCHIVE_DIR}") endif() endif() - + if(NOT EXISTS "${OPENCV_ICV_PACKAGE_ARCHIVE}") if(NOT DEFINED OPENCV_ICV_URL) if(DEFINED ENV{OPENCV_ICV_URL}) @@ -65,7 +65,7 @@ function(_icv_downloader) set(OPENCV_ICV_URL "http://sourceforge.net/projects/opencvlibrary/files/3rdparty/ippicv") endif() endif() - + file(MAKE_DIRECTORY ${OPENCV_ICV_PACKAGE_ARCHIVE_DIR}) message(STATUS "ICV: Downloading ${OPENCV_ICV_PACKAGE_NAME}...") file(DOWNLOAD "${OPENCV_ICV_URL}/${OPENCV_ICV_PACKAGE_NAME}" "${OPENCV_ICV_PACKAGE_ARCHIVE}" @@ -82,12 +82,12 @@ function(_icv_downloader) endif() endif() endif() - + ocv_assert(EXISTS "${OPENCV_ICV_PACKAGE_ARCHIVE}") ocv_assert(NOT EXISTS "${OPENCV_ICV_UNPACK_PATH}") file(MAKE_DIRECTORY ${OPENCV_ICV_UNPACK_PATH}) ocv_assert(EXISTS "${OPENCV_ICV_UNPACK_PATH}") - + message(STATUS "ICV: Unpacking ${OPENCV_ICV_PACKAGE_NAME} to ${OPENCV_ICV_UNPACK_PATH}...") execute_process(COMMAND ${CMAKE_COMMAND} -E tar xz "${OPENCV_ICV_PACKAGE_ARCHIVE}" WORKING_DIRECTORY "${OPENCV_ICV_UNPACK_PATH}" @@ -100,7 +100,7 @@ function(_icv_downloader) ocv_assert(EXISTS "${OPENCV_ICV_PATH}") set(OPENCV_ICV_PACKAGE_DOWNLOADED "${OPENCV_ICV_PACKAGE_HASH}" CACHE INTERNAL "ICV package hash") - + message(STATUS "ICV: Package successfully downloaded") set(OPENCV_ICV_PATH "${OPENCV_ICV_PATH}" PARENT_SCOPE) endfunction() diff --git a/cmake/templates/OpenCVConfig.cmake.in b/cmake/templates/OpenCVConfig.cmake.in index 5d97474f3a..0fa8048bba 100644 --- a/cmake/templates/OpenCVConfig.cmake.in +++ b/cmake/templates/OpenCVConfig.cmake.in @@ -49,7 +49,7 @@ if(NOT DEFINED OpenCV_MODULES_SUFFIX) endif() endif() -if(@USE_IPPICV@) # value is defined by package builder +if("@USE_IPPICV@" STREQUAL "TRUE") # value is defined by package builder (use STREQUAL to comply new CMake policy CMP0012) if(NOT TARGET ippicv) if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_PATH_RELATIVE_IPPICV@") add_library(ippicv STATIC IMPORTED) @@ -292,7 +292,9 @@ foreach(__opttype OPT DBG) set(OpenCV_CUDA_LIBS_RELPATH "") foreach(l ${OpenCV_CUDA_LIBS_ABSPATH}) get_filename_component(_tmp ${l} PATH) - list(APPEND OpenCV_CUDA_LIBS_RELPATH ${_tmp}) + if(NOT ${_tmp} MATCHES "-Wl.*") + list(APPEND OpenCV_CUDA_LIBS_RELPATH ${_tmp}) + endif() endforeach() list(REMOVE_DUPLICATES OpenCV_CUDA_LIBS_RELPATH) diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt index a671d43e3d..81e18973f7 100644 --- a/doc/CMakeLists.txt +++ b/doc/CMakeLists.txt @@ -147,14 +147,18 @@ endif() # ========= Doxygen docs ========= if(BUILD_DOCS AND HAVE_DOXYGEN) + # documented modules list set(candidates) - set(all_headers) - set(all_images) list(APPEND candidates ${BASE_MODULES} ${EXTRA_MODULES}) # blacklisted modules ocv_list_filterout(candidates "^ts$") + # gathering headers + set(all_headers) # files and dirs to process + set(all_images) # image search paths + set(reflist) # modules reference foreach(m ${candidates}) + set(reflist "${reflist} \n- @subpage ${m}") set(all_headers ${all_headers} "${OPENCV_MODULE_opencv_${m}_HEADERS}") set(docs_dir "${OPENCV_MODULE_opencv_${m}_LOCATION}/doc") if(EXISTS ${docs_dir}) @@ -164,15 +168,20 @@ if(BUILD_DOCS AND HAVE_DOXYGEN) endforeach() # additional config + set(doxyfile "${CMAKE_CURRENT_BINARY_DIR}/Doxyfile") + set(rootfile "${CMAKE_CURRENT_BINARY_DIR}/root.markdown") + set(all_headers ${all_headers} ${rootfile}) string(REGEX REPLACE ";" " \\\\\\n" CMAKE_DOXYGEN_INPUT_LIST "${all_headers}") string(REGEX REPLACE ";" " \\\\\\n" CMAKE_DOXYGEN_IMAGE_PATH "${all_images}") - set(CMAKE_DOXYGEN_INDEX_MD "${CMAKE_SOURCE_DIR}/README.md") set(CMAKE_DOXYGEN_LAYOUT "${CMAKE_CURRENT_SOURCE_DIR}/DoxygenLayout.xml") set(CMAKE_DOXYGEN_OUTPUT_PATH "doxygen") + set(CMAKE_DOXYGEN_MODULES_REFERENCE "${reflist}") + set(CMAKE_DOXYGEN_EXAMPLE_PATH "${CMAKE_SOURCE_DIR}/samples/cpp") # writing file - set(doxyfile "${CMAKE_CURRENT_BINARY_DIR}/Doxyfile") configure_file(Doxyfile.in ${doxyfile} @ONLY) + configure_file(root.markdown.in ${rootfile} @ONLY) + configure_file(mymath.sty "${CMAKE_DOXYGEN_OUTPUT_PATH}/html/mymath.sty" @ONLY) add_custom_target(doxygen COMMAND ${DOXYGEN_BUILD} ${doxyfile} diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in index c47496fa3b..443eb6d493 100644 --- a/doc/Doxyfile.in +++ b/doc/Doxyfile.in @@ -21,8 +21,8 @@ ABBREVIATE_BRIEF = "The $name class" \ the ALWAYS_DETAILED_SEC = NO INLINE_INHERITED_MEMB = NO -FULL_PATH_NAMES = NO -STRIP_FROM_PATH = +FULL_PATH_NAMES = YES +STRIP_FROM_PATH = @CMAKE_SOURCE_DIR@/modules STRIP_FROM_INC_PATH = SHORT_NAMES = NO JAVADOC_AUTOBRIEF = NO @@ -39,7 +39,7 @@ OPTIMIZE_FOR_FORTRAN = NO OPTIMIZE_OUTPUT_VHDL = NO EXTENSION_MAPPING = MARKDOWN_SUPPORT = YES -AUTOLINK_SUPPORT = NO +AUTOLINK_SUPPORT = YES BUILTIN_STL_SUPPORT = YES CPP_CLI_SUPPORT = NO SIP_SUPPORT = NO @@ -53,7 +53,7 @@ LOOKUP_CACHE_SIZE = 0 EXTRACT_ALL = YES EXTRACT_PRIVATE = NO EXTRACT_PACKAGE = NO -EXTRACT_STATIC = NO +EXTRACT_STATIC = YES EXTRACT_LOCAL_CLASSES = NO EXTRACT_LOCAL_METHODS = NO EXTRACT_ANON_NSPACES = NO @@ -66,11 +66,11 @@ CASE_SENSE_NAMES = YES HIDE_SCOPE_NAMES = NO SHOW_INCLUDE_FILES = YES SHOW_GROUPED_MEMB_INC = NO -FORCE_LOCAL_INCLUDES = NO +FORCE_LOCAL_INCLUDES = YES INLINE_INFO = YES SORT_MEMBER_DOCS = YES -SORT_BRIEF_DOCS = NO -SORT_MEMBERS_CTORS_1ST = NO +SORT_BRIEF_DOCS = YES +SORT_MEMBERS_CTORS_1ST = YES SORT_GROUP_NAMES = NO SORT_BY_SCOPE_NAME = NO STRICT_PROTO_MATCHING = NO @@ -86,7 +86,7 @@ SHOW_NAMESPACES = YES FILE_VERSION_FILTER = LAYOUT_FILE = @CMAKE_DOXYGEN_LAYOUT@ CITE_BIB_FILES = -QUIET = NO +QUIET = YES WARNINGS = YES WARN_IF_UNDOCUMENTED = YES WARN_IF_DOC_ERROR = YES @@ -100,19 +100,16 @@ RECURSIVE = YES EXCLUDE = EXCLUDE_SYMLINKS = NO EXCLUDE_PATTERNS = -EXCLUDE_SYMBOLS = CV_WRAP \ - CV_EXPORTS \ - CV_EXPORTS_W \ - CV_WRAP_AS -EXAMPLE_PATH = +EXCLUDE_SYMBOLS = cv::DataType<*> +EXAMPLE_PATH = @CMAKE_DOXYGEN_EXAMPLE_PATH@ EXAMPLE_PATTERNS = * -EXAMPLE_RECURSIVE = NO +EXAMPLE_RECURSIVE = YES IMAGE_PATH = @CMAKE_DOXYGEN_IMAGE_PATH@ INPUT_FILTER = FILTER_PATTERNS = FILTER_SOURCE_FILES = NO FILTER_SOURCE_PATTERNS = -USE_MDFILE_AS_MAINPAGE = @CMAKE_DOXYGEN_INDEX_MD@ +USE_MDFILE_AS_MAINPAGE = SOURCE_BROWSER = NO INLINE_SOURCES = NO STRIP_CODE_COMMENTS = YES @@ -161,18 +158,18 @@ QHP_SECT_FILTER_ATTRS = QHG_LOCATION = GENERATE_ECLIPSEHELP = NO ECLIPSE_DOC_ID = org.doxygen.Project -DISABLE_INDEX = YES +DISABLE_INDEX = NO GENERATE_TREEVIEW = YES -ENUM_VALUES_PER_LINE = 4 +ENUM_VALUES_PER_LINE = 0 TREEVIEW_WIDTH = 250 EXT_LINKS_IN_WINDOW = YES -FORMULA_FONTSIZE = 10 +FORMULA_FONTSIZE = 14 FORMULA_TRANSPARENT = YES -USE_MATHJAX = NO +USE_MATHJAX = YES MATHJAX_FORMAT = HTML-CSS MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest -MATHJAX_EXTENSIONS = -MATHJAX_CODEFILE = +MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols +MATHJAX_CODEFILE = @CMAKE_CURRENT_SOURCE_DIR@/mymath.js SEARCHENGINE = YES SERVER_BASED_SEARCH = NO EXTERNAL_SEARCH = NO @@ -180,13 +177,13 @@ SEARCHENGINE_URL = SEARCHDATA_FILE = searchdata.xml EXTERNAL_SEARCH_ID = EXTRA_SEARCH_MAPPINGS = -GENERATE_LATEX = YES +GENERATE_LATEX = NO LATEX_OUTPUT = latex LATEX_CMD_NAME = latex MAKEINDEX_CMD_NAME = makeindex COMPACT_LATEX = NO PAPER_TYPE = a4 -EXTRA_PACKAGES = +EXTRA_PACKAGES = mymath LATEX_HEADER = LATEX_FOOTER = LATEX_EXTRA_FILES = @@ -222,12 +219,29 @@ EXPAND_ONLY_PREDEF = NO SEARCH_INCLUDES = YES INCLUDE_PATH = INCLUDE_FILE_PATTERNS = -PREDEFINED = CV_WRAP= \ - __cplusplus=1 \ +PREDEFINED = __cplusplus=1 \ + HAVE_IPP_A=1 \ CVAPI(x)=x \ - CV_PROP_RW= \ CV_EXPORTS= \ - CV_EXPORTS_W= + CV_EXPORTS_W= \ + CV_EXPORTS_W_SIMPLE= \ + CV_EXPORTS_AS(x)= \ + CV_EXPORTS_W_MAP= \ + CV_IN_OUT= \ + CV_OUT= \ + CV_PROP= \ + CV_PROP_RW= \ + CV_WRAP= \ + CV_WRAP_AS(x)= \ + CV_CDECL= \ + CV_Func = \ + CV_DO_PRAGMA(x)= \ + CV_SUPPRESS_DEPRECATED_START= \ + CV_SUPPRESS_DEPRECATED_END= \ + CV_INLINE= \ + CV_NORETURN= \ + CV_DEFAULT(x)=" = x" \ + CV_NEON=1 EXPAND_AS_DEFINED = SKIP_FUNCTION_MACROS = YES TAGFILES = diff --git a/doc/mymath.js b/doc/mymath.js new file mode 100644 index 0000000000..69bc91ab65 --- /dev/null +++ b/doc/mymath.js @@ -0,0 +1,12 @@ + +MathJax.Hub.Config({ + TeX: { + Macros: { + matTT: [ "\\[ \\left|\\begin{array}{ccc} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \\end{array}\\right| \\]", 9], + fork: ["\\left\\{ \\begin{array}{l l} #1 & \\mbox{#2}\\\\ #3 & \\mbox{#4}\\\\ \\end{array} \\right.", 4], + forkthree: ["\\left\\{ \\begin{array}{l l} #1 & \\mbox{#2}\\\\ #3 & \\mbox{#4}\\\\ #5 & \\mbox{#6}\\\\ \\end{array} \\right.", 6], + vecthree: ["\\begin{bmatrix} #1\\\\ #2\\\\ #3 \\end{bmatrix}", 3], + vecthreethree: ["\\begin{bmatrix} #1 & #2 & #3\\\\ #4 & #5 & #6\\\\ #7 & #8 & #9 \\end{bmatrix}", 9] + } + } + }); diff --git a/doc/mymath.sty b/doc/mymath.sty index 4da8282121..24dae263a5 100644 --- a/doc/mymath.sty +++ b/doc/mymath.sty @@ -1,5 +1,9 @@ \ProvidesPackage{mymath} +\usepackage{euler} +\usepackage{amssymb} +\usepackage{amsmath} + \newcommand{\matTT}[9]{ \[ \left|\begin{array}{ccc} diff --git a/doc/root.markdown.in b/doc/root.markdown.in new file mode 100644 index 0000000000..63e7c543b0 --- /dev/null +++ b/doc/root.markdown.in @@ -0,0 +1,7 @@ +OpenCV modules {#mainpage} +============== + +- @subpage intro +- @subpage core + + diff --git a/doc/tutorials/core/discrete_fourier_transform/discrete_fourier_transform.rst b/doc/tutorials/core/discrete_fourier_transform/discrete_fourier_transform.rst index 17527a7124..8c41e6520c 100644 --- a/doc/tutorials/core/discrete_fourier_transform/discrete_fourier_transform.rst +++ b/doc/tutorials/core/discrete_fourier_transform/discrete_fourier_transform.rst @@ -126,7 +126,7 @@ In this sample I'll show how to calculate and show the *magnitude* image of a Fo Result ====== -An application idea would be to determine the geometrical orientation present in the image. For example, let us find out if a text is horizontal or not? Looking at some text you'll notice that the text lines sort of form also horizontal lines and the letters form sort of vertical lines. These two main components of a text snippet may be also seen in case of the Fourier transform. Let us use :download:`this horizontal <../../../../samples/cpp/tutorial_code/images/imageTextN.png>` and :download:`this rotated<../../../../samples/cpp/tutorial_code/images/imageTextR.png>` image about a text. +An application idea would be to determine the geometrical orientation present in the image. For example, let us find out if a text is horizontal or not? Looking at some text you'll notice that the text lines sort of form also horizontal lines and the letters form sort of vertical lines. These two main components of a text snippet may be also seen in case of the Fourier transform. Let us use :download:`this horizontal <../../../../samples/data/imageTextN.png>` and :download:`this rotated<../../../../samples/data/imageTextR.png>` image about a text. In case of the horizontal text: diff --git a/doc/tutorials/introduction/display_image/display_image.rst b/doc/tutorials/introduction/display_image/display_image.rst index e67da6cd3b..d4617cc126 100644 --- a/doc/tutorials/introduction/display_image/display_image.rst +++ b/doc/tutorials/introduction/display_image/display_image.rst @@ -39,28 +39,28 @@ You'll almost always end up using the: .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp :language: cpp :tab-width: 4 - :lines: 1-4 + :lines: 1-6 We also include the *iostream* to facilitate console line output and input. To avoid data structure and function name conflicts with other libraries, OpenCV has its own namespace: *cv*. To avoid the need appending prior each of these the *cv::* keyword you can import the namespace in the whole file by using the lines: .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp :language: cpp :tab-width: 4 - :lines: 6-7 + :lines: 8-9 -This is true for the STL library too (used for console I/O). Now, let's analyze the *main* function. We start up assuring that we acquire a valid image name argument from the command line. +This is true for the STL library too (used for console I/O). Now, let's analyze the *main* function. We start up assuring that we acquire a valid image name argument from the command line. Otherwise take a picture by default: "HappyFish.jpg". .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp :language: cpp :tab-width: 4 - :lines: 11-15 + :lines: 13-17 Then create a *Mat* object that will store the data of the loaded image. .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp :language: cpp :tab-width: 4 - :lines: 17 + :lines: 19 Now we call the :imread:`imread <>` function which loads the image name specified by the first argument (*argv[1]*). The second argument specifies the format in what we want the image. This may be: @@ -73,7 +73,7 @@ Now we call the :imread:`imread <>` function which loads the image name specifie .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp :language: cpp :tab-width: 4 - :lines: 18 + :lines: 20 .. note:: @@ -88,21 +88,21 @@ After checking that the image data was loaded correctly, we want to display our .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp :language: cpp - :lines: 26 + :lines: 28 :tab-width: 4 Finally, to update the content of the OpenCV window with a new image use the :imshow:`imshow <>` function. Specify the OpenCV window name to update and the image to use during this operation: .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp :language: cpp - :lines: 27 + :lines: 29 :tab-width: 4 Because we want our window to be displayed until the user presses a key (otherwise the program would end far too quickly), we use the :wait_key:`waitKey <>` function whose only parameter is just how long should it wait for a user input (measured in milliseconds). Zero means to wait forever. .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp :language: cpp - :lines: 29 + :lines: 31 :tab-width: 4 Result diff --git a/doc/tutorials/introduction/windows_visual_studio_Opencv/windows_visual_studio_Opencv.rst b/doc/tutorials/introduction/windows_visual_studio_Opencv/windows_visual_studio_Opencv.rst index 6788d17e4e..26ce913fba 100644 --- a/doc/tutorials/introduction/windows_visual_studio_Opencv/windows_visual_studio_Opencv.rst +++ b/doc/tutorials/introduction/windows_visual_studio_Opencv/windows_visual_studio_Opencv.rst @@ -160,7 +160,7 @@ You can start a Visual Studio build from two places. Either inside from the *IDE .. |voila| unicode:: voil U+00E1 -This is important to remember when you code inside the code open and save commands. You're resources will be saved ( and queried for at opening!!!) relatively to your working directory. This is unless you give a full, explicit path as parameter for the I/O functions. In the code above we open :download:`this OpenCV logo<../../../../samples/cpp/tutorial_code/images/opencv-logo.png>`. Before starting up the application make sure you place the image file in your current working directory. Modify the image file name inside the code to try it out on other images too. Run it and |voila|: +This is important to remember when you code inside the code open and save commands. You're resources will be saved ( and queried for at opening!!!) relatively to your working directory. This is unless you give a full, explicit path as parameter for the I/O functions. In the code above we open :download:`this OpenCV logo<../../../../samples/data/opencv-logo.png>`. Before starting up the application make sure you place the image file in your current working directory. Modify the image file name inside the code to try it out on other images too. Run it and |voila|: .. image:: images/SuccessVisualStudioWindows.jpg :alt: You should have this. diff --git a/modules/calib3d/src/solvepnp.cpp b/modules/calib3d/src/solvepnp.cpp index bdc32c6959..129c10ee76 100644 --- a/modules/calib3d/src/solvepnp.cpp +++ b/modules/calib3d/src/solvepnp.cpp @@ -160,7 +160,7 @@ public: Mat opoints = _m1.getMat(), ipoints = _m2.getMat(), model = _model.getMat(); - int i, count = opoints.cols; + int i, count = opoints.checkVector(3); Mat _rvec = model.col(0); Mat _tvec = model.col(1); @@ -251,14 +251,10 @@ bool cv::solvePnPRansac(InputArray _opoints, InputArray _ipoints, if(_inliers.needed()) { Mat _local_inliers; - int count = 0; - for (int i = 0; i < _mask_local_inliers.rows; ++i) + for (int i = 0; i < npoints; ++i) { - if((int)_mask_local_inliers.at(i) == 1) // inliers mask - { - _local_inliers.push_back(count); // output inliers vector - count++; - } + if((int)_mask_local_inliers.at(i) != 0) // inliers mask + _local_inliers.push_back(i); // output inliers vector } _local_inliers.copyTo(_inliers); } diff --git a/modules/calib3d/test/test_decompose_projection.cpp b/modules/calib3d/test/test_decompose_projection.cpp new file mode 100644 index 0000000000..ef80942a85 --- /dev/null +++ b/modules/calib3d/test/test_decompose_projection.cpp @@ -0,0 +1,140 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2000-2008, Intel Corporation, all rights reserved. +// Copyright (C) 2009, Willow Garage Inc., all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "test_precomp.hpp" + +class CV_DecomposeProjectionMatrixTest : public cvtest::BaseTest +{ +public: + CV_DecomposeProjectionMatrixTest(); +protected: + void run(int); +}; + +CV_DecomposeProjectionMatrixTest::CV_DecomposeProjectionMatrixTest() +{ + test_case_count = 30; +} + + +void CV_DecomposeProjectionMatrixTest::run(int start_from) +{ + + ts->set_failed_test_info(cvtest::TS::OK); + + cv::RNG& rng = ts->get_rng(); + int progress = 0; + + + for (int iter = start_from; iter < test_case_count; ++iter) + { + ts->update_context(this, iter, true); + progress = update_progress(progress, iter, test_case_count, 0); + + // Create the original (and random) camera matrix, rotation, and translation + cv::Vec2d f, c; + rng.fill(f, cv::RNG::UNIFORM, 300, 1000); + rng.fill(c, cv::RNG::UNIFORM, 150, 600); + + double alpha = 0.01*rng.gaussian(1); + + cv::Matx33d origK(f(0), alpha*f(0), c(0), + 0, f(1), c(1), + 0, 0, 1); + + + cv::Vec3d rVec; + rng.fill(rVec, cv::RNG::UNIFORM, -CV_PI, CV_PI); + + cv::Matx33d origR; + Rodrigues(rVec, origR); + + cv::Vec3d origT; + rng.fill(origT, cv::RNG::NORMAL, 0, 1); + + + // Compose the projection matrix + cv::Matx34d P(3,4); + hconcat(origK*origR, origK*origT, P); + + + // Decompose + cv::Matx33d K, R; + cv::Vec4d homogCameraCenter; + decomposeProjectionMatrix(P, K, R, homogCameraCenter); + + + // Recover translation from the camera center + cv::Vec3d cameraCenter(homogCameraCenter(0), homogCameraCenter(1), homogCameraCenter(2)); + cameraCenter /= homogCameraCenter(3); + + cv::Vec3d t = -R*cameraCenter; + + + const double thresh = 1e-6; + if ( norm(origK, K, cv::NORM_INF) > thresh ) + { + ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); + break; + } + + if ( norm(origR, R, cv::NORM_INF) > thresh ) + { + ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); + break; + } + + if ( norm(origT, t, cv::NORM_INF) > thresh ) + { + ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); + break; + } + + } + +} + +TEST(Calib3d_DecomposeProjectionMatrix, accuracy) +{ + CV_DecomposeProjectionMatrixTest test; + test.safe_run(); +} diff --git a/modules/core/doc/intro.markdown b/modules/core/doc/intro.markdown new file mode 100644 index 0000000000..952b7dc096 --- /dev/null +++ b/modules/core/doc/intro.markdown @@ -0,0 +1,318 @@ +Introduction {#intro} +============ + +OpenCV (Open Source Computer Vision Library: ) is an open-source BSD-licensed +library that includes several hundreds of computer vision algorithms. The document describes the +so-called OpenCV 2.x API, which is essentially a C++ API, as opposite to the C-based OpenCV 1.x API. +The latter is described in opencv1x.pdf. + +OpenCV has a modular structure, which means that the package includes several shared or static +libraries. The following modules are available: + +- @ref core - a compact module defining basic data structures, including the dense + multi-dimensional array Mat and basic functions used by all other modules. +- **imgproc** - an image processing module that includes linear and non-linear image filtering, + geometrical image transformations (resize, affine and perspective warping, generic table-based + remapping), color space conversion, histograms, and so on. +- **video** - a video analysis module that includes motion estimation, background subtraction, + and object tracking algorithms. +- **calib3d** - basic multiple-view geometry algorithms, single and stereo camera calibration, + object pose estimation, stereo correspondence algorithms, and elements of 3D reconstruction. +- **features2d** - salient feature detectors, descriptors, and descriptor matchers. +- **objdetect** - detection of objects and instances of the predefined classes (for example, + faces, eyes, mugs, people, cars, and so on). +- **highgui** - an easy-to-use interface to simple UI capabilities. +- **videoio** - an easy-to-use interface to video capturing and video codecs. +- **gpu** - GPU-accelerated algorithms from different OpenCV modules. +- ... some other helper modules, such as FLANN and Google test wrappers, Python bindings, and + others. + +The further chapters of the document describe functionality of each module. But first, make sure to +get familiar with the common API concepts used thoroughly in the library. + +API Concepts +------------ + +### cv Namespace + +All the OpenCV classes and functions are placed into the cv namespace. Therefore, to access this +functionality from your code, use the cv:: specifier or using namespace cv; directive: +@code +#include "opencv2/core.hpp" +... +cv::Mat H = cv::findHomography(points1, points2, CV_RANSAC, 5); +... +@endcode +or : +~~~ + #include "opencv2/core.hpp" + using namespace cv; + ... + Mat H = findHomography(points1, points2, CV_RANSAC, 5 ); + ... +~~~ +Some of the current or future OpenCV external names may conflict with STL or other libraries. In +this case, use explicit namespace specifiers to resolve the name conflicts: +@code + Mat a(100, 100, CV_32F); + randu(a, Scalar::all(1), Scalar::all(std::rand())); + cv::log(a, a); + a /= std::log(2.); +@endcode + +### Automatic Memory Management + +OpenCV handles all the memory automatically. + +First of all, std::vector, Mat, and other data structures used by the functions and methods have +destructors that deallocate the underlying memory buffers when needed. This means that the +destructors do not always deallocate the buffers as in case of Mat. They take into account possible +data sharing. A destructor decrements the reference counter associated with the matrix data buffer. +The buffer is deallocated if and only if the reference counter reaches zero, that is, when no other +structures refer to the same buffer. Similarly, when a Mat instance is copied, no actual data is +really copied. Instead, the reference counter is incremented to memorize that there is another owner +of the same data. There is also the Mat::clone method that creates a full copy of the matrix data. +See the example below: +@code + // create a big 8Mb matrix + Mat A(1000, 1000, CV_64F); + + // create another header for the same matrix; + // this is an instant operation, regardless of the matrix size. + Mat B = A; + // create another header for the 3-rd row of A; no data is copied either + Mat C = B.row(3); + // now create a separate copy of the matrix + Mat D = B.clone(); + // copy the 5-th row of B to C, that is, copy the 5-th row of A + // to the 3-rd row of A. + B.row(5).copyTo(C); + // now let A and D share the data; after that the modified version + // of A is still referenced by B and C. + A = D; + // now make B an empty matrix (which references no memory buffers), + // but the modified version of A will still be referenced by C, + // despite that C is just a single row of the original A + B.release(); + + // finally, make a full copy of C. As a result, the big modified + // matrix will be deallocated, since it is not referenced by anyone + C = C.clone(); +@endcode +You see that the use of Mat and other basic structures is simple. But what about high-level classes +or even user data types created without taking automatic memory management into account? For them, +OpenCV offers the Ptr template class that is similar to std::shared\_ptr from C++11. So, instead of +using plain pointers: +@code + T* ptr = new T(...); +@endcode +you can use: +@code + Ptr ptr(new T(...)); +@endcode +or: +@code + Ptr ptr = makePtr(...); +@endcode +Ptr\ encapsulates a pointer to a T instance and a reference counter associated with the pointer. +See the Ptr description for details. + +### Automatic Allocation of the Output Data + +OpenCV deallocates the memory automatically, as well as automatically allocates the memory for +output function parameters most of the time. So, if a function has one or more input arrays (cv::Mat +instances) and some output arrays, the output arrays are automatically allocated or reallocated. The +size and type of the output arrays are determined from the size and type of input arrays. If needed, +the functions take extra parameters that help to figure out the output array properties. + +Example: +@code + #include "opencv2/imgproc.hpp" + #include "opencv2/highgui.hpp" + + using namespace cv; + + int main(int, char**) + { + VideoCapture cap(0); + if(!cap.isOpened()) return -1; + + Mat frame, edges; + namedWindow("edges",1); + for(;;) + { + cap >> frame; + cvtColor(frame, edges, COLOR_BGR2GRAY); + GaussianBlur(edges, edges, Size(7,7), 1.5, 1.5); + Canny(edges, edges, 0, 30, 3); + imshow("edges", edges); + if(waitKey(30) >= 0) break; + } + return 0; + } +@endcode +The array frame is automatically allocated by the \>\> operator since the video frame resolution and +the bit-depth is known to the video capturing module. The array edges is automatically allocated by +the cvtColor function. It has the same size and the bit-depth as the input array. The number of +channels is 1 because the color conversion code COLOR\_BGR2GRAY is passed, which means a color to +grayscale conversion. Note that frame and edges are allocated only once during the first execution +of the loop body since all the next video frames have the same resolution. If you somehow change the +video resolution, the arrays are automatically reallocated. + +The key component of this technology is the Mat::create method. It takes the desired array size and +type. If the array already has the specified size and type, the method does nothing. Otherwise, it +releases the previously allocated data, if any (this part involves decrementing the reference +counter and comparing it with zero), and then allocates a new buffer of the required size. Most +functions call the Mat::create method for each output array, and so the automatic output data +allocation is implemented. + +Some notable exceptions from this scheme are cv::mixChannels, cv::RNG::fill, and a few other +functions and methods. They are not able to allocate the output array, so you have to do this in +advance. + +### Saturation Arithmetics + +As a computer vision library, OpenCV deals a lot with image pixels that are often encoded in a +compact, 8- or 16-bit per channel, form and thus have a limited value range. Furthermore, certain +operations on images, like color space conversions, brightness/contrast adjustments, sharpening, +complex interpolation (bi-cubic, Lanczos) can produce values out of the available range. If you just +store the lowest 8 (16) bits of the result, this results in visual artifacts and may affect a +further image analysis. To solve this problem, the so-called *saturation* arithmetics is used. For +example, to store r, the result of an operation, to an 8-bit image, you find the nearest value +within the 0..255 range: + +\f[I(x,y)= \min ( \max (\textrm{round}(r), 0), 255)\f] + +Similar rules are applied to 8-bit signed, 16-bit signed and unsigned types. This semantics is used +everywhere in the library. In C++ code, it is done using the saturate\_cast\<\> functions that +resemble standard C++ cast operations. See below the implementation of the formula provided above: +@code + I.at(y, x) = saturate_cast(r); +@endcode +where cv::uchar is an OpenCV 8-bit unsigned integer type. In the optimized SIMD code, such SSE2 +instructions as paddusb, packuswb, and so on are used. They help achieve exactly the same behavior +as in C++ code. + +@note Saturation is not applied when the result is 32-bit integer. + +### Fixed Pixel Types. Limited Use of Templates + +Templates is a great feature of C++ that enables implementation of very powerful, efficient and yet +safe data structures and algorithms. However, the extensive use of templates may dramatically +increase compilation time and code size. Besides, it is difficult to separate an interface and +implementation when templates are used exclusively. This could be fine for basic algorithms but not +good for computer vision libraries where a single algorithm may span thousands lines of code. +Because of this and also to simplify development of bindings for other languages, like Python, Java, +Matlab that do not have templates at all or have limited template capabilities, the current OpenCV +implementation is based on polymorphism and runtime dispatching over templates. In those places +where runtime dispatching would be too slow (like pixel access operators), impossible (generic +Ptr\<\> implementation), or just very inconvenient (saturate\_cast\<\>()) the current implementation +introduces small template classes, methods, and functions. Anywhere else in the current OpenCV +version the use of templates is limited. + +Consequently, there is a limited fixed set of primitive data types the library can operate on. That +is, array elements should have one of the following types: + +- 8-bit unsigned integer (uchar) +- 8-bit signed integer (schar) +- 16-bit unsigned integer (ushort) +- 16-bit signed integer (short) +- 32-bit signed integer (int) +- 32-bit floating-point number (float) +- 64-bit floating-point number (double) +- a tuple of several elements where all elements have the same type (one of the above). An array + whose elements are such tuples, are called multi-channel arrays, as opposite to the + single-channel arrays, whose elements are scalar values. The maximum possible number of + channels is defined by the CV\_CN\_MAX constant, which is currently set to 512. + +For these basic types, the following enumeration is applied: +@code + enum { CV_8U=0, CV_8S=1, CV_16U=2, CV_16S=3, CV_32S=4, CV_32F=5, CV_64F=6 }; +@endcode +Multi-channel (n-channel) types can be specified using the following options: + +- CV_8UC1 ... CV_64FC4 constants (for a number of channels from 1 to 4) +- CV_8UC(n) ... CV_64FC(n) or CV_MAKETYPE(CV_8U, n) ... CV_MAKETYPE(CV_64F, n) macros when + the number of channels is more than 4 or unknown at the compilation time. + +@note `CV_32FC1 == CV_32F, CV_32FC2 == CV_32FC(2) == CV_MAKETYPE(CV_32F, 2)`, and +`CV_MAKETYPE(depth, n) == ((x&7)<<3) + (n-1)``. This means that the constant type is formed from the +depth, taking the lowest 3 bits, and the number of channels minus 1, taking the next +`log2(CV_CN_MAX)`` bits. + +Examples: +@code + Mat mtx(3, 3, CV_32F); // make a 3x3 floating-point matrix + Mat cmtx(10, 1, CV_64FC2); // make a 10x1 2-channel floating-point + // matrix (10-element complex vector) + Mat img(Size(1920, 1080), CV_8UC3); // make a 3-channel (color) image + // of 1920 columns and 1080 rows. + Mat grayscale(image.size(), CV_MAKETYPE(image.depth(), 1)); // make a 1-channel image of + // the same size and same + // channel type as img +@endcode +Arrays with more complex elements cannot be constructed or processed using OpenCV. Furthermore, each +function or method can handle only a subset of all possible array types. Usually, the more complex +the algorithm is, the smaller the supported subset of formats is. See below typical examples of such +limitations: + +- The face detection algorithm only works with 8-bit grayscale or color images. +- Linear algebra functions and most of the machine learning algorithms work with floating-point + arrays only. +- Basic functions, such as cv::add, support all types. +- Color space conversion functions support 8-bit unsigned, 16-bit unsigned, and 32-bit + floating-point types. + +The subset of supported types for each function has been defined from practical needs and could be +extended in future based on user requests. + +### InputArray and OutputArray + +Many OpenCV functions process dense 2-dimensional or multi-dimensional numerical arrays. Usually, +such functions take cppMat as parameters, but in some cases it's more convenient to use +std::vector\<\> (for a point set, for example) or Matx\<\> (for 3x3 homography matrix and such). To +avoid many duplicates in the API, special "proxy" classes have been introduced. The base "proxy" +class is InputArray. It is used for passing read-only arrays on a function input. The derived from +InputArray class OutputArray is used to specify an output array for a function. Normally, you should +not care of those intermediate types (and you should not declare variables of those types +explicitly) - it will all just work automatically. You can assume that instead of +InputArray/OutputArray you can always use Mat, std::vector\<\>, Matx\<\>, Vec\<\> or Scalar. When a +function has an optional input or output array, and you do not have or do not want one, pass +cv::noArray(). + +### Error Handling + +OpenCV uses exceptions to signal critical errors. When the input data has a correct format and +belongs to the specified value range, but the algorithm cannot succeed for some reason (for example, +the optimization algorithm did not converge), it returns a special error code (typically, just a +boolean variable). + +The exceptions can be instances of the cv::Exception class or its derivatives. In its turn, +cv::Exception is a derivative of std::exception. So it can be gracefully handled in the code using +other standard C++ library components. + +The exception is typically thrown either using the CV\_Error(errcode, description) macro, or its +printf-like CV\_Error\_(errcode, printf-spec, (printf-args)) variant, or using the +CV\_Assert(condition) macro that checks the condition and throws an exception when it is not +satisfied. For performance-critical code, there is CV\_DbgAssert(condition) that is only retained in +the Debug configuration. Due to the automatic memory management, all the intermediate buffers are +automatically deallocated in case of a sudden error. You only need to add a try statement to catch +exceptions, if needed: : +@code + try + { + ... // call OpenCV + } + catch( cv::Exception& e ) + { + const char* err_msg = e.what(); + std::cout << "exception caught: " << err_msg << std::endl; + } +@endcode + +### Multi-threading and Re-enterability + +The current OpenCV implementation is fully re-enterable. That is, the same function, the same +*constant* method of a class instance, or the same *non-constant* method of different class +instances can be called from different threads. Also, the same cv::Mat can be used in different +threads because the reference-counting operations use the architecture-specific atomic instructions. diff --git a/modules/core/include/opencv2/core.hpp b/modules/core/include/opencv2/core.hpp index a8f2db2470..2f31ee3fc0 100644 --- a/modules/core/include/opencv2/core.hpp +++ b/modules/core/include/opencv2/core.hpp @@ -57,14 +57,38 @@ #include "opencv2/core/mat.hpp" #include "opencv2/core/persistence.hpp" -/*! \namespace cv - Namespace where all the C++ OpenCV functionality resides -*/ +/** +@defgroup core Core functionality +@{ + @defgroup core_basic Basic structures + @defgroup core_c C structures and operations + @{ + @defgroup core_c_glue Connections with C++ + @} + @defgroup core_array Operations on arrays + @defgroup core_xml XML/YAML Persistence + @defgroup core_cluster Clustering + @defgroup core_utils Utility and system functions and macros + @{ + @defgroup core_utils_neon NEON utilities + @} + @defgroup core_opengl OpenGL interoperability + @defgroup core_ipp Intel IPP Asynchronous C/C++ Converters + @defgroup core_optim Optimization Algorithms +@} + */ + namespace cv { -/*! - The standard OpenCV exception class. - Instances of the class are thrown by various functions and methods in the case of critical errors. +//! @addtogroup core_utils +//! @{ + +/*! @brief Class passed to an error. + +This class encapsulates all or almost all necessary +information about the error happened in the program. The exception is +usually constructed and thrown implicitly via CV_Error and CV_Error_ macros. +@see error */ class CV_EXPORTS Exception : public std::exception { @@ -95,41 +119,80 @@ public: int line; ///< line number in the source file where the error has occured }; +/*! @brief Signals an error and raises the exception. -//! Signals an error and raises the exception. - -/*! - By default the function prints information about the error to stderr, - then it either stops if setBreakOnError() had been called before or raises the exception. - It is possible to alternate error processing by using redirectError(). - \param exc the exception raisen. - \todo drop this version +By default the function prints information about the error to stderr, +then it either stops if cv::setBreakOnError() had been called before or raises the exception. +It is possible to alternate error processing by using cv::redirectError(). +@param exc the exception raisen. +@deprecated drop this version */ - CV_EXPORTS void error( const Exception& exc ); +enum SortFlags { SORT_EVERY_ROW = 0, //!< each matrix row is sorted independently + SORT_EVERY_COLUMN = 1, //!< each matrix column is sorted + //!< independently; this flag and the previous one are + //!< mutually exclusive. + SORT_ASCENDING = 0, //!< each matrix row is sorted in the ascending + //!< order. + SORT_DESCENDING = 16 //!< each matrix row is sorted in the + //!< descending order; this flag and the previous one are also + //!< mutually exclusive. + }; + +//! @} core_utils + +//! @addtogroup core +//! @{ + +//! Covariation flags +enum CovarFlags { + /** The output covariance matrix is calculated as: + \f[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...],\f] + The covariance matrix will be nsamples x nsamples. Such an unusual covariance matrix is used + for fast PCA of a set of very large vectors (see, for example, the EigenFaces technique for + face recognition). Eigenvalues of this "scrambled" matrix match the eigenvalues of the true + covariance matrix. The "true" eigenvectors can be easily calculated from the eigenvectors of + the "scrambled" covariance matrix. */ + COVAR_SCRAMBLED = 0, + /**The output covariance matrix is calculated as: + \f[\texttt{scale} \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...] \cdot [ \texttt{vects} [0]- \texttt{mean} , \texttt{vects} [1]- \texttt{mean} ,...]^T,\f] + covar will be a square matrix of the same size as the total number of elements in each input + vector. One and only one of COVAR_SCRAMBLED and COVAR_NORMAL must be specified.*/ + COVAR_NORMAL = 1, + /** If the flag is specified, the function does not calculate mean from + the input vectors but, instead, uses the passed mean vector. This is useful if mean has been + pre-calculated or known in advance, or if the covariance matrix is calculated by parts. In + this case, mean is not a mean vector of the input sub-set of vectors but rather the mean + vector of the whole set.*/ + COVAR_USE_AVG = 2, + /** If the flag is specified, the covariance matrix is scaled. In the + "normal" mode, scale is 1./nsamples . In the "scrambled" mode, scale is the reciprocal of the + total number of elements in each input vector. By default (if the flag is not specified), the + covariance matrix is not scaled ( scale=1 ).*/ + COVAR_SCALE = 4, + /** If the flag is + specified, all the input vectors are stored as rows of the samples matrix. mean should be a + single-row vector in this case.*/ + COVAR_ROWS = 8, + /** If the flag is + specified, all the input vectors are stored as columns of the samples matrix. mean should be a + single-column vector in this case.*/ + COVAR_COLS = 16 +}; -enum { SORT_EVERY_ROW = 0, - SORT_EVERY_COLUMN = 1, - SORT_ASCENDING = 0, - SORT_DESCENDING = 16 - }; - -enum { COVAR_SCRAMBLED = 0, - COVAR_NORMAL = 1, - COVAR_USE_AVG = 2, - COVAR_SCALE = 4, - COVAR_ROWS = 8, - COVAR_COLS = 16 - }; - -/*! - k-Means flags -*/ -enum { KMEANS_RANDOM_CENTERS = 0, // Chooses random centers for k-Means initialization - KMEANS_PP_CENTERS = 2, // Uses k-Means++ algorithm for initialization - KMEANS_USE_INITIAL_LABELS = 1 // Uses the user-provided labels for K-Means initialization - }; +//! k-Means flags +enum KmeansFlags { + /** Select random initial centers in each attempt.*/ + KMEANS_RANDOM_CENTERS = 0, + /** Use kmeans++ center initialization by Arthur and Vassilvitskii [Arthur2007].*/ + KMEANS_PP_CENTERS = 2, + /** During the first (and possibly the only) attempt, use the + user-supplied labels instead of computing them from the initial centers. For the second and + further attempts, use the random or semi-random centers. Use one of KMEANS_\*_CENTERS flag + to specify the exact method.*/ + KMEANS_USE_INITIAL_LABELS = 1 +}; enum { FILLED = -1, LINE_4 = 4, @@ -148,450 +211,2013 @@ enum { FONT_HERSHEY_SIMPLEX = 0, FONT_ITALIC = 16 }; -enum { REDUCE_SUM = 0, - REDUCE_AVG = 1, - REDUCE_MAX = 2, - REDUCE_MIN = 3 - }; +enum ReduceTypes { REDUCE_SUM = 0, //!< the output is the sum of all rows/columns of the matrix. + REDUCE_AVG = 1, //!< the output is the mean vector of all rows/columns of the matrix. + REDUCE_MAX = 2, //!< the output is the maximum (column/row-wise) of all rows/columns of the matrix. + REDUCE_MIN = 3 //!< the output is the minimum (column/row-wise) of all rows/columns of the matrix. + }; -//! swaps two matrices +/** @brief Swaps two matrices +*/ CV_EXPORTS void swap(Mat& a, Mat& b); - -//! swaps two umatrices +/** @overload */ CV_EXPORTS void swap( UMat& a, UMat& b ); -//! 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p. +//! @} core + +//! @addtogroup core_array +//! @{ + +/** @brief Computes the source location of an extrapolated pixel. + +The function computes and returns the coordinate of a donor pixel corresponding to the specified +extrapolated pixel when using the specified extrapolation border mode. For example, if you use +cv::BORDER_WRAP mode in the horizontal direction, cv::BORDER_REFLECT_101 in the vertical direction and +want to compute value of the "virtual" pixel Point(-5, 100) in a floating-point image img , it +looks like: +@code{.cpp} + float val = img.at(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101), + borderInterpolate(-5, img.cols, cv::BORDER_WRAP)); +@endcode +Normally, the function is not called directly. It is used inside filtering functions and also in +copyMakeBorder. +@param p 0-based coordinate of the extrapolated pixel along one of the axes, likely \<0 or \>= len +@param len Length of the array along the corresponding axis. +@param borderType Border type, one of the cv::BorderTypes, except for cv::BORDER_TRANSPARENT and +cv::BORDER_ISOLATED . When borderType==cv::BORDER_CONSTANT , the function always returns -1, regardless +of p and len. + +@sa copyMakeBorder +*/ CV_EXPORTS_W int borderInterpolate(int p, int len, int borderType); -//! copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode +/** @brief Forms a border around an image. + +The function copies the source image into the middle of the destination image. The areas to the +left, to the right, above and below the copied source image will be filled with extrapolated +pixels. This is not what filtering functions based on it do (they extrapolate pixels on-fly), but +what other more complex functions, including your own, may do to simplify image boundary handling. + +The function supports the mode when src is already in the middle of dst . In this case, the +function does not copy src itself but simply constructs the border, for example: + +@code{.cpp} + // let border be the same in all directions + int border=2; + // constructs a larger image to fit both the image and the border + Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth()); + // select the middle part of it w/o copying data + Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows)); + // convert image from RGB to grayscale + cvtColor(rgb, gray, COLOR_RGB2GRAY); + // form a border in-place + copyMakeBorder(gray, gray_buf, border, border, + border, border, BORDER_REPLICATE); + // now do some custom filtering ... + ... +@endcode +@note When the source image is a part (ROI) of a bigger image, the function will try to use the +pixels outside of the ROI to form a border. To disable this feature and always do extrapolation, as +if src was not a ROI, use borderType | BORDER_ISOLATED. + +@param src Source image. +@param dst Destination image of the same type as src and the size Size(src.cols+left+right, +src.rows+top+bottom) . +@param top +@param bottom +@param left +@param right Parameter specifying how many pixels in each direction from the source image rectangle +to extrapolate. For example, top=1, bottom=1, left=1, right=1 mean that 1 pixel-wide border needs +to be built. +@param borderType Border type. See borderInterpolate for details. +@param value Border value if borderType==BORDER_CONSTANT . + +@sa borderInterpolate +*/ CV_EXPORTS_W void copyMakeBorder(InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar& value = Scalar() ); -//! adds one matrix to another (dst = src1 + src2) +/** @brief Calculates the per-element sum of two arrays or an array and a scalar. + +The function add calculates: +- Sum of two arrays when both input arrays have the same size and the same number of channels: +\f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\f] +- Sum of an array and a scalar when src2 is constructed from Scalar or has the same number of +elements as `src1.channels()`: +\f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) + \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\f] +- Sum of a scalar and an array when src1 is constructed from Scalar or has the same number of +elements as `src2.channels()`: +\f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} + \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\f] +where `I` is a multi-dimensional index of array elements. In case of multi-channel arrays, each +channel is processed independently. + +The first function in the list above can be replaced with matrix expressions: +@code{.cpp} + dst = src1 + src2; + dst += src1; // equivalent to add(dst, src1, dst); +@endcode +The input arrays and the output array can all have the same or different depths. For example, you +can add a 16-bit unsigned array to a 8-bit signed array and store the sum as a 32-bit +floating-point array. Depth of the output array is determined by the dtype parameter. In the second +and third cases above, as well as in the first case, when src1.depth() == src2.depth(), dtype can +be set to the default -1. In this case, the output array will have the same depth as the input +array, be it src1, src2 or both. +@note Saturation is not applied when the output array has the depth CV_32S. You may even get +result of an incorrect sign in the case of overflow. +@param src1 first input array or a scalar. +@param src2 second input array or a scalar. +@param dst output array that has the same size and number of channels as the input array(s); the +depth is defined by dtype or src1/src2. +@param mask optional operation mask - 8-bit single channel array, that specifies elements of the +output array to be changed. +@param dtype optional depth of the output array (see the discussion below). +@sa subtract, addWeighted, scaleAdd, Mat::convertTo +*/ CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst, InputArray mask = noArray(), int dtype = -1); -//! subtracts one matrix from another (dst = src1 - src2) +/** @brief Calculates the per-element difference between two arrays or array and a scalar. + +The function subtract calculates: +- Difference between two arrays, when both input arrays have the same size and the same number of +channels: + \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2}(I)) \quad \texttt{if mask}(I) \ne0\f] +- Difference between an array and a scalar, when src2 is constructed from Scalar or has the same +number of elements as `src1.channels()`: + \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1}(I) - \texttt{src2} ) \quad \texttt{if mask}(I) \ne0\f] +- Difference between a scalar and an array, when src1 is constructed from Scalar or has the same +number of elements as `src2.channels()`: + \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src1} - \texttt{src2}(I) ) \quad \texttt{if mask}(I) \ne0\f] +- The reverse difference between a scalar and an array in the case of `SubRS`: + \f[\texttt{dst}(I) = \texttt{saturate} ( \texttt{src2} - \texttt{src1}(I) ) \quad \texttt{if mask}(I) \ne0\f] +where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each +channel is processed independently. + +The first function in the list above can be replaced with matrix expressions: +@code{.cpp} + dst = src1 - src2; + dst -= src1; // equivalent to subtract(dst, src1, dst); +@endcode +The input arrays and the output array can all have the same or different depths. For example, you +can subtract to 8-bit unsigned arrays and store the difference in a 16-bit signed array. Depth of +the output array is determined by dtype parameter. In the second and third cases above, as well as +in the first case, when src1.depth() == src2.depth(), dtype can be set to the default -1. In this +case the output array will have the same depth as the input array, be it src1, src2 or both. +@note Saturation is not applied when the output array has the depth CV_32S. You may even get +result of an incorrect sign in the case of overflow. +@param src1 first input array or a scalar. +@param src2 second input array or a scalar. +@param dst output array of the same size and the same number of channels as the input array. +@param mask optional operation mask; this is an 8-bit single channel array that specifies elements +of the output array to be changed. +@param dtype optional depth of the output array +@sa add, addWeighted, scaleAdd, Mat::convertTo + */ CV_EXPORTS_W void subtract(InputArray src1, InputArray src2, OutputArray dst, InputArray mask = noArray(), int dtype = -1); -//! computes element-wise weighted product of the two arrays (dst = scale*src1*src2) + +/** @brief Calculates the per-element scaled product of two arrays. + +The function multiply calculates the per-element product of two arrays: + +\f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{scale} \cdot \texttt{src1} (I) \cdot \texttt{src2} (I))\f] + +There is also a @ref MatrixExpressions -friendly variant of the first function. See Mat::mul . + +For a not-per-element matrix product, see gemm . + +@note Saturation is not applied when the output array has the depth +CV_32S. You may even get result of an incorrect sign in the case of +overflow. +@param src1 first input array. +@param src2 second input array of the same size and the same type as src1. +@param dst output array of the same size and type as src1. +@param scale optional scale factor. +@param dtype optional depth of the output array +@sa add, subtract, divide, scaleAdd, addWeighted, accumulate, accumulateProduct, accumulateSquare, +Mat::convertTo +*/ CV_EXPORTS_W void multiply(InputArray src1, InputArray src2, OutputArray dst, double scale = 1, int dtype = -1); -//! computes element-wise weighted quotient of the two arrays (dst = scale * src1 / src2) +/** @brief Performs per-element division of two arrays or a scalar by an array. + +The functions divide divide one array by another: +\f[\texttt{dst(I) = saturate(src1(I)*scale/src2(I))}\f] +or a scalar by an array when there is no src1 : +\f[\texttt{dst(I) = saturate(scale/src2(I))}\f] + +When src2(I) is zero, dst(I) will also be zero. Different channels of +multi-channel arrays are processed independently. + +@note Saturation is not applied when the output array has the depth CV_32S. You may even get +result of an incorrect sign in the case of overflow. +@param src1 first input array. +@param src2 second input array of the same size and type as src1. +@param scale scalar factor. +@param dst output array of the same size and type as src2. +@param dtype optional depth of the output array; if -1, dst will have depth src2.depth(), but in +case of an array-by-array division, you can only pass -1 when src1.depth()==src2.depth(). +@sa multiply, add, subtract +*/ CV_EXPORTS_W void divide(InputArray src1, InputArray src2, OutputArray dst, double scale = 1, int dtype = -1); -//! computes element-wise weighted reciprocal of an array (dst = scale/src2) +/** @overload */ CV_EXPORTS_W void divide(double scale, InputArray src2, OutputArray dst, int dtype = -1); -//! adds scaled array to another one (dst = alpha*src1 + src2) +/** @brief Calculates the sum of a scaled array and another array. + +The function scaleAdd is one of the classical primitive linear algebra operations, known as DAXPY +or SAXPY in [BLAS](http://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms). It calculates +the sum of a scaled array and another array: +\f[\texttt{dst} (I)= \texttt{scale} \cdot \texttt{src1} (I) + \texttt{src2} (I)\f] +The function can also be emulated with a matrix expression, for example: +@code{.cpp} + Mat A(3, 3, CV_64F); + ... + A.row(0) = A.row(1)*2 + A.row(2); +@endcode +@param src1 first input array. +@param alpha scale factor for the first array. +@param src2 second input array of the same size and type as src1. +@param dst output array of the same size and type as src1. +@sa add, addWeighted, subtract, Mat::dot, Mat::convertTo +*/ CV_EXPORTS_W void scaleAdd(InputArray src1, double alpha, InputArray src2, OutputArray dst); -//! computes weighted sum of two arrays (dst = alpha*src1 + beta*src2 + gamma) +/** @brief Calculates the weighted sum of two arrays. + +The function addWeighted calculates the weighted sum of two arrays as follows: +\f[\texttt{dst} (I)= \texttt{saturate} ( \texttt{src1} (I)* \texttt{alpha} + \texttt{src2} (I)* \texttt{beta} + \texttt{gamma} )\f] +where I is a multi-dimensional index of array elements. In case of multi-channel arrays, each +channel is processed independently. +The function can be replaced with a matrix expression: +@code{.cpp} + dst = src1*alpha + src2*beta + gamma; +@endcode +@note Saturation is not applied when the output array has the depth CV_32S. You may even get +result of an incorrect sign in the case of overflow. +@param src1 first input array. +@param alpha weight of the first array elements. +@param src2 second input array of the same size and channel number as src1. +@param beta weight of the second array elements. +@param gamma scalar added to each sum. +@param dst output array that has the same size and number of channels as the input arrays. +@param dtype optional depth of the output array; when both input arrays have the same depth, dtype +can be set to -1, which will be equivalent to src1.depth(). +@sa add, subtract, scaleAdd, Mat::convertTo +*/ CV_EXPORTS_W void addWeighted(InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype = -1); -//! scales array elements, computes absolute values and converts the results to 8-bit unsigned integers: dst(i)=saturate_castabs(src(i)*alpha+beta) +/** @brief Scales, calculates absolute values, and converts the result to 8-bit. + +On each element of the input array, the function convertScaleAbs +performs three operations sequentially: scaling, taking an absolute +value, conversion to an unsigned 8-bit type: +\f[\texttt{dst} (I)= \texttt{saturate\_cast} (| \texttt{src} (I)* \texttt{alpha} + \texttt{beta} |)\f] +In case of multi-channel arrays, the function processes each channel +independently. When the output is not 8-bit, the operation can be +emulated by calling the Mat::convertTo method (or by using matrix +expressions) and then by calculating an absolute value of the result. +For example: +@code{.cpp} + Mat_ A(30,30); + randu(A, Scalar(-100), Scalar(100)); + Mat_ B = A*5 + 3; + B = abs(B); + // Mat_ B = abs(A*5+3) will also do the job, + // but it will allocate a temporary matrix +@endcode +@param src input array. +@param dst output array. +@param alpha optional scale factor. +@param beta optional delta added to the scaled values. +@sa Mat::convertTo, cv::abs(const Mat&) +*/ CV_EXPORTS_W void convertScaleAbs(InputArray src, OutputArray dst, double alpha = 1, double beta = 0); -//! transforms array of numbers using a lookup table: dst(i)=lut(src(i)) +/** @brief Performs a look-up table transform of an array. + +The function LUT fills the output array with values from the look-up table. Indices of the entries +are taken from the input array. That is, the function processes each element of src as follows: +\f[\texttt{dst} (I) \leftarrow \texttt{lut(src(I) + d)}\f] +where +\f[d = \fork{0}{if \texttt{src} has depth \texttt{CV\_8U}}{128}{if \texttt{src} has depth \texttt{CV\_8S}}\f] +@param src input array of 8-bit elements. +@param lut look-up table of 256 elements; in case of multi-channel input array, the table should +either have a single channel (in this case the same table is used for all channels) or the same +number of channels as in the input array. +@param dst output array of the same size and number of channels as src, and the same depth as lut. +@sa convertScaleAbs, Mat::convertTo +*/ CV_EXPORTS_W void LUT(InputArray src, InputArray lut, OutputArray dst); -//! computes sum of array elements +/** @brief Calculates the sum of array elements. + +The functions sum calculate and return the sum of array elements, +independently for each channel. +@param src input array that must have from 1 to 4 channels. +@sa countNonZero, mean, meanStdDev, norm, minMaxLoc, reduce +*/ CV_EXPORTS_AS(sumElems) Scalar sum(InputArray src); -//! computes the number of nonzero array elements +/** @brief Counts non-zero array elements. + +The function returns the number of non-zero elements in src : +\f[\sum _{I: \; \texttt{src} (I) \ne0 } 1\f] +@param src single-channel array. +@sa mean, meanStdDev, norm, minMaxLoc, calcCovarMatrix +*/ CV_EXPORTS_W int countNonZero( InputArray src ); -//! returns the list of locations of non-zero pixels +/** @brief returns the list of locations of non-zero pixels +@todo document +*/ CV_EXPORTS_W void findNonZero( InputArray src, OutputArray idx ); -//! computes mean value of selected array elements +/** @brief Calculates an average (mean) of array elements. + +The function mean calculates the mean value M of array elements, +independently for each channel, and return it: +\f[\begin{array}{l} N = \sum _{I: \; \texttt{mask} (I) \ne 0} 1 \\ M_c = \left ( \sum _{I: \; \texttt{mask} (I) \ne 0}{ \texttt{mtx} (I)_c} \right )/N \end{array}\f] +When all the mask elements are 0's, the functions return Scalar::all(0) +@param src input array that should have from 1 to 4 channels so that the result can be stored in +Scalar_ . +@param mask optional operation mask. +@sa countNonZero, meanStdDev, norm, minMaxLoc +*/ CV_EXPORTS_W Scalar mean(InputArray src, InputArray mask = noArray()); -//! computes mean value and standard deviation of all or selected array elements +/** Calculates a mean and standard deviation of array elements. + +The function meanStdDev calculates the mean and the standard deviation M +of array elements independently for each channel and returns it via the +output parameters: +\f[\begin{array}{l} N = \sum _{I, \texttt{mask} (I) \ne 0} 1 \\ \texttt{mean} _c = \frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \texttt{src} (I)_c}{N} \\ \texttt{stddev} _c = \sqrt{\frac{\sum_{ I: \; \texttt{mask}(I) \ne 0} \left ( \texttt{src} (I)_c - \texttt{mean} _c \right )^2}{N}} \end{array}\f] +When all the mask elements are 0's, the functions return +mean=stddev=Scalar::all(0). +@note The calculated standard deviation is only the diagonal of the +complete normalized covariance matrix. If the full matrix is needed, you +can reshape the multi-channel array M x N to the single-channel array +M\*N x mtx.channels() (only possible when the matrix is continuous) and +then pass the matrix to calcCovarMatrix . +@param src input array that should have from 1 to 4 channels so that the results can be stored in +Scalar_ 's. +@param mean output parameter: calculated mean value. +@param stddev output parameter: calculateded standard deviation. +@param mask optional operation mask. +@sa countNonZero, mean, norm, minMaxLoc, calcCovarMatrix +*/ CV_EXPORTS_W void meanStdDev(InputArray src, OutputArray mean, OutputArray stddev, InputArray mask=noArray()); -//! computes norm of the selected array part +/** @brief Calculates an absolute array norm, an absolute difference norm, or a +relative difference norm. + +The functions norm calculate an absolute norm of src1 (when there is no +src2 ): + +\f[norm = \forkthree{\|\texttt{src1}\|_{L_{\infty}} = \max _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM\_INF}\) } +{ \| \texttt{src1} \| _{L_1} = \sum _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM\_L1}\) } +{ \| \texttt{src1} \| _{L_2} = \sqrt{\sum_I \texttt{src1}(I)^2} }{if \(\texttt{normType} = \texttt{NORM\_L2}\) }\f] + +or an absolute or relative difference norm if src2 is there: + +\f[norm = \forkthree{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} = \max _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM\_INF}\) } +{ \| \texttt{src1} - \texttt{src2} \| _{L_1} = \sum _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM\_L1}\) } +{ \| \texttt{src1} - \texttt{src2} \| _{L_2} = \sqrt{\sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2} }{if \(\texttt{normType} = \texttt{NORM\_L2}\) }\f] + +or + +\f[norm = \forkthree{\frac{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} }{\|\texttt{src2}\|_{L_{\infty}} }}{if \(\texttt{normType} = \texttt{NORM\_RELATIVE\_INF}\) } +{ \frac{\|\texttt{src1}-\texttt{src2}\|_{L_1} }{\|\texttt{src2}\|_{L_1}} }{if \(\texttt{normType} = \texttt{NORM\_RELATIVE\_L1}\) } +{ \frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}} }{if \(\texttt{normType} = \texttt{NORM\_RELATIVE\_L2}\) }\f] + +The functions norm return the calculated norm. + +When the mask parameter is specified and it is not empty, the norm is +calculated only over the region specified by the mask. + +A multi-channel input arrays are treated as a single-channel, that is, +the results for all channels are combined. + +@param src1 first input array. +@param normType type of the norm (see cv::NormTypes). +@param mask optional operation mask; it must have the same size as src1 and CV_8UC1 type. +*/ CV_EXPORTS_W double norm(InputArray src1, int normType = NORM_L2, InputArray mask = noArray()); -//! computes norm of selected part of the difference between two arrays +/** @overload +@param src1 first input array. +@param src2 second input array of the same size and the same type as src1. +@param normType type of the norm (cv::NormTypes). +@param mask optional operation mask; it must have the same size as src1 and CV_8UC1 type. +*/ CV_EXPORTS_W double norm(InputArray src1, InputArray src2, int normType = NORM_L2, InputArray mask = noArray()); +/** @overload +@param src first input array. +@param normType type of the norm (see cv::NormTypes). +*/ +CV_EXPORTS double norm( const SparseMat& src, int normType ); -//! computes PSNR image/video quality metric +/** @brief computes PSNR image/video quality metric + +see http://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio for details +@todo document + */ CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2); -//! computes norm of a sparse matrix -CV_EXPORTS double norm( const SparseMat& src, int normType ); +/** @brief naive nearest neighbor finder -//! naive nearest neighbor finder +see http://en.wikipedia.org/wiki/Nearest_neighbor_search +@todo document + */ CV_EXPORTS_W void batchDistance(InputArray src1, InputArray src2, OutputArray dist, int dtype, OutputArray nidx, int normType = NORM_L2, int K = 0, InputArray mask = noArray(), int update = 0, bool crosscheck = false); -//! scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values +/** @brief Normalizes the norm or value range of an array. + +The functions normalize scale and shift the input array elements so that +\f[\| \texttt{dst} \| _{L_p}= \texttt{alpha}\f] +(where p=Inf, 1 or 2) when normType=NORM_INF, NORM_L1, or NORM_L2, respectively; or so that +\f[\min _I \texttt{dst} (I)= \texttt{alpha} , \, \, \max _I \texttt{dst} (I)= \texttt{beta}\f] + +when normType=NORM_MINMAX (for dense arrays only). The optional mask specifies a sub-array to be +normalized. This means that the norm or min-n-max are calculated over the sub-array, and then this +sub-array is modified to be normalized. If you want to only use the mask to calculate the norm or +min-max but modify the whole array, you can use norm and Mat::convertTo. + +In case of sparse matrices, only the non-zero values are analyzed and transformed. Because of this, +the range transformation for sparse matrices is not allowed since it can shift the zero level. + +@param src input array. +@param dst output array of the same size as src . +@param alpha norm value to normalize to or the lower range boundary in case of the range +normalization. +@param beta upper range boundary in case of the range normalization; it is not used for the norm +normalization. +@param norm_type normalization type (see cv::NormTypes). +@param dtype when negative, the output array has the same type as src; otherwise, it has the same +number of channels as src and the depth =CV_MAT_DEPTH(dtype). +@param mask optional operation mask. +@sa norm, Mat::convertTo, SparseMat::convertTo +*/ CV_EXPORTS_W void normalize( InputArray src, InputOutputArray dst, double alpha = 1, double beta = 0, int norm_type = NORM_L2, int dtype = -1, InputArray mask = noArray()); -//! scales and shifts array elements so that either the specified norm (alpha) or the minimum (alpha) and maximum (beta) array values get the specified values +/** @overload +@param src input array. +@param dst output array of the same size as src . +@param alpha norm value to normalize to or the lower range boundary in case of the range +normalization. +@param normType normalization type (see cv::NormTypes). +*/ CV_EXPORTS void normalize( const SparseMat& src, SparseMat& dst, double alpha, int normType ); -//! finds global minimum and maximum array elements and returns their values and their locations +/** @brief Finds the global minimum and maximum in an array. + +The functions minMaxLoc find the minimum and maximum element values and their positions. The +extremums are searched across the whole array or, if mask is not an empty array, in the specified +array region. + +The functions do not work with multi-channel arrays. If you need to find minimum or maximum +elements across all the channels, use Mat::reshape first to reinterpret the array as +single-channel. Or you may extract the particular channel using either extractImageCOI , or +mixChannels , or split . +@param src input single-channel array. +@param minVal pointer to the returned minimum value; NULL is used if not required. +@param maxVal pointer to the returned maximum value; NULL is used if not required. +@param minLoc pointer to the returned minimum location (in 2D case); NULL is used if not required. +@param maxLoc pointer to the returned maximum location (in 2D case); NULL is used if not required. +@param mask optional mask used to select a sub-array. +@sa max, min, compare, inRange, extractImageCOI, mixChannels, split, Mat::reshape +*/ CV_EXPORTS_W void minMaxLoc(InputArray src, CV_OUT double* minVal, CV_OUT double* maxVal = 0, CV_OUT Point* minLoc = 0, CV_OUT Point* maxLoc = 0, InputArray mask = noArray()); + +/** @brief Finds the global minimum and maximum in an array + +The function minMaxIdx finds the minimum and maximum element values and their positions. The +extremums are searched across the whole array or, if mask is not an empty array, in the specified +array region. The function does not work with multi-channel arrays. If you need to find minimum or +maximum elements across all the channels, use Mat::reshape first to reinterpret the array as +single-channel. Or you may extract the particular channel using either extractImageCOI , or +mixChannels , or split . In case of a sparse matrix, the minimum is found among non-zero elements +only. +@note When minIdx is not NULL, it must have at least 2 elements (as well as maxIdx), even if src is +a single-row or single-column matrix. In OpenCV (following MATLAB) each array has at least 2 +dimensions, i.e. single-column matrix is Mx1 matrix (and therefore minIdx/maxIdx will be +(i1,0)/(i2,0)) and single-row matrix is 1xN matrix (and therefore minIdx/maxIdx will be +(0,j1)/(0,j2)). +@param src input single-channel array. +@param minVal pointer to the returned minimum value; NULL is used if not required. +@param maxVal pointer to the returned maximum value; NULL is used if not required. +@param minIdx pointer to the returned minimum location (in nD case); NULL is used if not required; +Otherwise, it must point to an array of src.dims elements, the coordinates of the minimum element +in each dimension are stored there sequentially. +@param maxIdx pointer to the returned maximum location (in nD case). NULL is used if not required. +@param mask specified array region +*/ CV_EXPORTS void minMaxIdx(InputArray src, double* minVal, double* maxVal = 0, int* minIdx = 0, int* maxIdx = 0, InputArray mask = noArray()); -//! finds global minimum and maximum sparse array elements and returns their values and their locations +/** @overload +@param a input single-channel array. +@param minVal pointer to the returned minimum value; NULL is used if not required. +@param maxVal pointer to the returned maximum value; NULL is used if not required. +@param minIdx pointer to the returned minimum location (in nD case); NULL is used if not required; +Otherwise, it must point to an array of src.dims elements, the coordinates of the minimum element +in each dimension are stored there sequentially. +@param maxIdx pointer to the returned maximum location (in nD case). NULL is used if not required. +*/ CV_EXPORTS void minMaxLoc(const SparseMat& a, double* minVal, double* maxVal, int* minIdx = 0, int* maxIdx = 0); -//! transforms 2D matrix to 1D row or column vector by taking sum, minimum, maximum or mean value over all the rows +/** @brief Reduces a matrix to a vector. + +The function reduce reduces the matrix to a vector by treating the matrix rows/columns as a set of +1D vectors and performing the specified operation on the vectors until a single row/column is +obtained. For example, the function can be used to compute horizontal and vertical projections of a +raster image. In case of REDUCE_SUM and REDUCE_AVG , the output may have a larger element +bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction +modes. +@param src input 2D matrix. +@param dst output vector. Its size and type is defined by dim and dtype parameters. +@param dim dimension index along which the matrix is reduced. 0 means that the matrix is reduced to +a single row. 1 means that the matrix is reduced to a single column. +@param rtype reduction operation that could be one of cv::ReduceTypes +@param dtype when negative, the output vector will have the same type as the input matrix, +otherwise, its type will be CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()). +@sa repeat +*/ CV_EXPORTS_W void reduce(InputArray src, OutputArray dst, int dim, int rtype, int dtype = -1); -//! makes multi-channel array out of several single-channel arrays +/** @brief Creates one multichannel array out of several single-channel ones. + +The functions merge merge several arrays to make a single multi-channel array. That is, each +element of the output array will be a concatenation of the elements of the input arrays, where +elements of i-th input array are treated as mv[i].channels()-element vectors. + +The function split does the reverse operation. If you need to shuffle channels in some other +advanced way, use mixChannels . +@param mv input array of matrices to be merged; all the matrices in mv must have the same +size and the same depth. +@param count number of input matrices when mv is a plain C array; it must be greater than zero. +@param dst output array of the same size and the same depth as mv[0]; The number of channels will +be the total number of channels in the matrix array. +@sa mixChannels, split, Mat::reshape +*/ CV_EXPORTS void merge(const Mat* mv, size_t count, OutputArray dst); -//! makes multi-channel array out of several single-channel arrays +/** @overload +@param mv input vector of matrices to be merged; all the matrices in mv must have the same +size and the same depth. +@param dst output array of the same size and the same depth as mv[0]; The number of channels will +be the total number of channels in the matrix array. + */ CV_EXPORTS_W void merge(InputArrayOfArrays mv, OutputArray dst); -//! copies each plane of a multi-channel array to a dedicated array +/** @brief Divides a multi-channel array into several single-channel arrays. + +The functions split split a multi-channel array into separate single-channel arrays: +\f[\texttt{mv} [c](I) = \texttt{src} (I)_c\f] +If you need to extract a single channel or do some other sophisticated channel permutation, use +mixChannels . +@param src input multi-channel array. +@param mvbegin output array; the number of arrays must match src.channels(); the arrays themselves are +reallocated, if needed. +@sa merge, mixChannels, cvtColor +*/ CV_EXPORTS void split(const Mat& src, Mat* mvbegin); -//! copies each plane of a multi-channel array to a dedicated array +/** @overload +@param m input multi-channel array. +@param mv output vector of arrays; the arrays themselves are reallocated, if needed. +*/ CV_EXPORTS_W void split(InputArray m, OutputArrayOfArrays mv); -//! copies selected channels from the input arrays to the selected channels of the output arrays +/** @brief Copies specified channels from input arrays to the specified channels of +output arrays. + +The functions mixChannels provide an advanced mechanism for shuffling image channels. + +split and merge and some forms of cvtColor are partial cases of mixChannels . + +In the example below, the code splits a 4-channel RGBA image into a 3-channel BGR (with R and B +channels swapped) and a separate alpha-channel image: +@code{.cpp} + Mat rgba( 100, 100, CV_8UC4, Scalar(1,2,3,4) ); + Mat bgr( rgba.rows, rgba.cols, CV_8UC3 ); + Mat alpha( rgba.rows, rgba.cols, CV_8UC1 ); + + // forming an array of matrices is a quite efficient operation, + // because the matrix data is not copied, only the headers + Mat out[] = { bgr, alpha }; + // rgba[0] -> bgr[2], rgba[1] -> bgr[1], + // rgba[2] -> bgr[0], rgba[3] -> alpha[0] + int from_to[] = { 0,2, 1,1, 2,0, 3,3 }; + mixChannels( &rgba, 1, out, 2, from_to, 4 ); +@endcode +@note Unlike many other new-style C++ functions in OpenCV (see the introduction section and +Mat::create ), mixChannels requires the output arrays to be pre-allocated before calling the +function. +@param src input array or vector of matricesl; all of the matrices must have the same size and the +same depth. +@param nsrcs number of matrices in src. +@param dst output array or vector of matrices; all the matrices *must be allocated*; their size and +depth must be the same as in src[0]. +@param ndsts number of matrices in dst. +@param fromTo array of index pairs specifying which channels are copied and where; fromTo[k\*2] is +a 0-based index of the input channel in src, fromTo[k\*2+1] is an index of the output channel in +dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to +src[0].channels()-1, the second input image channels are indexed from src[0].channels() to +src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image +channels; as a special case, when fromTo[k\*2] is negative, the corresponding output channel is +filled with zero . +@param npairs number of index pairs in fromTo. +@sa split, merge, cvtColor +*/ CV_EXPORTS void mixChannels(const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, const int* fromTo, size_t npairs); +/** @overload +@param src input array or vector of matricesl; all of the matrices must have the same size and the +same depth. +@param dst output array or vector of matrices; all the matrices *must be allocated*; their size and +depth must be the same as in src[0]. +@param fromTo array of index pairs specifying which channels are copied and where; fromTo[k\*2] is +a 0-based index of the input channel in src, fromTo[k\*2+1] is an index of the output channel in +dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to +src[0].channels()-1, the second input image channels are indexed from src[0].channels() to +src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image +channels; as a special case, when fromTo[k\*2] is negative, the corresponding output channel is +filled with zero . +@param npairs number of index pairs in fromTo. +*/ CV_EXPORTS void mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst, const int* fromTo, size_t npairs); +/** @overload +@param src input array or vector of matricesl; all of the matrices must have the same size and the +same depth. +@param dst output array or vector of matrices; all the matrices *must be allocated*; their size and +depth must be the same as in src[0]. +@param fromTo array of index pairs specifying which channels are copied and where; fromTo[k\*2] is +a 0-based index of the input channel in src, fromTo[k\*2+1] is an index of the output channel in +dst; the continuous channel numbering is used: the first input image channels are indexed from 0 to +src[0].channels()-1, the second input image channels are indexed from src[0].channels() to +src[0].channels() + src[1].channels()-1, and so on, the same scheme is used for the output image +channels; as a special case, when fromTo[k\*2] is negative, the corresponding output channel is +filled with zero . +*/ CV_EXPORTS_W void mixChannels(InputArrayOfArrays src, InputOutputArrayOfArrays dst, const std::vector& fromTo); -//! extracts a single channel from src (coi is 0-based index) +/** @brief extracts a single channel from src (coi is 0-based index) +@todo document +*/ CV_EXPORTS_W void extractChannel(InputArray src, OutputArray dst, int coi); -//! inserts a single channel to dst (coi is 0-based index) +/** @brief inserts a single channel to dst (coi is 0-based index) +@todo document +*/ CV_EXPORTS_W void insertChannel(InputArray src, InputOutputArray dst, int coi); -//! reverses the order of the rows, columns or both in a matrix +/** @brief Flips a 2D array around vertical, horizontal, or both axes. + +The function flip flips the array in one of three different ways (row +and column indices are 0-based): +\f[\texttt{dst} _{ij} = +\left\{ +\begin{array}{l l} +\texttt{src} _{\texttt{src.rows}-i-1,j} & if\; \texttt{flipCode} = 0 \\ +\texttt{src} _{i, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} > 0 \\ +\texttt{src} _{ \texttt{src.rows} -i-1, \texttt{src.cols} -j-1} & if\; \texttt{flipCode} < 0 \\ +\end{array} +\right.\f] +The example scenarios of using the function are the following: +* Vertical flipping of the image (flipCode == 0) to switch between + top-left and bottom-left image origin. This is a typical operation + in video processing on Microsoft Windows\* OS. +* Horizontal flipping of the image with the subsequent horizontal + shift and absolute difference calculation to check for a + vertical-axis symmetry (flipCode \> 0). +* Simultaneous horizontal and vertical flipping of the image with + the subsequent shift and absolute difference calculation to check + for a central symmetry (flipCode \< 0). +* Reversing the order of point arrays (flipCode \> 0 or + flipCode == 0). +@param src input array. +@param dst output array of the same size and type as src. +@param flipCode a flag to specify how to flip the array; 0 means +flipping around the x-axis and positive value (for example, 1) means +flipping around y-axis. Negative value (for example, -1) means flipping +around both axes. +@sa transpose , repeat , completeSymm +*/ CV_EXPORTS_W void flip(InputArray src, OutputArray dst, int flipCode); -//! replicates the input matrix the specified number of times in the horizontal and/or vertical direction +/** @brief Fills the output array with repeated copies of the input array. + +The functions repeat duplicate the input array one or more times along each of the two axes: +\f[\texttt{dst} _{ij}= \texttt{src} _{i\mod src.rows, \; j\mod src.cols }\f] +The second variant of the function is more convenient to use with @ref MatrixExpressions. +@param src input array to replicate. +@param dst output array of the same type as src. +@param ny Flag to specify how many times the src is repeated along the +vertical axis. +@param nx Flag to specify how many times the src is repeated along the +horizontal axis. +@sa reduce +*/ CV_EXPORTS_W void repeat(InputArray src, int ny, int nx, OutputArray dst); +/** @overload +@param src input array to replicate. +@param ny Flag to specify how many times the src is repeated along the +vertical axis. +@param nx Flag to specify how many times the src is repeated along the +horizontal axis. + */ CV_EXPORTS Mat repeat(const Mat& src, int ny, int nx); +/** @brief concatenate matrices horizontally +@todo document +*/ CV_EXPORTS void hconcat(const Mat* src, size_t nsrc, OutputArray dst); - +/** @overload */ CV_EXPORTS void hconcat(InputArray src1, InputArray src2, OutputArray dst); - +/** @overload */ CV_EXPORTS_W void hconcat(InputArrayOfArrays src, OutputArray dst); +/** @brief concatenate matrices vertically +@todo document +*/ CV_EXPORTS void vconcat(const Mat* src, size_t nsrc, OutputArray dst); - +/** @overload */ CV_EXPORTS void vconcat(InputArray src1, InputArray src2, OutputArray dst); - +/** @overload */ CV_EXPORTS_W void vconcat(InputArrayOfArrays src, OutputArray dst); -//! computes bitwise conjunction of the two arrays (dst = src1 & src2) +/** @brief computes bitwise conjunction of the two arrays (dst = src1 & src2) +Calculates the per-element bit-wise conjunction of two arrays or an +array and a scalar. + +The function calculates the per-element bit-wise logical conjunction for: +* Two arrays when src1 and src2 have the same size: + \f[\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] +* An array and a scalar when src2 is constructed from Scalar or has + the same number of elements as `src1.channels()`: + \f[\texttt{dst} (I) = \texttt{src1} (I) \wedge \texttt{src2} \quad \texttt{if mask} (I) \ne0\f] +* A scalar and an array when src1 is constructed from Scalar or has + the same number of elements as `src2.channels()`: + \f[\texttt{dst} (I) = \texttt{src1} \wedge \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] +In case of floating-point arrays, their machine-specific bit +representations (usually IEEE754-compliant) are used for the operation. +In case of multi-channel arrays, each channel is processed +independently. In the second and third cases above, the scalar is first +converted to the array type. +@param src1 first input array or a scalar. +@param src2 second input array or a scalar. +@param dst output array that has the same size and type as the input +arrays. +@param mask optional operation mask, 8-bit single channel array, that +specifies elements of the output array to be changed. +*/ CV_EXPORTS_W void bitwise_and(InputArray src1, InputArray src2, OutputArray dst, InputArray mask = noArray()); -//! computes bitwise disjunction of the two arrays (dst = src1 | src2) +/** @brief Calculates the per-element bit-wise disjunction of two arrays or an +array and a scalar. + +The function calculates the per-element bit-wise logical disjunction for: +* Two arrays when src1 and src2 have the same size: + \f[\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] +* An array and a scalar when src2 is constructed from Scalar or has + the same number of elements as `src1.channels()`: + \f[\texttt{dst} (I) = \texttt{src1} (I) \vee \texttt{src2} \quad \texttt{if mask} (I) \ne0\f] +* A scalar and an array when src1 is constructed from Scalar or has + the same number of elements as `src2.channels()`: + \f[\texttt{dst} (I) = \texttt{src1} \vee \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] +In case of floating-point arrays, their machine-specific bit +representations (usually IEEE754-compliant) are used for the operation. +In case of multi-channel arrays, each channel is processed +independently. In the second and third cases above, the scalar is first +converted to the array type. +@param src1 first input array or a scalar. +@param src2 second input array or a scalar. +@param dst output array that has the same size and type as the input +arrays. +@param mask optional operation mask, 8-bit single channel array, that +specifies elements of the output array to be changed. +*/ CV_EXPORTS_W void bitwise_or(InputArray src1, InputArray src2, OutputArray dst, InputArray mask = noArray()); -//! computes bitwise exclusive-or of the two arrays (dst = src1 ^ src2) +/** @brief Calculates the per-element bit-wise "exclusive or" operation on two +arrays or an array and a scalar. + +The function calculates the per-element bit-wise logical "exclusive-or" +operation for: +* Two arrays when src1 and src2 have the same size: + \f[\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] +* An array and a scalar when src2 is constructed from Scalar or has + the same number of elements as `src1.channels()`: + \f[\texttt{dst} (I) = \texttt{src1} (I) \oplus \texttt{src2} \quad \texttt{if mask} (I) \ne0\f] +* A scalar and an array when src1 is constructed from Scalar or has + the same number of elements as `src2.channels()`: + \f[\texttt{dst} (I) = \texttt{src1} \oplus \texttt{src2} (I) \quad \texttt{if mask} (I) \ne0\f] +In case of floating-point arrays, their machine-specific bit +representations (usually IEEE754-compliant) are used for the operation. +In case of multi-channel arrays, each channel is processed +independently. In the 2nd and 3rd cases above, the scalar is first +converted to the array type. +@param src1 first input array or a scalar. +@param src2 second input array or a scalar. +@param dst output array that has the same size and type as the input +arrays. +@param mask optional operation mask, 8-bit single channel array, that +specifies elements of the output array to be changed. +*/ CV_EXPORTS_W void bitwise_xor(InputArray src1, InputArray src2, OutputArray dst, InputArray mask = noArray()); -//! inverts each bit of array (dst = ~src) +/** @brief Inverts every bit of an array. + +The function calculates per-element bit-wise inversion of the input +array: +\f[\texttt{dst} (I) = \neg \texttt{src} (I)\f] +In case of a floating-point input array, its machine-specific bit +representation (usually IEEE754-compliant) is used for the operation. In +case of multi-channel arrays, each channel is processed independently. +@param src input array. +@param dst output array that has the same size and type as the input +array. +@param mask optional operation mask, 8-bit single channel array, that +specifies elements of the output array to be changed. +*/ CV_EXPORTS_W void bitwise_not(InputArray src, OutputArray dst, InputArray mask = noArray()); -//! computes element-wise absolute difference of two arrays (dst = abs(src1 - src2)) +/** @brief Calculates the per-element absolute difference between two arrays or between an array and a scalar. + +The function absdiff calculates: +* Absolute difference between two arrays when they have the same + size and type: + \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2}(I)|)\f] +* Absolute difference between an array and a scalar when the second + array is constructed from Scalar or has as many elements as the + number of channels in `src1`: + \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1}(I) - \texttt{src2} |)\f] +* Absolute difference between a scalar and an array when the first + array is constructed from Scalar or has as many elements as the + number of channels in `src2`: + \f[\texttt{dst}(I) = \texttt{saturate} (| \texttt{src1} - \texttt{src2}(I) |)\f] + where I is a multi-dimensional index of array elements. In case of + multi-channel arrays, each channel is processed independently. +@note Saturation is not applied when the arrays have the depth CV_32S. +You may even get a negative value in the case of overflow. +@param src1 first input array or a scalar. +@param src2 second input array or a scalar. +@param dst output array that has the same size and type as input arrays. +@sa cv::abs(const Mat&) +*/ CV_EXPORTS_W void absdiff(InputArray src1, InputArray src2, OutputArray dst); -//! set mask elements for those array elements which are within the element-specific bounding box (dst = lowerb <= src && src < upperb) +/** @brief Checks if array elements lie between the elements of two other arrays. + +The function checks the range as follows: +- For every element of a single-channel input array: + \f[\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0\f] +- For two-channel arrays: + \f[\texttt{dst} (I)= \texttt{lowerb} (I)_0 \leq \texttt{src} (I)_0 \leq \texttt{upperb} (I)_0 \land \texttt{lowerb} (I)_1 \leq \texttt{src} (I)_1 \leq \texttt{upperb} (I)_1\f] +- and so forth. + +That is, dst (I) is set to 255 (all 1 -bits) if src (I) is within the +specified 1D, 2D, 3D, ... box and 0 otherwise. + +When the lower and/or upper boundary parameters are scalars, the indexes +(I) at lowerb and upperb in the above formulas should be omitted. +@param src first input array. +@param lowerb inclusive lower boundary array or a scalar. +@param upperb inclusive upper boundary array or a scalar. +@param dst output array of the same size as src and CV_8U type. +*/ CV_EXPORTS_W void inRange(InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst); -//! compares elements of two arrays (dst = src1 \ src2) +/** @brief Performs the per-element comparison of two arrays or an array and scalar value. + +The function compares: +* Elements of two arrays when src1 and src2 have the same size: + \f[\texttt{dst} (I) = \texttt{src1} (I) \,\texttt{cmpop}\, \texttt{src2} (I)\f] +* Elements of src1 with a scalar src2 when src2 is constructed from + Scalar or has a single element: + \f[\texttt{dst} (I) = \texttt{src1}(I) \,\texttt{cmpop}\, \texttt{src2}\f] +* src1 with elements of src2 when src1 is constructed from Scalar or + has a single element: + \f[\texttt{dst} (I) = \texttt{src1} \,\texttt{cmpop}\, \texttt{src2} (I)\f] +When the comparison result is true, the corresponding element of output +array is set to 255. The comparison operations can be replaced with the +equivalent matrix expressions: +@code{.cpp} + Mat dst1 = src1 >= src2; + Mat dst2 = src1 < 8; + ... +@endcode +@param src1 first input array or a scalar; when it is an array, it must have a single channel. +@param src2 second input array or a scalar; when it is an array, it must have a single channel. +@param dst output array that has the same size and type as the input arrays. +@param cmpop a flag, that specifies correspondence between the arrays (cv::CmpTypes) +@sa checkRange, min, max, threshold +*/ CV_EXPORTS_W void compare(InputArray src1, InputArray src2, OutputArray dst, int cmpop); -//! computes per-element minimum of two arrays (dst = min(src1, src2)) +/** @brief Calculates per-element minimum of two arrays or an array and a scalar. + +The functions min calculate the per-element minimum of two arrays: +\f[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{src2} (I))\f] +or array and a scalar: +\f[\texttt{dst} (I)= \min ( \texttt{src1} (I), \texttt{value} )\f] +@param src1 first input array. +@param src2 second input array of the same size and type as src1. +@param dst output array of the same size and type as src1. +@sa max, compare, inRange, minMaxLoc +*/ CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst); +/** @overload +needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare) +*/ +CV_EXPORTS void min(const Mat& src1, const Mat& src2, Mat& dst); +/** @overload +needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare) +*/ +CV_EXPORTS void min(const UMat& src1, const UMat& src2, UMat& dst); -//! computes per-element maximum of two arrays (dst = max(src1, src2)) -CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst); +/** @brief Calculates per-element maximum of two arrays or an array and a scalar. -// the following overloads are needed to avoid conflicts with -// const _Tp& std::min(const _Tp&, const _Tp&, _Compare) -//! computes per-element minimum of two arrays (dst = min(src1, src2)) -CV_EXPORTS void min(const Mat& src1, const Mat& src2, Mat& dst); -//! computes per-element maximum of two arrays (dst = max(src1, src2)) +The functions max calculate the per-element maximum of two arrays: +\f[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{src2} (I))\f] +or array and a scalar: +\f[\texttt{dst} (I)= \max ( \texttt{src1} (I), \texttt{value} )\f] +@param src1 first input array. +@param src2 second input array of the same size and type as src1 . +@param dst output array of the same size and type as src1. +@sa min, compare, inRange, minMaxLoc, @ref MatrixExpressions +*/ +CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst); +/** @overload +needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare) +*/ CV_EXPORTS void max(const Mat& src1, const Mat& src2, Mat& dst); -//! computes per-element minimum of two arrays (dst = min(src1, src2)) -CV_EXPORTS void min(const UMat& src1, const UMat& src2, UMat& dst); -//! computes per-element maximum of two arrays (dst = max(src1, src2)) +/** @overload +needed to avoid conflicts with const _Tp& std::min(const _Tp&, const _Tp&, _Compare) +*/ CV_EXPORTS void max(const UMat& src1, const UMat& src2, UMat& dst); -//! computes square root of each matrix element (dst = src**0.5) +/** @brief Calculates a square root of array elements. + +The functions sqrt calculate a square root of each input array element. +In case of multi-channel arrays, each channel is processed +independently. The accuracy is approximately the same as of the built-in +std::sqrt . +@param src input floating-point array. +@param dst output array of the same size and type as src. +*/ CV_EXPORTS_W void sqrt(InputArray src, OutputArray dst); -//! raises the input matrix elements to the specified power (b = a**power) +/** @brief Raises every array element to a power. + +The function pow raises every element of the input array to power : +\f[\texttt{dst} (I) = \fork{\texttt{src}(I)^power}{if \texttt{power} is integer}{|\texttt{src}(I)|^power}{otherwise}\f] + +So, for a non-integer power exponent, the absolute values of input array +elements are used. However, it is possible to get true values for +negative values using some extra operations. In the example below, +computing the 5th root of array src shows: +@code{.cpp} + Mat mask = src < 0; + pow(src, 1./5, dst); + subtract(Scalar::all(0), dst, dst, mask); +@endcode +For some values of power, such as integer values, 0.5 and -0.5, +specialized faster algorithms are used. + +Special values (NaN, Inf) are not handled. +@param src input array. +@param power exponent of power. +@param dst output array of the same size and type as src. +@sa sqrt, exp, log, cartToPolar, polarToCart +*/ CV_EXPORTS_W void pow(InputArray src, double power, OutputArray dst); -//! computes exponent of each matrix element (dst = e**src) +/** @brief Calculates the exponent of every array element. + +The function exp calculates the exponent of every element of the input +array: +\f[\texttt{dst} [I] = e^{ src(I) }\f] + +The maximum relative error is about 7e-6 for single-precision input and +less than 1e-10 for double-precision input. Currently, the function +converts denormalized values to zeros on output. Special values (NaN, +Inf) are not handled. +@param src input array. +@param dst output array of the same size and type as src. +@sa log , cartToPolar , polarToCart , phase , pow , sqrt , magnitude +*/ CV_EXPORTS_W void exp(InputArray src, OutputArray dst); -//! computes natural logarithm of absolute value of each matrix element: dst = log(abs(src)) +/** @brief Calculates the natural logarithm of every array element. + +The function log calculates the natural logarithm of the absolute value +of every element of the input array: +\f[\texttt{dst} (I) = \fork{\log |\texttt{src}(I)|}{if \(\texttt{src}(I) \ne 0\) }{\texttt{C}}{otherwise}\f] + +where C is a large negative number (about -700 in the current +implementation). The maximum relative error is about 7e-6 for +single-precision input and less than 1e-10 for double-precision input. +Special values (NaN, Inf) are not handled. +@param src input array. +@param dst output array of the same size and type as src . +@sa exp, cartToPolar, polarToCart, phase, pow, sqrt, magnitude +*/ CV_EXPORTS_W void log(InputArray src, OutputArray dst); -//! converts polar coordinates to Cartesian +/** @brief Calculates x and y coordinates of 2D vectors from their magnitude and angle. + +The function polarToCart calculates the Cartesian coordinates of each 2D +vector represented by the corresponding elements of magnitude and angle: +\f[\begin{array}{l} \texttt{x} (I) = \texttt{magnitude} (I) \cos ( \texttt{angle} (I)) \\ \texttt{y} (I) = \texttt{magnitude} (I) \sin ( \texttt{angle} (I)) \\ \end{array}\f] + +The relative accuracy of the estimated coordinates is about 1e-6. +@param magnitude input floating-point array of magnitudes of 2D vectors; +it can be an empty matrix (=Mat()), in this case, the function assumes +that all the magnitudes are =1; if it is not empty, it must have the +same size and type as angle. +@param angle input floating-point array of angles of 2D vectors. +@param x output array of x-coordinates of 2D vectors; it has the same +size and type as angle. +@param y output array of y-coordinates of 2D vectors; it has the same +size and type as angle. +@param angleInDegrees when true, the input angles are measured in +degrees, otherwise, they are measured in radians. +@sa cartToPolar, magnitude, phase, exp, log, pow, sqrt +*/ CV_EXPORTS_W void polarToCart(InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees = false); -//! converts Cartesian coordinates to polar +/** @brief Calculates the magnitude and angle of 2D vectors. + +The function cartToPolar calculates either the magnitude, angle, or both +for every 2D vector (x(I),y(I)): +\f[\begin{array}{l} \texttt{magnitude} (I)= \sqrt{\texttt{x}(I)^2+\texttt{y}(I)^2} , \\ \texttt{angle} (I)= \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))[ \cdot180 / \pi ] \end{array}\f] + +The angles are calculated with accuracy about 0.3 degrees. For the point +(0,0), the angle is set to 0. +@param x array of x-coordinates; this must be a single-precision or +double-precision floating-point array. +@param y array of y-coordinates, that must have the same size and same type as x. +@param magnitude output array of magnitudes of the same size and type as x. +@param angle output array of angles that has the same size and type as +x; the angles are measured in radians (from 0 to 2\*Pi) or in degrees (0 to 360 degrees). +@param angleInDegrees a flag, indicating whether the angles are measured +in radians (which is by default), or in degrees. +@sa Sobel, Scharr +*/ CV_EXPORTS_W void cartToPolar(InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees = false); -//! computes angle (angle(i)) of each (x(i), y(i)) vector +/** @brief Calculates the rotation angle of 2D vectors. + +The function phase calculates the rotation angle of each 2D vector that +is formed from the corresponding elements of x and y : +\f[\texttt{angle} (I) = \texttt{atan2} ( \texttt{y} (I), \texttt{x} (I))\f] + +The angle estimation accuracy is about 0.3 degrees. When x(I)=y(I)=0 , +the corresponding angle(I) is set to 0. +@param x input floating-point array of x-coordinates of 2D vectors. +@param y input array of y-coordinates of 2D vectors; it must have the +same size and the same type as x. +@param angle output array of vector angles; it has the same size and +same type as x . +@param angleInDegrees when true, the function calculates the angle in +degrees, otherwise, they are measured in radians. +*/ CV_EXPORTS_W void phase(InputArray x, InputArray y, OutputArray angle, bool angleInDegrees = false); -//! computes magnitude (magnitude(i)) of each (x(i), y(i)) vector +/** @brief Calculates the magnitude of 2D vectors. + +The function magnitude calculates the magnitude of 2D vectors formed +from the corresponding elements of x and y arrays: +\f[\texttt{dst} (I) = \sqrt{\texttt{x}(I)^2 + \texttt{y}(I)^2}\f] +@param x floating-point array of x-coordinates of the vectors. +@param y floating-point array of y-coordinates of the vectors; it must +have the same size as x. +@param magnitude output array of the same size and type as x. +@sa cartToPolar, polarToCart, phase, sqrt +*/ CV_EXPORTS_W void magnitude(InputArray x, InputArray y, OutputArray magnitude); -//! checks that each matrix element is within the specified range. +/** @brief Checks every element of an input array for invalid values. + +The functions checkRange check that every array element is neither NaN nor infinite. When minVal \< +-DBL_MAX and maxVal \< DBL_MAX, the functions also check that each value is between minVal and +maxVal. In case of multi-channel arrays, each channel is processed independently. If some values +are out of range, position of the first outlier is stored in pos (when pos != NULL). Then, the +functions either return false (when quiet=true) or throw an exception. +@param a input array. +@param quiet a flag, indicating whether the functions quietly return false when the array elements +are out of range or they throw an exception. +@param pos optional output parameter, when not NULL, must be a pointer to array of src.dims +elements. +@param minVal inclusive lower boundary of valid values range. +@param maxVal exclusive upper boundary of valid values range. +*/ CV_EXPORTS_W bool checkRange(InputArray a, bool quiet = true, CV_OUT Point* pos = 0, double minVal = -DBL_MAX, double maxVal = DBL_MAX); -//! converts NaN's to the given number +/** @brief converts NaN's to the given number +*/ CV_EXPORTS_W void patchNaNs(InputOutputArray a, double val = 0); -//! implements generalized matrix product algorithm GEMM from BLAS +/** @brief Performs generalized matrix multiplication. + +The function performs generalized matrix multiplication similar to the +gemm functions in BLAS level 3. For example, +`gemm(src1, src2, alpha, src3, beta, dst, GEMM_1_T + GEMM_3_T)` +corresponds to +\f[\texttt{dst} = \texttt{alpha} \cdot \texttt{src1} ^T \cdot \texttt{src2} + \texttt{beta} \cdot \texttt{src3} ^T\f] + +In case of complex (two-channel) data, performed a complex matrix +multiplication. + +The function can be replaced with a matrix expression. For example, the +above call can be replaced with: +@code{.cpp} + dst = alpha*src1.t()*src2 + beta*src3.t(); +@endcode +@param src1 first multiplied input matrix that could be real(CV_32FC1, +CV_64FC1) or complex(CV_32FC2, CV_64FC2). +@param src2 second multiplied input matrix of the same type as src1. +@param alpha weight of the matrix product. +@param src3 third optional delta matrix added to the matrix product; it +should have the same type as src1 and src2. +@param beta weight of src3. +@param dst output matrix; it has the proper size and the same type as +input matrices. +@param flags operation flags (cv::GemmFlags) +@sa mulTransposed , transform +*/ CV_EXPORTS_W void gemm(InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags = 0); -//! multiplies matrix by its transposition from the left or from the right +/** @brief Calculates the product of a matrix and its transposition. + +The function mulTransposed calculates the product of src and its +transposition: +\f[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} )^T ( \texttt{src} - \texttt{delta} )\f] +if aTa=true , and +\f[\texttt{dst} = \texttt{scale} ( \texttt{src} - \texttt{delta} ) ( \texttt{src} - \texttt{delta} )^T\f] +otherwise. The function is used to calculate the covariance matrix. With +zero delta, it can be used as a faster substitute for general matrix +product A\*B when B=A' +@param src input single-channel matrix. Note that unlike gemm, the +function can multiply not only floating-point matrices. +@param dst output square matrix. +@param aTa Flag specifying the multiplication ordering. See the +description below. +@param delta Optional delta matrix subtracted from src before the +multiplication. When the matrix is empty ( delta=noArray() ), it is +assumed to be zero, that is, nothing is subtracted. If it has the same +size as src , it is simply subtracted. Otherwise, it is "repeated" (see +repeat ) to cover the full src and then subtracted. Type of the delta +matrix, when it is not empty, must be the same as the type of created +output matrix. See the dtype parameter description below. +@param scale Optional scale factor for the matrix product. +@param dtype Optional type of the output matrix. When it is negative, +the output matrix will have the same type as src . Otherwise, it will be +type=CV_MAT_DEPTH(dtype) that should be either CV_32F or CV_64F . +@sa calcCovarMatrix, gemm, repeat, reduce +*/ CV_EXPORTS_W void mulTransposed( InputArray src, OutputArray dst, bool aTa, InputArray delta = noArray(), double scale = 1, int dtype = -1 ); -//! transposes the matrix +/** @brief Transposes a matrix. + +The function transpose transposes the matrix src : +\f[\texttt{dst} (i,j) = \texttt{src} (j,i)\f] +@note No complex conjugation is done in case of a complex matrix. It it +should be done separately if needed. +@param src input array. +@param dst output array of the same type as src. +*/ CV_EXPORTS_W void transpose(InputArray src, OutputArray dst); -//! performs affine transformation of each element of multi-channel input matrix +/** @brief Performs the matrix transformation of every array element. + +The function transform performs the matrix transformation of every +element of the array src and stores the results in dst : +\f[\texttt{dst} (I) = \texttt{m} \cdot \texttt{src} (I)\f] +(when m.cols=src.channels() ), or +\f[\texttt{dst} (I) = \texttt{m} \cdot [ \texttt{src} (I); 1]\f] +(when m.cols=src.channels()+1 ) + +Every element of the N -channel array src is interpreted as N -element +vector that is transformed using the M x N or M x (N+1) matrix m to +M-element vector - the corresponding element of the output array dst . + +The function may be used for geometrical transformation of +N -dimensional points, arbitrary linear color space transformation (such +as various kinds of RGB to YUV transforms), shuffling the image +channels, and so forth. +@param src input array that must have as many channels (1 to 4) as +m.cols or m.cols-1. +@param dst output array of the same size and depth as src; it has as +many channels as m.rows. +@param m transformation 2x2 or 2x3 floating-point matrix. +@sa perspectiveTransform, getAffineTransform, estimateRigidTransform, warpAffine, warpPerspective +*/ CV_EXPORTS_W void transform(InputArray src, OutputArray dst, InputArray m ); -//! performs perspective transformation of each element of multi-channel input matrix +/** @brief Performs the perspective matrix transformation of vectors. + +The function perspectiveTransform transforms every element of src by +treating it as a 2D or 3D vector, in the following way: +\f[(x, y, z) \rightarrow (x'/w, y'/w, z'/w)\f] +where +\f[(x', y', z', w') = \texttt{mat} \cdot \begin{bmatrix} x & y & z & 1 \end{bmatrix}\f] +and +\f[w = \fork{w'}{if \(w' \ne 0\)}{\infty}{otherwise}\f] + +Here a 3D vector transformation is shown. In case of a 2D vector +transformation, the z component is omitted. + +@note The function transforms a sparse set of 2D or 3D vectors. If you +want to transform an image using perspective transformation, use +warpPerspective . If you have an inverse problem, that is, you want to +compute the most probable perspective transformation out of several +pairs of corresponding points, you can use getPerspectiveTransform or +findHomography . +@param src input two-channel or three-channel floating-point array; each +element is a 2D/3D vector to be transformed. +@param dst output array of the same size and type as src. +@param m 3x3 or 4x4 floating-point transformation matrix. +@sa transform, warpPerspective, getPerspectiveTransform, findHomography +*/ CV_EXPORTS_W void perspectiveTransform(InputArray src, OutputArray dst, InputArray m ); -//! extends the symmetrical matrix from the lower half or from the upper half +/** @brief Copies the lower or the upper half of a square matrix to another half. + +The function completeSymm copies the lower half of a square matrix to +its another half. The matrix diagonal remains unchanged: +* \f$\texttt{mtx}_{ij}=\texttt{mtx}_{ji}\f$ for \f$i > j\f$ if + lowerToUpper=false +* \f$\texttt{mtx}_{ij}=\texttt{mtx}_{ji}\f$ for \f$i < j\f$ if + lowerToUpper=true +@param mtx input-output floating-point square matrix. +@param lowerToUpper operation flag; if true, the lower half is copied to +the upper half. Otherwise, the upper half is copied to the lower half. +@sa flip, transpose +*/ CV_EXPORTS_W void completeSymm(InputOutputArray mtx, bool lowerToUpper = false); -//! initializes scaled identity matrix +/** @brief Initializes a scaled identity matrix. + +The function setIdentity initializes a scaled identity matrix: +\f[\texttt{mtx} (i,j)= \fork{\texttt{value}}{ if \(i=j\)}{0}{otherwise}\f] + +The function can also be emulated using the matrix initializers and the +matrix expressions: +@code + Mat A = Mat::eye(4, 3, CV_32F)*5; + // A will be set to [[5, 0, 0], [0, 5, 0], [0, 0, 5], [0, 0, 0]] +@endcode +@param mtx matrix to initialize (not necessarily square). +@param s value to assign to diagonal elements. +@sa Mat::zeros, Mat::ones, Mat::setTo, Mat::operator= +*/ CV_EXPORTS_W void setIdentity(InputOutputArray mtx, const Scalar& s = Scalar(1)); -//! computes determinant of a square matrix +/** @brief Returns the determinant of a square floating-point matrix. + +The function determinant calculates and returns the determinant of the +specified matrix. For small matrices ( mtx.cols=mtx.rows\<=3 ), the +direct method is used. For larger matrices, the function uses LU +factorization with partial pivoting. + +For symmetric positively-determined matrices, it is also possible to use +eigen decomposition to calculate the determinant. +@param mtx input matrix that must have CV_32FC1 or CV_64FC1 type and +square size. +@sa trace, invert, solve, eigen, @ref MatrixExpressions +*/ CV_EXPORTS_W double determinant(InputArray mtx); -//! computes trace of a matrix +/** @brief Returns the trace of a matrix. + +The function trace returns the sum of the diagonal elements of the +matrix mtx . +\f[\mathrm{tr} ( \texttt{mtx} ) = \sum _i \texttt{mtx} (i,i)\f] +@param mtx input matrix. +*/ CV_EXPORTS_W Scalar trace(InputArray mtx); -//! computes inverse or pseudo-inverse matrix +/** @brief Finds the inverse or pseudo-inverse of a matrix. + +The function invert inverts the matrix src and stores the result in dst +. When the matrix src is singular or non-square, the function calculates +the pseudo-inverse matrix (the dst matrix) so that norm(src\*dst - I) is +minimal, where I is an identity matrix. + +In case of the DECOMP_LU method, the function returns non-zero value if +the inverse has been successfully calculated and 0 if src is singular. + +In case of the DECOMP_SVD method, the function returns the inverse +condition number of src (the ratio of the smallest singular value to the +largest singular value) and 0 if src is singular. The SVD method +calculates a pseudo-inverse matrix if src is singular. + +Similarly to DECOMP_LU, the method DECOMP_CHOLESKY works only with +non-singular square matrices that should also be symmetrical and +positively defined. In this case, the function stores the inverted +matrix in dst and returns non-zero. Otherwise, it returns 0. + +@param src input floating-point M x N matrix. +@param dst output matrix of N x M size and the same type as src. +@param flags inversion method (cv::DecompTypes) +@sa solve, SVD +*/ CV_EXPORTS_W double invert(InputArray src, OutputArray dst, int flags = DECOMP_LU); -//! solves linear system or a least-square problem +/** @brief Solves one or more linear systems or least-squares problems. + +The function solve solves a linear system or least-squares problem (the +latter is possible with SVD or QR methods, or by specifying the flag +DECOMP_NORMAL ): +\f[\texttt{dst} = \arg \min _X \| \texttt{src1} \cdot \texttt{X} - \texttt{src2} \|\f] + +If DECOMP_LU or DECOMP_CHOLESKY method is used, the function returns 1 +if src1 (or \f$\texttt{src1}^T\texttt{src1}\f$ ) is non-singular. Otherwise, +it returns 0. In the latter case, dst is not valid. Other methods find a +pseudo-solution in case of a singular left-hand side part. + +@note If you want to find a unity-norm solution of an under-defined +singular system \f$\texttt{src1}\cdot\texttt{dst}=0\f$ , the function solve +will not do the work. Use SVD::solveZ instead. + +@param src1 input matrix on the left-hand side of the system. +@param src2 input matrix on the right-hand side of the system. +@param dst output solution. +@param flags solution (matrix inversion) method (cv::DecompTypes) +@sa invert, SVD, eigen +*/ CV_EXPORTS_W bool solve(InputArray src1, InputArray src2, OutputArray dst, int flags = DECOMP_LU); -//! sorts independently each matrix row or each matrix column +/** @brief Sorts each row or each column of a matrix. + +The function sort sorts each matrix row or each matrix column in +ascending or descending order. So you should pass two operation flags to +get desired behaviour. If you want to sort matrix rows or columns +lexicographically, you can use STL std::sort generic function with the +proper comparison predicate. + +@param src input single-channel array. +@param dst output array of the same size and type as src. +@param flags operation flags, a combination of cv::SortFlags +@sa sortIdx, randShuffle +*/ CV_EXPORTS_W void sort(InputArray src, OutputArray dst, int flags); -//! sorts independently each matrix row or each matrix column +/** @brief Sorts each row or each column of a matrix. + +The function sortIdx sorts each matrix row or each matrix column in the +ascending or descending order. So you should pass two operation flags to +get desired behaviour. Instead of reordering the elements themselves, it +stores the indices of sorted elements in the output array. For example: +@code + Mat A = Mat::eye(3,3,CV_32F), B; + sortIdx(A, B, SORT_EVERY_ROW + SORT_ASCENDING); + // B will probably contain + // (because of equal elements in A some permutations are possible): + // [[1, 2, 0], [0, 2, 1], [0, 1, 2]] +@endcode +@param src input single-channel array. +@param dst output integer array of the same size as src. +@param flags operation flags that could be a combination of cv::SortFlags +@sa sort, randShuffle +*/ CV_EXPORTS_W void sortIdx(InputArray src, OutputArray dst, int flags); -//! finds real roots of a cubic polynomial +/** @brief Finds the real roots of a cubic equation. + +The function solveCubic finds the real roots of a cubic equation: +- if coeffs is a 4-element vector: +\f[\texttt{coeffs} [0] x^3 + \texttt{coeffs} [1] x^2 + \texttt{coeffs} [2] x + \texttt{coeffs} [3] = 0\f] +- if coeffs is a 3-element vector: +\f[x^3 + \texttt{coeffs} [0] x^2 + \texttt{coeffs} [1] x + \texttt{coeffs} [2] = 0\f] + +The roots are stored in the roots array. +@param coeffs equation coefficients, an array of 3 or 4 elements. +@param roots output array of real roots that has 1 or 3 elements. +*/ CV_EXPORTS_W int solveCubic(InputArray coeffs, OutputArray roots); -//! finds real and complex roots of a polynomial +/** @brief Finds the real or complex roots of a polynomial equation. + +The function solvePoly finds real and complex roots of a polynomial equation: +\f[\texttt{coeffs} [n] x^{n} + \texttt{coeffs} [n-1] x^{n-1} + ... + \texttt{coeffs} [1] x + \texttt{coeffs} [0] = 0\f] +@param coeffs array of polynomial coefficients. +@param roots output (complex) array of roots. +@param maxIters maximum number of iterations the algorithm does. +*/ CV_EXPORTS_W double solvePoly(InputArray coeffs, OutputArray roots, int maxIters = 300); -//! finds eigenvalues and eigenvectors of a symmetric matrix +/** @brief Calculates eigenvalues and eigenvectors of a symmetric matrix. + +The functions eigen calculate just eigenvalues, or eigenvalues and eigenvectors of the symmetric +matrix src: +@code + src*eigenvectors.row(i).t() = eigenvalues.at(i)*eigenvectors.row(i).t() +@endcode +@note in the new and the old interfaces different ordering of eigenvalues and eigenvectors +parameters is used. +@param src input matrix that must have CV_32FC1 or CV_64FC1 type, square size and be symmetrical +(src ^T^ == src). +@param eigenvalues output vector of eigenvalues of the same type as src; the eigenvalues are stored +in the descending order. +@param eigenvectors output matrix of eigenvectors; it has the same size and type as src; the +eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding +eigenvalues. +@sa completeSymm , PCA +*/ CV_EXPORTS_W bool eigen(InputArray src, OutputArray eigenvalues, OutputArray eigenvectors = noArray()); -//! computes covariation matrix of a set of samples +/** @brief Calculates the covariance matrix of a set of vectors. + +The functions calcCovarMatrix calculate the covariance matrix and, optionally, the mean vector of +the set of input vectors. +@param samples samples stored as separate matrices +@param nsamples number of samples +@param covar output covariance matrix of the type ctype and square size. +@param mean input or output (depending on the flags) array as the average value of the input vectors. +@param flags operation flags as a combination of cv::CovarFlags +@param ctype type of the matrixl; it equals 'CV_64F' by default. +@sa PCA, mulTransposed, Mahalanobis +@todo InputArrayOfArrays +*/ CV_EXPORTS void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean, - int flags, int ctype = CV_64F); //TODO: InputArrayOfArrays - -//! computes covariation matrix of a set of samples + int flags, int ctype = CV_64F); + +/** @overload +@note use cv::COVAR_ROWS or cv::COVAR_COLS flag +@param samples samples stored as rows/columns of a single matrix. +@param covar output covariance matrix of the type ctype and square size. +@param mean input or output (depending on the flags) array as the average value of the input vectors. +@param flags operation flags as a combination of cv::CovarFlags +@param ctype type of the matrixl; it equals 'CV_64F' by default. +*/ CV_EXPORTS_W void calcCovarMatrix( InputArray samples, OutputArray covar, InputOutputArray mean, int flags, int ctype = CV_64F); +/** wrap PCA::operator() */ CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean, OutputArray eigenvectors, int maxComponents = 0); +/** wrap PCA::operator() */ CV_EXPORTS_W void PCACompute(InputArray data, InputOutputArray mean, OutputArray eigenvectors, double retainedVariance); +/** wrap PCA::project */ CV_EXPORTS_W void PCAProject(InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result); +/** wrap PCA::backProject */ CV_EXPORTS_W void PCABackProject(InputArray data, InputArray mean, InputArray eigenvectors, OutputArray result); -//! computes SVD of src +/** wrap SVD::compute */ CV_EXPORTS_W void SVDecomp( InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags = 0 ); -//! performs back substitution for the previously computed SVD +/** wrap SVD::backSubst */ CV_EXPORTS_W void SVBackSubst( InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst ); -//! computes Mahalanobis distance between two vectors: sqrt((v1-v2)'*icovar*(v1-v2)), where icovar is the inverse covariation matrix +/** @brief Calculates the Mahalanobis distance between two vectors. + +The function Mahalanobis calculates and returns the weighted distance between two vectors: +\f[d( \texttt{vec1} , \texttt{vec2} )= \sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})} }\f] +The covariance matrix may be calculated using the cv::calcCovarMatrix function and then inverted using +the invert function (preferably using the cv::DECOMP_SVD method, as the most accurate). +@param v1 first 1D input vector. +@param v2 second 1D input vector. +@param icovar inverse covariance matrix. +*/ CV_EXPORTS_W double Mahalanobis(InputArray v1, InputArray v2, InputArray icovar); -//! performs forward or inverse 1D or 2D Discrete Fourier Transformation +/** @brief Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array. + +The function performs one of the following: +- Forward the Fourier transform of a 1D vector of N elements: + \f[Y = F^{(N)} \cdot X,\f] + where \f$F^{(N)}_{jk}=\exp(-2\pi i j k/N)\f$ and \f$i=\sqrt{-1}\f$ +- Inverse the Fourier transform of a 1D vector of N elements: + \f[\begin{array}{l} X'= \left (F^{(N)} \right )^{-1} \cdot Y = \left (F^{(N)} \right )^* \cdot y \\ X = (1/N) \cdot X, \end{array}\f] + where \f$F^*=\left(\textrm{Re}(F^{(N)})-\textrm{Im}(F^{(N)})\right)^T\f$ +- Forward the 2D Fourier transform of a M x N matrix: + \f[Y = F^{(M)} \cdot X \cdot F^{(N)}\f] +- Inverse the 2D Fourier transform of a M x N matrix: + \f[\begin{array}{l} X'= \left (F^{(M)} \right )^* \cdot Y \cdot \left (F^{(N)} \right )^* \\ X = \frac{1}{M \cdot N} \cdot X' \end{array}\f] + +In case of real (single-channel) data, the output spectrum of the forward Fourier transform or input +spectrum of the inverse Fourier transform can be represented in a packed format called *CCS* +(complex-conjugate-symmetrical). It was borrowed from IPL (Intel\* Image Processing Library). Here +is how 2D *CCS* spectrum looks: +\f[\begin{bmatrix} Re Y_{0,0} & Re Y_{0,1} & Im Y_{0,1} & Re Y_{0,2} & Im Y_{0,2} & \cdots & Re Y_{0,N/2-1} & Im Y_{0,N/2-1} & Re Y_{0,N/2} \\ Re Y_{1,0} & Re Y_{1,1} & Im Y_{1,1} & Re Y_{1,2} & Im Y_{1,2} & \cdots & Re Y_{1,N/2-1} & Im Y_{1,N/2-1} & Re Y_{1,N/2} \\ Im Y_{1,0} & Re Y_{2,1} & Im Y_{2,1} & Re Y_{2,2} & Im Y_{2,2} & \cdots & Re Y_{2,N/2-1} & Im Y_{2,N/2-1} & Im Y_{1,N/2} \\ \hdotsfor{9} \\ Re Y_{M/2-1,0} & Re Y_{M-3,1} & Im Y_{M-3,1} & \hdotsfor{3} & Re Y_{M-3,N/2-1} & Im Y_{M-3,N/2-1}& Re Y_{M/2-1,N/2} \\ Im Y_{M/2-1,0} & Re Y_{M-2,1} & Im Y_{M-2,1} & \hdotsfor{3} & Re Y_{M-2,N/2-1} & Im Y_{M-2,N/2-1}& Im Y_{M/2-1,N/2} \\ Re Y_{M/2,0} & Re Y_{M-1,1} & Im Y_{M-1,1} & \hdotsfor{3} & Re Y_{M-1,N/2-1} & Im Y_{M-1,N/2-1}& Re Y_{M/2,N/2} \end{bmatrix}\f] + +In case of 1D transform of a real vector, the output looks like the first row of the matrix above. + +So, the function chooses an operation mode depending on the flags and size of the input array: +- If DFT_ROWS is set or the input array has a single row or single column, the function + performs a 1D forward or inverse transform of each row of a matrix when DFT_ROWS is set. + Otherwise, it performs a 2D transform. +- If the input array is real and DFT_INVERSE is not set, the function performs a forward 1D or + 2D transform: + - When DFT_COMPLEX_OUTPUT is set, the output is a complex matrix of the same size as + input. + - When DFT_COMPLEX_OUTPUT is not set, the output is a real matrix of the same size as + input. In case of 2D transform, it uses the packed format as shown above. In case of a + single 1D transform, it looks like the first row of the matrix above. In case of + multiple 1D transforms (when using the DFT_ROWS flag), each row of the output matrix + looks like the first row of the matrix above. +- If the input array is complex and either DFT_INVERSE or DFT_REAL_OUTPUT are not set, the + output is a complex array of the same size as input. The function performs a forward or + inverse 1D or 2D transform of the whole input array or each row of the input array + independently, depending on the flags DFT_INVERSE and DFT_ROWS. +- When DFT_INVERSE is set and the input array is real, or it is complex but DFT_REAL_OUTPUT + is set, the output is a real array of the same size as input. The function performs a 1D or 2D + inverse transformation of the whole input array or each individual row, depending on the flags + DFT_INVERSE and DFT_ROWS. + +If DFT_SCALE is set, the scaling is done after the transformation. + +Unlike dct , the function supports arrays of arbitrary size. But only those arrays are processed +efficiently, whose sizes can be factorized in a product of small prime numbers (2, 3, and 5 in the +current implementation). Such an efficient DFT size can be calculated using the getOptimalDFTSize +method. + +The sample below illustrates how to calculate a DFT-based convolution of two 2D real arrays: +@code + void convolveDFT(InputArray A, InputArray B, OutputArray C) + { + // reallocate the output array if needed + C.create(abs(A.rows - B.rows)+1, abs(A.cols - B.cols)+1, A.type()); + Size dftSize; + // calculate the size of DFT transform + dftSize.width = getOptimalDFTSize(A.cols + B.cols - 1); + dftSize.height = getOptimalDFTSize(A.rows + B.rows - 1); + + // allocate temporary buffers and initialize them with 0's + Mat tempA(dftSize, A.type(), Scalar::all(0)); + Mat tempB(dftSize, B.type(), Scalar::all(0)); + + // copy A and B to the top-left corners of tempA and tempB, respectively + Mat roiA(tempA, Rect(0,0,A.cols,A.rows)); + A.copyTo(roiA); + Mat roiB(tempB, Rect(0,0,B.cols,B.rows)); + B.copyTo(roiB); + + // now transform the padded A & B in-place; + // use "nonzeroRows" hint for faster processing + dft(tempA, tempA, 0, A.rows); + dft(tempB, tempB, 0, B.rows); + + // multiply the spectrums; + // the function handles packed spectrum representations well + mulSpectrums(tempA, tempB, tempA); + + // transform the product back from the frequency domain. + // Even though all the result rows will be non-zero, + // you need only the first C.rows of them, and thus you + // pass nonzeroRows == C.rows + dft(tempA, tempA, DFT_INVERSE + DFT_SCALE, C.rows); + + // now copy the result back to C. + tempA(Rect(0, 0, C.cols, C.rows)).copyTo(C); + + // all the temporary buffers will be deallocated automatically + } +@endcode +To optimize this sample, consider the following approaches: +- Since nonzeroRows != 0 is passed to the forward transform calls and since A and B are copied to + the top-left corners of tempA and tempB, respectively, it is not necessary to clear the whole + tempA and tempB. It is only necessary to clear the tempA.cols - A.cols ( tempB.cols - B.cols) + rightmost columns of the matrices. +- This DFT-based convolution does not have to be applied to the whole big arrays, especially if B + is significantly smaller than A or vice versa. Instead, you can calculate convolution by parts. + To do this, you need to split the output array C into multiple tiles. For each tile, estimate + which parts of A and B are required to calculate convolution in this tile. If the tiles in C are + too small, the speed will decrease a lot because of repeated work. In the ultimate case, when + each tile in C is a single pixel, the algorithm becomes equivalent to the naive convolution + algorithm. If the tiles are too big, the temporary arrays tempA and tempB become too big and + there is also a slowdown because of bad cache locality. So, there is an optimal tile size + somewhere in the middle. +- If different tiles in C can be calculated in parallel and, thus, the convolution is done by + parts, the loop can be threaded. + +All of the above improvements have been implemented in matchTemplate and filter2D . Therefore, by +using them, you can get the performance even better than with the above theoretically optimal +implementation. Though, those two functions actually calculate cross-correlation, not convolution, +so you need to "flip" the second convolution operand B vertically and horizontally using flip . +@note +- An example using the discrete fourier transform can be found at + opencv_source_code/samples/cpp/dft.cpp +- (Python) An example using the dft functionality to perform Wiener deconvolution can be found + at opencv_source/samples/python2/deconvolution.py +- (Python) An example rearranging the quadrants of a Fourier image can be found at + opencv_source/samples/python2/dft.py +@param src input array that could be real or complex. +@param dst output array whose size and type depends on the flags . +@param flags transformation flags, representing a combination of the cv::DftFlags +@param nonzeroRows when the parameter is not zero, the function assumes that only the first +nonzeroRows rows of the input array (DFT_INVERSE is not set) or only the first nonzeroRows of the +output array (DFT_INVERSE is set) contain non-zeros, thus, the function can handle the rest of the +rows more efficiently and save some time; this technique is very useful for calculating array +cross-correlation or convolution using DFT. +@sa dct , getOptimalDFTSize , mulSpectrums, filter2D , matchTemplate , flip , cartToPolar , +magnitude , phase +*/ CV_EXPORTS_W void dft(InputArray src, OutputArray dst, int flags = 0, int nonzeroRows = 0); -//! performs inverse 1D or 2D Discrete Fourier Transformation +/** @brief Calculates the inverse Discrete Fourier Transform of a 1D or 2D array. + +idft(src, dst, flags) is equivalent to dft(src, dst, flags | DFT_INVERSE) . +@note None of dft and idft scales the result by default. So, you should pass DFT_SCALE to one of +dft or idft explicitly to make these transforms mutually inverse. +@sa dft, dct, idct, mulSpectrums, getOptimalDFTSize +@param src input floating-point real or complex array. +@param dst output array whose size and type depend on the flags. +@param flags operation flags (see dft and cv::DftFlags). +@param nonzeroRows number of dst rows to process; the rest of the rows have undefined content (see +the convolution sample in dft description. +*/ CV_EXPORTS_W void idft(InputArray src, OutputArray dst, int flags = 0, int nonzeroRows = 0); -//! performs forward or inverse 1D or 2D Discrete Cosine Transformation +/** @brief Performs a forward or inverse discrete Cosine transform of 1D or 2D array. + +The function dct performs a forward or inverse discrete Cosine transform (DCT) of a 1D or 2D +floating-point array: +- Forward Cosine transform of a 1D vector of N elements: + \f[Y = C^{(N)} \cdot X\f] + where + \f[C^{(N)}_{jk}= \sqrt{\alpha_j/N} \cos \left ( \frac{\pi(2k+1)j}{2N} \right )\f] + and + \f$\alpha_0=1\f$, \f$\alpha_j=2\f$ for *j \> 0*. +- Inverse Cosine transform of a 1D vector of N elements: + \f[X = \left (C^{(N)} \right )^{-1} \cdot Y = \left (C^{(N)} \right )^T \cdot Y\f] + (since \f$C^{(N)}\f$ is an orthogonal matrix, \f$C^{(N)} \cdot \left(C^{(N)}\right)^T = I\f$ ) +- Forward 2D Cosine transform of M x N matrix: + \f[Y = C^{(N)} \cdot X \cdot \left (C^{(N)} \right )^T\f] +- Inverse 2D Cosine transform of M x N matrix: + \f[X = \left (C^{(N)} \right )^T \cdot X \cdot C^{(N)}\f] + +The function chooses the mode of operation by looking at the flags and size of the input array: +- If (flags & DCT_INVERSE) == 0 , the function does a forward 1D or 2D transform. Otherwise, it + is an inverse 1D or 2D transform. +- If (flags & DCT_ROWS) != 0 , the function performs a 1D transform of each row. +- If the array is a single column or a single row, the function performs a 1D transform. +- If none of the above is true, the function performs a 2D transform. + +@note Currently dct supports even-size arrays (2, 4, 6 ...). For data analysis and approximation, you +can pad the array when necessary. +Also, the function performance depends very much, and not monotonically, on the array size (see +getOptimalDFTSize ). In the current implementation DCT of a vector of size N is calculated via DFT +of a vector of size N/2 . Thus, the optimal DCT size N1 \>= N can be calculated as: +@code + size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); } + N1 = getOptimalDCTSize(N); +@endcode +@param src input floating-point array. +@param dst output array of the same size and type as src . +@param flags transformation flags as a combination of cv::DftFlags (DCT_*) +@sa dft , getOptimalDFTSize , idct +*/ CV_EXPORTS_W void dct(InputArray src, OutputArray dst, int flags = 0); -//! performs inverse 1D or 2D Discrete Cosine Transformation +/** @brief Calculates the inverse Discrete Cosine Transform of a 1D or 2D array. + +idct(src, dst, flags) is equivalent to dct(src, dst, flags | DCT_INVERSE). +@param src input floating-point single-channel array. +@param dst output array of the same size and type as src. +@param flags operation flags. +@sa dct, dft, idft, getOptimalDFTSize +*/ CV_EXPORTS_W void idct(InputArray src, OutputArray dst, int flags = 0); -//! computes element-wise product of the two Fourier spectrums. The second spectrum can optionally be conjugated before the multiplication +/** @brief Performs the per-element multiplication of two Fourier spectrums. + +The function mulSpectrums performs the per-element multiplication of the two CCS-packed or complex +matrices that are results of a real or complex Fourier transform. + +The function, together with dft and idft , may be used to calculate convolution (pass conjB=false ) +or correlation (pass conjB=true ) of two arrays rapidly. When the arrays are complex, they are +simply multiplied (per element) with an optional conjugation of the second-array elements. When the +arrays are real, they are assumed to be CCS-packed (see dft for details). +@param a first input array. +@param b second input array of the same size and type as src1 . +@param c output array of the same size and type as src1 . +@param flags operation flags; currently, the only supported flag is cv::DFT_ROWS, which indicates that +each row of src1 and src2 is an independent 1D Fourier spectrum. +@param conjB optional flag that conjugates the second input array before the multiplication (true) +or not (false). +*/ CV_EXPORTS_W void mulSpectrums(InputArray a, InputArray b, OutputArray c, int flags, bool conjB = false); -//! computes the minimal vector size vecsize1 >= vecsize so that the dft() of the vector of length vecsize1 can be computed efficiently +/** @brief Returns the optimal DFT size for a given vector size. + +DFT performance is not a monotonic function of a vector size. Therefore, when you calculate +convolution of two arrays or perform the spectral analysis of an array, it usually makes sense to +pad the input data with zeros to get a bit larger array that can be transformed much faster than the +original one. Arrays whose size is a power-of-two (2, 4, 8, 16, 32, ...) are the fastest to process. +Though, the arrays whose size is a product of 2's, 3's, and 5's (for example, 300 = 5\*5\*3\*2\*2) +are also processed quite efficiently. + +The function getOptimalDFTSize returns the minimum number N that is greater than or equal to vecsize +so that the DFT of a vector of size N can be processed efficiently. In the current implementation N += 2 ^p^ \* 3 ^q^ \* 5 ^r^ for some integer p, q, r. + +The function returns a negative number if vecsize is too large (very close to INT_MAX ). + +While the function cannot be used directly to estimate the optimal vector size for DCT transform +(since the current DCT implementation supports only even-size vectors), it can be easily processed +as getOptimalDFTSize((vecsize+1)/2)\*2. +@param vecsize vector size. +@sa dft , dct , idft , idct , mulSpectrums +*/ CV_EXPORTS_W int getOptimalDFTSize(int vecsize); -//! clusters the input data using k-Means algorithm -CV_EXPORTS_W double kmeans( InputArray data, int K, InputOutputArray bestLabels, - TermCriteria criteria, int attempts, - int flags, OutputArray centers = noArray() ); +/** @brief Returns the default random number generator. -//! returns the thread-local Random number generator +The function theRNG returns the default random number generator. For each thread, there is a +separate random number generator, so you can use the function safely in multi-thread environments. +If you just need to get a single random number using this generator or initialize an array, you can +use randu or randn instead. But if you are going to generate many random numbers inside a loop, it +is much faster to use this function to retrieve the generator and then use RNG::operator _Tp() . +@sa RNG, randu, randn +*/ CV_EXPORTS RNG& theRNG(); -//! fills array with uniformly-distributed random numbers from the range [low, high) +/** @brief Generates a single uniformly-distributed random number or an array of random numbers. + +Non-template variant of the function fills the matrix dst with uniformly-distributed +random numbers from the specified range: +\f[\texttt{low} _c \leq \texttt{dst} (I)_c < \texttt{high} _c\f] +@param dst output array of random numbers; the array must be pre-allocated. +@param low inclusive lower boundary of the generated random numbers. +@param high exclusive upper boundary of the generated random numbers. +@sa RNG, randn, theRNG +*/ CV_EXPORTS_W void randu(InputOutputArray dst, InputArray low, InputArray high); -//! fills array with normally-distributed random numbers with the specified mean and the standard deviation -CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean, InputArray stddev); +/** @brief Fills the array with normally distributed random numbers. -//! shuffles the input array elements -CV_EXPORTS_W void randShuffle(InputOutputArray dst, double iterFactor = 1., RNG* rng = 0); +The function randn fills the matrix dst with normally distributed random numbers with the specified +mean vector and the standard deviation matrix. The generated random numbers are clipped to fit the +value range of the output array data type. +@param dst output array of random numbers; the array must be pre-allocated and have 1 to 4 channels. +@param mean mean value (expectation) of the generated random numbers. +@param stddev standard deviation of the generated random numbers; it can be either a vector (in +which case a diagonal standard deviation matrix is assumed) or a square matrix. +@sa RNG, randu +*/ +CV_EXPORTS_W void randn(InputOutputArray dst, InputArray mean, InputArray stddev); -/*! - Principal Component Analysis +/** @brief Shuffles the array elements randomly. - The class PCA is used to compute the special basis for a set of vectors. - The basis will consist of eigenvectors of the covariance matrix computed - from the input set of vectors. After PCA is performed, vectors can be transformed from - the original high-dimensional space to the subspace formed by a few most - prominent eigenvectors (called the principal components), - corresponding to the largest eigenvalues of the covariation matrix. - Thus the dimensionality of the vector and the correlation between the coordinates is reduced. +The function randShuffle shuffles the specified 1D array by randomly choosing pairs of elements and +swapping them. The number of such swap operations will be dst.rows\*dst.cols\*iterFactor . +@param dst input/output numerical 1D array. +@param iterFactor scale factor that determines the number of random swap operations (see the details +below). +@param rng optional random number generator used for shuffling; if it is zero, theRNG () is used +instead. +@sa RNG, sort +*/ +CV_EXPORTS_W void randShuffle(InputOutputArray dst, double iterFactor = 1., RNG* rng = 0); - The following sample is the function that takes two matrices. The first one stores the set - of vectors (a row per vector) that is used to compute PCA, the second one stores another - "test" set of vectors (a row per vector) that are first compressed with PCA, - then reconstructed back and then the reconstruction error norm is computed and printed for each vector. +/** @brief Principal Component Analysis + +The class is used to calculate a special basis for a set of vectors. The +basis will consist of eigenvectors of the covariance matrix calculated +from the input set of vectors. The class %PCA can also transform +vectors to/from the new coordinate space defined by the basis. Usually, +in this new coordinate system, each vector from the original set (and +any linear combination of such vectors) can be quite accurately +approximated by taking its first few components, corresponding to the +eigenvectors of the largest eigenvalues of the covariance matrix. +Geometrically it means that you calculate a projection of the vector to +a subspace formed by a few eigenvectors corresponding to the dominant +eigenvalues of the covariance matrix. And usually such a projection is +very close to the original vector. So, you can represent the original +vector from a high-dimensional space with a much shorter vector +consisting of the projected vector's coordinates in the subspace. Such a +transformation is also known as Karhunen-Loeve Transform, or KLT. +See http://en.wikipedia.org/wiki/Principal_component_analysis + +The sample below is the function that takes two matrices. The first +function stores a set of vectors (a row per vector) that is used to +calculate PCA. The second function stores another "test" set of vectors +(a row per vector). First, these vectors are compressed with PCA, then +reconstructed back, and then the reconstruction error norm is computed +and printed for each vector. : + +@code{.cpp} +using namespace cv; + +PCA compressPCA(const Mat& pcaset, int maxComponents, + const Mat& testset, Mat& compressed) +{ + PCA pca(pcaset, // pass the data + Mat(), // we do not have a pre-computed mean vector, + // so let the PCA engine to compute it + PCA::DATA_AS_ROW, // indicate that the vectors + // are stored as matrix rows + // (use PCA::DATA_AS_COL if the vectors are + // the matrix columns) + maxComponents // specify, how many principal components to retain + ); + // if there is no test data, just return the computed basis, ready-to-use + if( !testset.data ) + return pca; + CV_Assert( testset.cols == pcaset.cols ); - \code - using namespace cv; + compressed.create(testset.rows, maxComponents, testset.type()); - PCA compressPCA(const Mat& pcaset, int maxComponents, - const Mat& testset, Mat& compressed) + Mat reconstructed; + for( int i = 0; i < testset.rows; i++ ) { - PCA pca(pcaset, // pass the data - Mat(), // we do not have a pre-computed mean vector, - // so let the PCA engine to compute it - PCA::DATA_AS_ROW, // indicate that the vectors - // are stored as matrix rows - // (use PCA::DATA_AS_COL if the vectors are - // the matrix columns) - maxComponents // specify, how many principal components to retain - ); - // if there is no test data, just return the computed basis, ready-to-use - if( !testset.data ) - return pca; - CV_Assert( testset.cols == pcaset.cols ); - - compressed.create(testset.rows, maxComponents, testset.type()); - - Mat reconstructed; - for( int i = 0; i < testset.rows; i++ ) - { - Mat vec = testset.row(i), coeffs = compressed.row(i), reconstructed; - // compress the vector, the result will be stored - // in the i-th row of the output matrix - pca.project(vec, coeffs); - // and then reconstruct it - pca.backProject(coeffs, reconstructed); - // and measure the error - printf("%d. diff = %g\n", i, norm(vec, reconstructed, NORM_L2)); - } - return pca; + Mat vec = testset.row(i), coeffs = compressed.row(i), reconstructed; + // compress the vector, the result will be stored + // in the i-th row of the output matrix + pca.project(vec, coeffs); + // and then reconstruct it + pca.backProject(coeffs, reconstructed); + // and measure the error + printf("%d. diff = %g\n", i, norm(vec, reconstructed, NORM_L2)); } - \endcode + return pca; +} +@endcode +@sa calcCovarMatrix, mulTransposed, SVD, dft, dct */ class CV_EXPORTS PCA { public: - enum { DATA_AS_ROW = 0, - DATA_AS_COL = 1, - USE_AVG = 2 - }; + enum Flags { DATA_AS_ROW = 0, //!< indicates that the input samples are stored as matrix rows + DATA_AS_COL = 1, //!< indicates that the input samples are stored as matrix columns + USE_AVG = 2 //! + }; - //! default constructor + /** @brief default constructor + + The default constructor initializes an empty %PCA structure. The other + constructors initialize the structure and call PCA::operator()(). + */ PCA(); - //! the constructor that performs PCA + /** @overload + @param data input samples stored as matrix rows or matrix columns. + @param mean optional mean value; if the matrix is empty (@c noArray()), + the mean is computed from the data. + @param flags operation flags; currently the parameter is only used to + specify the data layout (PCA::Flags) + @param maxComponents maximum number of components that %PCA should + retain; by default, all the components are retained. + */ PCA(InputArray data, InputArray mean, int flags, int maxComponents = 0); + + /** @overload + @param data input samples stored as matrix rows or matrix columns. + @param mean optional mean value; if the matrix is empty (noArray()), + the mean is computed from the data. + @param flags operation flags; currently the parameter is only used to + specify the data layout (PCA::Flags) + @param retainedVariance Percentage of variance that PCA should retain. + Using this parameter will let the PCA decided how many components to + retain but it will always keep at least 2. + */ PCA(InputArray data, InputArray mean, int flags, double retainedVariance); - //! operator that performs PCA. The previously stored data, if any, is released + /** @brief performs %PCA + + The operator performs %PCA of the supplied dataset. It is safe to reuse + the same PCA structure for multiple datasets. That is, if the structure + has been previously used with another dataset, the existing internal + data is reclaimed and the new eigenvalues, @ref eigenvectors , and @ref + mean are allocated and computed. + + The computed eigenvalues are sorted from the largest to the smallest and + the corresponding eigenvectors are stored as eigenvectors rows. + + @param data input samples stored as the matrix rows or as the matrix + columns. + @param mean optional mean value; if the matrix is empty (noArray()), + the mean is computed from the data. + @param flags operation flags; currently the parameter is only used to + specify the data layout. (Flags) + @param maxComponents maximum number of components that PCA should + retain; by default, all the components are retained. + */ PCA& operator()(InputArray data, InputArray mean, int flags, int maxComponents = 0); + + /** @overload + @param data input samples stored as the matrix rows or as the matrix + columns. + @param mean optional mean value; if the matrix is empty (noArray()), + the mean is computed from the data. + @param flags operation flags; currently the parameter is only used to + specify the data layout. (PCA::Flags) + @param retainedVariance Percentage of variance that %PCA should retain. + Using this parameter will let the %PCA decided how many components to + retain but it will always keep at least 2. + */ PCA& operator()(InputArray data, InputArray mean, int flags, double retainedVariance); - //! projects vector from the original space to the principal components subspace + /** @brief Projects vector(s) to the principal component subspace. + + The methods project one or more vectors to the principal component + subspace, where each vector projection is represented by coefficients in + the principal component basis. The first form of the method returns the + matrix that the second form writes to the result. So the first form can + be used as a part of expression while the second form can be more + efficient in a processing loop. + @param vec input vector(s); must have the same dimensionality and the + same layout as the input data used at %PCA phase, that is, if + DATA_AS_ROW are specified, then `vec.cols==data.cols` + (vector dimensionality) and `vec.rows` is the number of vectors to + project, and the same is true for the PCA::DATA_AS_COL case. + */ Mat project(InputArray vec) const; - //! projects vector from the original space to the principal components subspace + /** @overload + @param vec input vector(s); must have the same dimensionality and the + same layout as the input data used at PCA phase, that is, if + DATA_AS_ROW are specified, then `vec.cols==data.cols` + (vector dimensionality) and `vec.rows` is the number of vectors to + project, and the same is true for the PCA::DATA_AS_COL case. + @param result output vectors; in case of PCA::DATA_AS_COL, the + output matrix has as many columns as the number of input vectors, this + means that `result.cols==vec.cols` and the number of rows match the + number of principal components (for example, `maxComponents` parameter + passed to the constructor). + */ void project(InputArray vec, OutputArray result) const; - //! reconstructs the original vector from the projection + /** @brief Reconstructs vectors from their PC projections. + + The methods are inverse operations to PCA::project. They take PC + coordinates of projected vectors and reconstruct the original vectors. + Unless all the principal components have been retained, the + reconstructed vectors are different from the originals. But typically, + the difference is small if the number of components is large enough (but + still much smaller than the original vector dimensionality). As a + result, PCA is used. + @param vec coordinates of the vectors in the principal component + subspace, the layout and size are the same as of PCA::project output + vectors. + */ Mat backProject(InputArray vec) const; - //! reconstructs the original vector from the projection + /** @overload + @param vec coordinates of the vectors in the principal component + subspace, the layout and size are the same as of PCA::project output + vectors. + @param result reconstructed vectors; the layout and size are the same as + of PCA::project input vectors. + */ void backProject(InputArray vec, OutputArray result) const; - //! write and load PCA matrix + /** @brief write and load PCA matrix + +*/ void write(FileStorage& fs ) const; void read(const FileNode& fs); @@ -600,48 +2226,68 @@ public: Mat mean; //!< mean value subtracted before the projection and added after the back projection }; -// Linear Discriminant Analysis +/** @example pca.cpp + An example using %PCA for dimensionality reduction while maintaining an amount of variance + */ + +/** + @brief Linear Discriminant Analysis + @todo document this class + */ class CV_EXPORTS LDA { public: - // Initializes a LDA with num_components (default 0) and specifies how - // samples are aligned (default dataAsRow=true). + /** @brief constructor + Initializes a LDA with num_components (default 0) and specifies how + samples are aligned (default dataAsRow=true). + */ explicit LDA(int num_components = 0); - // Initializes and performs a Discriminant Analysis with Fisher's - // Optimization Criterion on given data in src and corresponding labels - // in labels. If 0 (or less) number of components are given, they are - // automatically determined for given data in computation. + /** Initializes and performs a Discriminant Analysis with Fisher's + Optimization Criterion on given data in src and corresponding labels + in labels. If 0 (or less) number of components are given, they are + automatically determined for given data in computation. + */ LDA(InputArrayOfArrays src, InputArray labels, int num_components = 0); - // Serializes this object to a given filename. + /** Serializes this object to a given filename. + */ void save(const String& filename) const; - // Deserializes this object from a given filename. + /** Deserializes this object from a given filename. + */ void load(const String& filename); - // Serializes this object to a given cv::FileStorage. + /** Serializes this object to a given cv::FileStorage. + */ void save(FileStorage& fs) const; - // Deserializes this object from a given cv::FileStorage. + /** Deserializes this object from a given cv::FileStorage. + */ void load(const FileStorage& node); - // Destructor. + /** destructor + */ ~LDA(); - //! Compute the discriminants for data in src and labels. + /** Compute the discriminants for data in src and labels. + */ void compute(InputArrayOfArrays src, InputArray labels); - // Projects samples into the LDA subspace. + /** Projects samples into the LDA subspace. + */ Mat project(InputArray src); - // Reconstructs projections from the LDA subspace. + /** Reconstructs projections from the LDA subspace. + */ Mat reconstruct(InputArray src); - // Returns the eigenvectors of this LDA. + /** Returns the eigenvectors of this LDA. + */ Mat eigenvectors() const { return _eigenvectors; } - // Returns the eigenvalues of this LDA. + /** Returns the eigenvalues of this LDA. + */ Mat eigenvalues() const { return _eigenvalues; } static Mat subspaceProject(InputArray W, InputArray mean, InputArray src); @@ -656,101 +2302,160 @@ protected: void lda(InputArrayOfArrays src, InputArray labels); }; -/*! - Singular Value Decomposition class +/** @brief Singular Value Decomposition + +Class for computing Singular Value Decomposition of a floating-point +matrix. The Singular Value Decomposition is used to solve least-square +problems, under-determined linear systems, invert matrices, compute +condition numbers, and so on. - The class is used to compute Singular Value Decomposition of a floating-point matrix and then - use it to solve least-square problems, under-determined linear systems, invert matrices, - compute condition numbers etc. +For a faster operation, you can pass flags=SVD::MODIFY_A|... to modify +the decomposed matrix when it is not necessary to preserve it. If you +want to compute a condition number of a matrix or an absolute value of +its determinant, you do not need `u` and `vt`. You can pass +flags=SVD::NO_UV|... . Another flag SVD::FULL_UV indicates that full-size u +and vt must be computed, which is not necessary most of the time. - For a bit faster operation you can pass flags=SVD::MODIFY_A|... to modify the decomposed matrix - when it is not necessarily to preserve it. If you want to compute condition number of a matrix - or absolute value of its determinant - you do not need SVD::u or SVD::vt, - so you can pass flags=SVD::NO_UV|... . Another flag SVD::FULL_UV indicates that the full-size SVD::u and SVD::vt - must be computed, which is not necessary most of the time. +@sa invert, solve, eigen, determinant */ class CV_EXPORTS SVD { public: - enum { MODIFY_A = 1, - NO_UV = 2, - FULL_UV = 4 - }; - - //! the default constructor + enum Flags { + /** use the algorithm to modify the decomposed matrix; it can save space and speed up + processing */ + MODIFY_A = 1, + /** indicates that only a vector of singular values `w` is to be processed, while u and vt + will be set to empty matrices */ + NO_UV = 2, + /** when the matrix is not square, by default the algorithm produces u and vt matrices of + sufficiently large size for the further A reconstruction; if, however, FULL_UV flag is + specified, u and vt will be full-size square orthogonal matrices.*/ + FULL_UV = 4 + }; + + /** @brief the default constructor + + initializes an empty SVD structure + */ SVD(); - //! the constructor that performs SVD + /** @overload + initializes an empty SVD structure and then calls SVD::operator() + @param src decomposed matrix. + @param flags operation flags (SVD::Flags) + */ SVD( InputArray src, int flags = 0 ); - //! the operator that performs SVD. The previously allocated SVD::u, SVD::w are SVD::vt are released. + /** @brief the operator that performs SVD. The previously allocated u, w and vt are released. + + The operator performs the singular value decomposition of the supplied + matrix. The u,`vt` , and the vector of singular values w are stored in + the structure. The same SVD structure can be reused many times with + different matrices. Each time, if needed, the previous u,`vt` , and w + are reclaimed and the new matrices are created, which is all handled by + Mat::create. + @param src decomposed matrix. + @param flags operation flags (SVD::Flags) + */ SVD& operator ()( InputArray src, int flags = 0 ); - //! decomposes matrix and stores the results to user-provided matrices + /** @brief decomposes matrix and stores the results to user-provided matrices + + The methods/functions perform SVD of matrix. Unlike SVD::SVD constructor + and SVD::operator(), they store the results to the user-provided + matrices: + + @code{.cpp} + Mat A, w, u, vt; + SVD::compute(A, w, u, vt); + @endcode + + @param src decomposed matrix + @param w calculated singular values + @param u calculated left singular vectors + @param vt transposed matrix of right singular values + @param flags operation flags - see SVD::SVD. + */ static void compute( InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags = 0 ); - //! computes singular values of a matrix + /** @overload + computes singular values of a matrix + @param src decomposed matrix + @param w calculated singular values + @param flags operation flags - see SVD::Flags. + */ static void compute( InputArray src, OutputArray w, int flags = 0 ); - //! performs back substitution + /** @brief performs back substitution + */ static void backSubst( InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst ); - //! finds dst = arg min_{|dst|=1} |m*dst| + /** @brief solves an under-determined singular linear system + + The method finds a unit-length solution x of a singular linear system + A\*x = 0. Depending on the rank of A, there can be no solutions, a + single solution or an infinite number of solutions. In general, the + algorithm solves the following problem: + \f[dst = \arg \min _{x: \| x \| =1} \| src \cdot x \|\f] + @param src left-hand-side matrix. + @param dst found solution. + */ static void solveZ( InputArray src, OutputArray dst ); - //! performs back substitution, so that dst is the solution or pseudo-solution of m*dst = rhs, where m is the decomposed matrix + /** @brief performs a singular value back substitution. + + The method calculates a back substitution for the specified right-hand + side: + + \f[\texttt{x} = \texttt{vt} ^T \cdot diag( \texttt{w} )^{-1} \cdot \texttt{u} ^T \cdot \texttt{rhs} \sim \texttt{A} ^{-1} \cdot \texttt{rhs}\f] + + Using this technique you can either get a very accurate solution of the + convenient linear system, or the best (in the least-squares terms) + pseudo-solution of an overdetermined linear system. + + @param rhs right-hand side of a linear system (u\*w\*v')\*dst = rhs to + be solved, where A has been previously decomposed. + + @param dst found solution of the system. + + @note Explicit SVD with the further back substitution only makes sense + if you need to solve many linear systems with the same left-hand side + (for example, src ). If all you need is to solve a single system + (possibly with multiple rhs immediately available), simply call solve + add pass DECOMP_SVD there. It does absolutely the same thing. + */ void backSubst( InputArray rhs, OutputArray dst ) const; + /** @todo document */ template static void compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w, Matx<_Tp, m, nm>& u, Matx<_Tp, n, nm>& vt ); + /** @todo document */ template static void compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w ); + /** @todo document */ template static void backSubst( const Matx<_Tp, nm, 1>& w, const Matx<_Tp, m, nm>& u, const Matx<_Tp, n, nm>& vt, const Matx<_Tp, m, nb>& rhs, Matx<_Tp, n, nb>& dst ); Mat u, w, vt; }; - - -/*! - Line iterator class - - The class is used to iterate over all the pixels on the raster line - segment connecting two specified points. -*/ -class CV_EXPORTS LineIterator -{ -public: - //! intializes the iterator - LineIterator( const Mat& img, Point pt1, Point pt2, - int connectivity = 8, bool leftToRight = false ); - //! returns pointer to the current pixel - uchar* operator *(); - //! prefix increment operator (++it). shifts iterator to the next pixel - LineIterator& operator ++(); - //! postfix increment operator (it++). shifts iterator to the next pixel - LineIterator operator ++(int); - //! returns coordinates of the current pixel - Point pos() const; - - uchar* ptr; - const uchar* ptr0; - int step, elemSize; - int err, count; - int minusDelta, plusDelta; - int minusStep, plusStep; -}; - -/*! - Random Number Generator - - The class implements RNG using Multiply-with-Carry algorithm +/** @brief Random Number Generator + +Random number generator. It encapsulates the state (currently, a 64-bit +integer) and has methods to return scalar random values and to fill +arrays with random values. Currently it supports uniform and Gaussian +(normal) distributions. The generator uses Multiply-With-Carry +algorithm, introduced by G. Marsaglia ( + ). +Gaussian-distribution random numbers are generated using the Ziggurat +algorithm ( ), +introduced by G. Marsaglia and W. W. Tsang. */ class CV_EXPORTS RNG { @@ -759,35 +2464,154 @@ public: NORMAL = 1 }; + /** @brief constructor + + These are the RNG constructors. The first form sets the state to some + pre-defined value, equal to 2\*\*32-1 in the current implementation. The + second form sets the state to the specified value. If you passed state=0 + , the constructor uses the above default value instead to avoid the + singular random number sequence, consisting of all zeros. + */ RNG(); + /** @overload + @param state 64-bit value used to initialize the RNG. + */ RNG(uint64 state); - //! updates the state and returns the next 32-bit unsigned integer random number + /**The method updates the state using the MWC algorithm and returns the + next 32-bit random number.*/ unsigned next(); + /**Each of the methods updates the state using the MWC algorithm and + returns the next random number of the specified type. In case of integer + types, the returned number is from the available value range for the + specified type. In case of floating-point types, the returned value is + from [0,1) range. + */ operator uchar(); + /** @overload */ operator schar(); + /** @overload */ operator ushort(); + /** @overload */ operator short(); + /** @overload */ operator unsigned(); - //! returns a random integer sampled uniformly from [0, N). - unsigned operator ()(unsigned N); - unsigned operator ()(); + /** @overload */ operator int(); + /** @overload */ operator float(); + /** @overload */ operator double(); - //! returns uniformly distributed integer random number from [a,b) range + + /** @brief returns a random integer sampled uniformly from [0, N). + + The methods transform the state using the MWC algorithm and return the + next random number. The first form is equivalent to RNG::next . The + second form returns the random number modulo N , which means that the + result is in the range [0, N) . + */ + unsigned operator ()(); + /** @overload + @param N upper non-inclusive boundary of the returned random number. + */ + unsigned operator ()(unsigned N); + + /** @brief returns uniformly distributed integer random number from [a,b) range + + The methods transform the state using the MWC algorithm and return the + next uniformly-distributed random number of the specified type, deduced + from the input parameter type, from the range [a, b) . There is a nuance + illustrated by the following sample: + + @code{.cpp} + RNG rng; + + // always produces 0 + double a = rng.uniform(0, 1); + + // produces double from [0, 1) + double a1 = rng.uniform((double)0, (double)1); + + // produces float from [0, 1) + double b = rng.uniform(0.f, 1.f); + + // produces double from [0, 1) + double c = rng.uniform(0., 1.); + + // may cause compiler error because of ambiguity: + // RNG::uniform(0, (int)0.999999)? or RNG::uniform((double)0, 0.99999)? + double d = rng.uniform(0, 0.999999); + @endcode + + The compiler does not take into account the type of the variable to + which you assign the result of RNG::uniform . The only thing that + matters to the compiler is the type of a and b parameters. So, if you + want a floating-point random number, but the range boundaries are + integer numbers, either put dots in the end, if they are constants, or + use explicit type cast operators, as in the a1 initialization above. + @param a lower inclusive boundary of the returned random numbers. + @param b upper non-inclusive boundary of the returned random numbers. + */ int uniform(int a, int b); - //! returns uniformly distributed floating-point random number from [a,b) range + /** @overload */ float uniform(float a, float b); - //! returns uniformly distributed double-precision floating-point random number from [a,b) range + /** @overload */ double uniform(double a, double b); + + /** @brief Fills arrays with random numbers. + + @param mat 2D or N-dimensional matrix; currently matrices with more than + 4 channels are not supported by the methods, use Mat::reshape as a + possible workaround. + @param distType distribution type, RNG::UNIFORM or RNG::NORMAL. + @param a first distribution parameter; in case of the uniform + distribution, this is an inclusive lower boundary, in case of the normal + distribution, this is a mean value. + @param b second distribution parameter; in case of the uniform + distribution, this is a non-inclusive upper boundary, in case of the + normal distribution, this is a standard deviation (diagonal of the + standard deviation matrix or the full standard deviation matrix). + @param saturateRange pre-saturation flag; for uniform distribution only; + if true, the method will first convert a and b to the acceptable value + range (according to the mat datatype) and then will generate uniformly + distributed random numbers within the range [saturate(a), saturate(b)), + if saturateRange=false, the method will generate uniformly distributed + random numbers in the original range [a, b) and then will saturate them, + it means, for example, that + theRNG().fill(mat_8u, RNG::UNIFORM, -DBL_MAX, DBL_MAX) will likely + produce array mostly filled with 0's and 255's, since the range (0, 255) + is significantly smaller than [-DBL_MAX, DBL_MAX). + + Each of the methods fills the matrix with the random values from the + specified distribution. As the new numbers are generated, the RNG state + is updated accordingly. In case of multiple-channel images, every + channel is filled independently, which means that RNG cannot generate + samples from the multi-dimensional Gaussian distribution with + non-diagonal covariance matrix directly. To do that, the method + generates samples from multi-dimensional standard Gaussian distribution + with zero mean and identity covariation matrix, and then transforms them + using transform to get samples from the specified Gaussian distribution. + */ void fill( InputOutputArray mat, int distType, InputArray a, InputArray b, bool saturateRange = false ); - //! returns Gaussian random variate with mean zero. + + /** @brief Returns the next random number sampled from the Gaussian distribution + @param sigma standard deviation of the distribution. + + The method transforms the state using the MWC algorithm and returns the + next random number from the Gaussian distribution N(0,sigma) . That is, + the mean value of the returned random numbers is zero and the standard + deviation is the specified sigma . + */ double gaussian(double sigma); uint64 state; }; +/** @brief Mersenne Twister random number generator + +Inspired by http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/CODES/mt19937ar.c +@todo document + */ class CV_EXPORTS RNG_MT19937 { public: @@ -805,11 +2629,17 @@ public: unsigned operator ()(unsigned N); unsigned operator ()(); - // returns uniformly distributed integer random number from [a,b) range + /** @brief returns uniformly distributed integer random number from [a,b) range + +*/ int uniform(int a, int b); - // returns uniformly distributed floating-point random number from [a,b) range + /** @brief returns uniformly distributed floating-point random number from [a,b) range + +*/ float uniform(float a, float b); - // returns uniformly distributed double-precision floating-point random number from [a,b) range + /** @brief returns uniformly distributed double-precision floating-point random number from [a,b) range + +*/ double uniform(double a, double b); private: @@ -818,10 +2648,132 @@ private: int mti; }; +//! @} core_array + +//! @addtogroup core_cluster +//! @{ + +/** @example kmeans.cpp + An example on K-means clustering +*/ + +/** @brief Finds centers of clusters and groups input samples around the clusters. + +The function kmeans implements a k-means algorithm that finds the centers of cluster_count clusters +and groups the input samples around the clusters. As an output, \f$\texttt{labels}_i\f$ contains a +0-based cluster index for the sample stored in the \f$i^{th}\f$ row of the samples matrix. + +@note +- (Python) An example on K-means clustering can be found at + opencv_source_code/samples/python2/kmeans.py +@param data Data for clustering. An array of N-Dimensional points with float coordinates is needed. +Examples of this array can be: +- Mat points(count, 2, CV_32F); +- Mat points(count, 1, CV_32FC2); +- Mat points(1, count, CV_32FC2); +- std::vector\ points(sampleCount); +@param K Number of clusters to split the set by. +@param bestLabels Input/output integer array that stores the cluster indices for every sample. +@param criteria The algorithm termination criteria, that is, the maximum number of iterations and/or +the desired accuracy. The accuracy is specified as criteria.epsilon. As soon as each of the cluster +centers moves by less than criteria.epsilon on some iteration, the algorithm stops. +@param attempts Flag to specify the number of times the algorithm is executed using different +initial labellings. The algorithm returns the labels that yield the best compactness (see the last +function parameter). +@param flags Flag that can take values of cv::KmeansFlags +@param centers Output matrix of the cluster centers, one row per each cluster center. +@return The function returns the compactness measure that is computed as +\f[\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2\f] +after every attempt. The best (minimum) value is chosen and the corresponding labels and the +compactness value are returned by the function. Basically, you can use only the core of the +function, set the number of attempts to 1, initialize labels each time using a custom algorithm, +pass them with the ( flags = KMEANS_USE_INITIAL_LABELS ) flag, and then choose the best +(most-compact) clustering. +*/ +CV_EXPORTS_W double kmeans( InputArray data, int K, InputOutputArray bestLabels, + TermCriteria criteria, int attempts, + int flags, OutputArray centers = noArray() ); + +//! @} core_cluster + +//! @addtogroup imgproc_drawing +//! @{ + +/*! @brief Line iterator + +The class is used to iterate over all the pixels on the raster line +segment connecting two specified points. + +The class LineIterator is used to get each pixel of a raster line. It +can be treated as versatile implementation of the Bresenham algorithm +where you can stop at each pixel and do some extra processing, for +example, grab pixel values along the line or draw a line with an effect +(for example, with XOR operation). + +The number of pixels along the line is stored in LineIterator::count. +The method LineIterator::pos returns the current position in the image: + +@code{.cpp} +// grabs pixels along the line (pt1, pt2) +// from 8-bit 3-channel image to the buffer +LineIterator it(img, pt1, pt2, 8); +LineIterator it2 = it; +vector buf(it.count); + +for(int i = 0; i < it.count; i++, ++it) + buf[i] = *(const Vec3b)*it; + +// alternative way of iterating through the line +for(int i = 0; i < it2.count; i++, ++it2) +{ + Vec3b val = img.at(it2.pos()); + CV_Assert(buf[i] == val); +} +@endcode +*/ +class CV_EXPORTS LineIterator +{ +public: + /** @brief intializes the iterator + + creates iterators for the line connecting pt1 and pt2 + the line will be clipped on the image boundaries + the line is 8-connected or 4-connected + If leftToRight=true, then the iteration is always done + from the left-most point to the right most, + not to depend on the ordering of pt1 and pt2 parameters + */ + LineIterator( const Mat& img, Point pt1, Point pt2, + int connectivity = 8, bool leftToRight = false ); + /** @brief returns pointer to the current pixel + */ + uchar* operator *(); + /** @brief prefix increment operator (++it). shifts iterator to the next pixel + */ + LineIterator& operator ++(); + /** @brief postfix increment operator (it++). shifts iterator to the next pixel + */ + LineIterator operator ++(int); + /** @brief returns coordinates of the current pixel + */ + Point pos() const; + + uchar* ptr; + const uchar* ptr0; + int step, elemSize; + int err, count; + int minusDelta, plusDelta; + int minusStep, plusStep; +}; + +//! @} imgproc_drawing +//! @addtogroup core_basic +//! @{ /////////////////////////////// Formatted output of cv::Mat /////////////////////////// +/** @todo document */ class CV_EXPORTS Formatted { public: @@ -830,7 +2782,7 @@ public: virtual ~Formatted(); }; - +/** @todo document */ class CV_EXPORTS Formatter { public: @@ -855,7 +2807,6 @@ public: }; - //////////////////////////////////////// Algorithm //////////////////////////////////// class CV_EXPORTS Algorithm; @@ -864,17 +2815,109 @@ struct CV_EXPORTS AlgorithmInfoData; template struct ParamType {}; -/*! - Base class for high-level OpenCV algorithms -*/ + +/** @brief This is a base class for all more or less complex algorithms in OpenCV + +especially for classes of algorithms, for which there can be multiple implementations. The examples +are stereo correspondence (for which there are algorithms like block matching, semi-global block +matching, graph-cut etc.), background subtraction (which can be done using mixture-of-gaussians +models, codebook-based algorithm etc.), optical flow (block matching, Lucas-Kanade, Horn-Schunck +etc.). + +The class provides the following features for all derived classes: + +- so called "virtual constructor". That is, each Algorithm derivative is registered at program + start and you can get the list of registered algorithms and create instance of a particular + algorithm by its name (see Algorithm::create). If you plan to add your own algorithms, it is + good practice to add a unique prefix to your algorithms to distinguish them from other + algorithms. +- setting/retrieving algorithm parameters by name. If you used video capturing functionality + from OpenCV videoio module, you are probably familar with cvSetCaptureProperty(), + cvGetCaptureProperty(), VideoCapture::set() and VideoCapture::get(). Algorithm provides + similar method where instead of integer id's you specify the parameter names as text strings. + See Algorithm::set and Algorithm::get for details. +- reading and writing parameters from/to XML or YAML files. Every Algorithm derivative can store + all its parameters and then read them back. There is no need to re-implement it each time. + +Here is example of SIFT use in your application via Algorithm interface: +@code + #include "opencv2/opencv.hpp" + #include "opencv2/xfeatures2d.hpp" + + using namespace cv::xfeatures2d; + + ... + + Ptr sift = SIFT::create(); + + FileStorage fs("sift_params.xml", FileStorage::READ); + if( fs.isOpened() ) // if we have file with parameters, read them + { + sift->read(fs["sift_params"]); + fs.release(); + } + else // else modify the parameters and store them; user can later edit the file to use different parameters + { + sift->setContrastThreshold(0.01f); // lower the contrast threshold, compared to the default value + + { + WriteStructContext ws(fs, "sift_params", CV_NODE_MAP); + sift->write(fs); + } + } + + Mat image = imread("myimage.png", 0), descriptors; + vector keypoints; + sift->detectAndCompute(image, noArray(), keypoints, descriptors); +@endcode + +Creating Own Algorithms +----------------------- +If you want to make your own algorithm, derived from Algorithm, you should basically follow a few +conventions and add a little semi-standard piece of code to your class: +- Make a class and specify Algorithm as its base class. +- The algorithm parameters should be the class members. See Algorithm::get() for the list of + possible types of the parameters. +- Add public virtual method `AlgorithmInfo* info() const;` to your class. +- Add constructor function, AlgorithmInfo instance and implement the info() method. The simplest + way is to take as + the reference and modify it according to the list of your parameters. +- Add some public function (e.g. `initModule_()`) that calls info() of your algorithm + and put it into the same source file as info() implementation. This is to force C++ linker to + include this object file into the target application. See Algorithm::create() for details. + */ class CV_EXPORTS_W Algorithm -{ -public: + { + public: Algorithm(); virtual ~Algorithm(); + /**Returns the algorithm name*/ String name() const; + /** @brief returns the algorithm parameter + + The method returns value of the particular parameter. Since the compiler can not deduce the + type of the returned parameter, you should specify it explicitly in angle brackets. Here are + the allowed forms of get: + + - myalgo.get\("param_name") + - myalgo.get\("param_name") + - myalgo.get\("param_name") + - myalgo.get\("param_name") + - myalgo.get\("param_name") + - myalgo.get\ \>("param_name") + - myalgo.get\("param_name") (it returns Ptr\). + + In some cases the actual type of the parameter can be cast to the specified type, e.g. integer + parameter can be cast to double, bool can be cast to int. But "dangerous" transformations + (string\<-\>number, double-\>int, 1x1 Mat\<-\>number, ...) are not performed and the method + will throw an exception. In the case of Mat or vector\ parameters the method does not + clone the matrix data, so do not modify the matrices. Use Algorithm::set instead - slower, but + more safe. + @param name The parameter name. + */ template typename ParamType<_Tp>::member_type get(const String& name) const; + /** @overload */ template typename ParamType<_Tp>::member_type get(const char* name) const; CV_WRAP int getInt(const String& name) const; @@ -885,6 +2928,14 @@ public: CV_WRAP std::vector getMatVector(const String& name) const; CV_WRAP Ptr getAlgorithm(const String& name) const; + /** @brief Sets the algorithm parameter + + The method sets value of the particular parameter. Some of the algorithm + parameters may be declared as read-only. If you try to set such a + parameter, you will get exception with the corresponding error message. + @param name The parameter name. + @param value The parameter value. + */ void set(const String& name, int value); void set(const String& name, double value); void set(const String& name, bool value); @@ -926,22 +2977,97 @@ public: CV_WRAP int paramType(const String& name) const; CV_WRAP void getParams(CV_OUT std::vector& names) const; - + /** @brief Stores algorithm parameters in a file storage + + The method stores all the algorithm parameters (in alphabetic order) to + the file storage. The method is virtual. If you define your own + Algorithm derivative, your can override the method and store some extra + information. However, it's rarely needed. Here are some examples: + - SIFT feature detector (from xfeatures2d module). The class only + stores algorithm parameters and no keypoints or their descriptors. + Therefore, it's enough to store the algorithm parameters, which is + what Algorithm::write() does. Therefore, there is no dedicated + SIFT::write(). + - Background subtractor (from video module). It has the algorithm + parameters and also it has the current background model. However, + the background model is not stored. First, it's rather big. Then, + if you have stored the background model, it would likely become + irrelevant on the next run (because of shifted camera, changed + background, different lighting etc.). Therefore, + BackgroundSubtractorMOG and BackgroundSubtractorMOG2 also rely on + the standard Algorithm::write() to store just the algorithm + parameters. + - Expectation Maximization (from ml module). The algorithm finds + mixture of gaussians that approximates user data best of all. In + this case the model may be re-used on the next run to test new + data against the trained statistical model. So EM needs to store + the model. However, since the model is described by a few + parameters that are available as read-only algorithm parameters + (i.e. they are available via EM::get()), EM also relies on + Algorithm::write() to store both EM parameters and the model + (represented by read-only algorithm parameters). + @param fs File storage. + */ virtual void write(FileStorage& fs) const; + + /** @brief Reads algorithm parameters from a file storage + + The method reads all the algorithm parameters from the specified node of + a file storage. Similarly to Algorithm::write(), if you implement an + algorithm that needs to read some extra data and/or re-compute some + internal data, you may override the method. + @param fn File node of the file storage. + */ virtual void read(const FileNode& fn); typedef Algorithm* (*Constructor)(void); typedef int (Algorithm::*Getter)() const; typedef void (Algorithm::*Setter)(int); + /** @brief Returns the list of registered algorithms + + This static method returns the list of registered algorithms in + alphabetical order. Here is how to use it : + @code{.cpp} + vector algorithms; + Algorithm::getList(algorithms); + cout << "Algorithms: " << algorithms.size() << endl; + for (size_t i=0; i < algorithms.size(); i++) + cout << algorithms[i] << endl; + @endcode + @param algorithms The output vector of algorithm names. + */ CV_WRAP static void getList(CV_OUT std::vector& algorithms); CV_WRAP static Ptr _create(const String& name); + + /** @brief Creates algorithm instance by name + + This static method creates a new instance of the specified algorithm. If + there is no such algorithm, the method will silently return a null + pointer. Also, you should specify the particular Algorithm subclass as + _Tp (or simply Algorithm if you do not know it at that point). : + @code{.cpp} + Ptr bgfg = Algorithm::create("BackgroundSubtractor.MOG2"); + @endcode + @note This is important note about seemingly mysterious behavior of + Algorithm::create() when it returns NULL while it should not. The reason + is simple - Algorithm::create() resides in OpenCV's core module and the + algorithms are implemented in other modules. If you create algorithms + dynamically, C++ linker may decide to throw away the modules where the + actual algorithms are implemented, since you do not call any functions + from the modules. To avoid this problem, you need to call + initModule_\(); somewhere in the beginning of the program + before Algorithm::create(). For example, call initModule_xfeatures2d() + in order to use SURF/SIFT, call initModule_ml() to use expectation + maximization etc. + @param name The algorithm name, one of the names returned by Algorithm::getList(). + */ template static Ptr<_Tp> create(const String& name); virtual AlgorithmInfo* info() const /* TODO: make it = 0;*/ { return 0; } }; - +/** @todo document */ class CV_EXPORTS AlgorithmInfo { public: @@ -1032,7 +3158,7 @@ protected: const void* value, bool force=false) const; }; - +/** @todo document */ struct CV_EXPORTS Param { enum { INT=0, BOOLEAN=1, REAL=2, STRING=3, MAT=4, MAT_VECTOR=5, ALGORITHM=6, FLOAT=7, UNSIGNED_INT=8, UINT64=9, UCHAR=11 }; @@ -1138,6 +3264,8 @@ template<> struct ParamType enum { type = Param::UCHAR }; }; +//! @} core_basic + } //namespace cv #include "opencv2/core/operations.hpp" diff --git a/modules/core/include/opencv2/core/affine.hpp b/modules/core/include/opencv2/core/affine.hpp index 172f5297c6..f8e84b97ad 100644 --- a/modules/core/include/opencv2/core/affine.hpp +++ b/modules/core/include/opencv2/core/affine.hpp @@ -48,10 +48,15 @@ #include -/*! @file */ - namespace cv { + +//! @addtogroup core +//! @{ + + /** @brief Affine transform + @todo document + */ template class Affine3 { @@ -63,30 +68,31 @@ namespace cv Affine3(); - //Augmented affine matrix + //! Augmented affine matrix Affine3(const Mat4& affine); - //Rotation matrix + //! Rotation matrix Affine3(const Mat3& R, const Vec3& t = Vec3::all(0)); - //Rodrigues vector + //! Rodrigues vector Affine3(const Vec3& rvec, const Vec3& t = Vec3::all(0)); - //Combines all contructors above. Supports 4x4, 4x3, 3x3, 1x3, 3x1 sizes of data matrix + //! Combines all contructors above. Supports 4x4, 4x3, 3x3, 1x3, 3x1 sizes of data matrix explicit Affine3(const Mat& data, const Vec3& t = Vec3::all(0)); - //From 16th element array + //! From 16th element array explicit Affine3(const float_type* vals); + //! Create identity transform static Affine3 Identity(); - //Rotation matrix + //! Rotation matrix void rotation(const Mat3& R); - //Rodrigues vector + //! Rodrigues vector void rotation(const Vec3& rvec); - //Combines rotation methods above. Suports 3x3, 1x3, 3x1 sizes of data matrix; + //! Combines rotation methods above. Suports 3x3, 1x3, 3x1 sizes of data matrix; void rotation(const Mat& data); void linear(const Mat3& L); @@ -96,21 +102,21 @@ namespace cv Mat3 linear() const; Vec3 translation() const; - //Rodrigues vector + //! Rodrigues vector Vec3 rvec() const; Affine3 inv(int method = cv::DECOMP_SVD) const; - // a.rotate(R) is equivalent to Affine(R, 0) * a; + //! a.rotate(R) is equivalent to Affine(R, 0) * a; Affine3 rotate(const Mat3& R) const; - // a.rotate(R) is equivalent to Affine(rvec, 0) * a; + //! a.rotate(R) is equivalent to Affine(rvec, 0) * a; Affine3 rotate(const Vec3& rvec) const; - // a.translate(t) is equivalent to Affine(E, t) * a; + //! a.translate(t) is equivalent to Affine(E, t) * a; Affine3 translate(const Vec3& t) const; - // a.concatenate(affine) is equivalent to affine * a; + //! a.concatenate(affine) is equivalent to affine * a; Affine3 concatenate(const Affine3& affine) const; template operator Affine3() const; @@ -155,11 +161,15 @@ namespace cv typedef Vec vec_type; }; + +//! @} core + } +//! @cond IGNORED /////////////////////////////////////////////////////////////////////////////////// -/// Implementaiton +// Implementaiton template inline cv::Affine3::Affine3() @@ -431,7 +441,6 @@ cv::Affine3 cv::Affine3::cast() const return Affine3(matrix); } -/** @cond IGNORED */ template inline cv::Affine3 cv::operator*(const cv::Affine3& affine1, const cv::Affine3& affine2) { @@ -449,7 +458,6 @@ V cv::operator*(const cv::Affine3& affine, const V& v) r.z = m.val[8] * v.x + m.val[9] * v.y + m.val[10] * v.z + m.val[11]; return r; } -/** @endcond */ static inline cv::Vec3f cv::operator*(const cv::Affine3f& affine, const cv::Vec3f& v) @@ -507,6 +515,7 @@ cv::Affine3::operator Eigen::Transform() const #endif /* defined EIGEN_WORLD_VERSION && defined EIGEN_GEOMETRY_MODULE_H */ +//! @endcond #endif /* __cplusplus */ diff --git a/modules/core/include/opencv2/core/base.hpp b/modules/core/include/opencv2/core/base.hpp index d048dec496..5b3ef205cc 100644 --- a/modules/core/include/opencv2/core/base.hpp +++ b/modules/core/include/opencv2/core/base.hpp @@ -56,56 +56,59 @@ namespace cv { -// error codes +//! @addtogroup core_utils +//! @{ + namespace Error { -enum { - StsOk= 0, /* everithing is ok */ - StsBackTrace= -1, /* pseudo error for back trace */ - StsError= -2, /* unknown /unspecified error */ - StsInternal= -3, /* internal error (bad state) */ - StsNoMem= -4, /* insufficient memory */ - StsBadArg= -5, /* function arg/param is bad */ - StsBadFunc= -6, /* unsupported function */ - StsNoConv= -7, /* iter. didn't converge */ - StsAutoTrace= -8, /* tracing */ - HeaderIsNull= -9, /* image header is NULL */ - BadImageSize= -10, /* image size is invalid */ - BadOffset= -11, /* offset is invalid */ - BadDataPtr= -12, /**/ - BadStep= -13, /**/ - BadModelOrChSeq= -14, /**/ - BadNumChannels= -15, /**/ - BadNumChannel1U= -16, /**/ - BadDepth= -17, /**/ - BadAlphaChannel= -18, /**/ - BadOrder= -19, /**/ - BadOrigin= -20, /**/ - BadAlign= -21, /**/ - BadCallBack= -22, /**/ - BadTileSize= -23, /**/ - BadCOI= -24, /**/ - BadROISize= -25, /**/ - MaskIsTiled= -26, /**/ - StsNullPtr= -27, /* null pointer */ - StsVecLengthErr= -28, /* incorrect vector length */ - StsFilterStructContentErr= -29, /* incorr. filter structure content */ - StsKernelStructContentErr= -30, /* incorr. transform kernel content */ - StsFilterOffsetErr= -31, /* incorrect filter ofset value */ - StsBadSize= -201, /* the input/output structure size is incorrect */ - StsDivByZero= -202, /* division by zero */ - StsInplaceNotSupported= -203, /* in-place operation is not supported */ - StsObjectNotFound= -204, /* request can't be completed */ - StsUnmatchedFormats= -205, /* formats of input/output arrays differ */ - StsBadFlag= -206, /* flag is wrong or not supported */ - StsBadPoint= -207, /* bad CvPoint */ - StsBadMask= -208, /* bad format of mask (neither 8uC1 nor 8sC1)*/ - StsUnmatchedSizes= -209, /* sizes of input/output structures do not match */ - StsUnsupportedFormat= -210, /* the data format/type is not supported by the function*/ - StsOutOfRange= -211, /* some of parameters are out of range */ - StsParseError= -212, /* invalid syntax/structure of the parsed file */ - StsNotImplemented= -213, /* the requested function/feature is not implemented */ - StsBadMemBlock= -214, /* an allocated block has been corrupted */ - StsAssert= -215, /* assertion failed */ +//! error codes +enum Code { + StsOk= 0, //!< everithing is ok + StsBackTrace= -1, //!< pseudo error for back trace + StsError= -2, //!< unknown /unspecified error + StsInternal= -3, //!< internal error (bad state) + StsNoMem= -4, //!< insufficient memory + StsBadArg= -5, //!< function arg/param is bad + StsBadFunc= -6, //!< unsupported function + StsNoConv= -7, //!< iter. didn't converge + StsAutoTrace= -8, //!< tracing + HeaderIsNull= -9, //!< image header is NULL + BadImageSize= -10, //!< image size is invalid + BadOffset= -11, //!< offset is invalid + BadDataPtr= -12, //!< + BadStep= -13, //!< + BadModelOrChSeq= -14, //!< + BadNumChannels= -15, //!< + BadNumChannel1U= -16, //!< + BadDepth= -17, //!< + BadAlphaChannel= -18, //!< + BadOrder= -19, //!< + BadOrigin= -20, //!< + BadAlign= -21, //!< + BadCallBack= -22, //!< + BadTileSize= -23, //!< + BadCOI= -24, //!< + BadROISize= -25, //!< + MaskIsTiled= -26, //!< + StsNullPtr= -27, //!< null pointer + StsVecLengthErr= -28, //!< incorrect vector length + StsFilterStructContentErr= -29, //!< incorr. filter structure content + StsKernelStructContentErr= -30, //!< incorr. transform kernel content + StsFilterOffsetErr= -31, //!< incorrect filter ofset value + StsBadSize= -201, //!< the input/output structure size is incorrect + StsDivByZero= -202, //!< division by zero + StsInplaceNotSupported= -203, //!< in-place operation is not supported + StsObjectNotFound= -204, //!< request can't be completed + StsUnmatchedFormats= -205, //!< formats of input/output arrays differ + StsBadFlag= -206, //!< flag is wrong or not supported + StsBadPoint= -207, //!< bad CvPoint + StsBadMask= -208, //!< bad format of mask (neither 8uC1 nor 8sC1) + StsUnmatchedSizes= -209, //!< sizes of input/output structures do not match + StsUnsupportedFormat= -210, //!< the data format/type is not supported by the function + StsOutOfRange= -211, //!< some of parameters are out of range + StsParseError= -212, //!< invalid syntax/structure of the parsed file + StsNotImplemented= -213, //!< the requested function/feature is not implemented + StsBadMemBlock= -214, //!< an allocated block has been corrupted + StsAssert= -215, //!< assertion failed GpuNotSupported= -216, GpuApiCallError= -217, OpenGlNotSupported= -218, @@ -117,68 +120,135 @@ enum { }; } //Error -// matrix decomposition types -enum { DECOMP_LU = 0, - DECOMP_SVD = 1, - DECOMP_EIG = 2, - DECOMP_CHOLESKY = 3, - DECOMP_QR = 4, - DECOMP_NORMAL = 16 - }; - -// norm types -enum { NORM_INF = 1, - NORM_L1 = 2, - NORM_L2 = 4, - NORM_L2SQR = 5, - NORM_HAMMING = 6, - NORM_HAMMING2 = 7, - NORM_TYPE_MASK = 7, - NORM_RELATIVE = 8, - NORM_MINMAX = 32 - }; - -// comparison types -enum { CMP_EQ = 0, - CMP_GT = 1, - CMP_GE = 2, - CMP_LT = 3, - CMP_LE = 4, - CMP_NE = 5 - }; - -enum { GEMM_1_T = 1, - GEMM_2_T = 2, - GEMM_3_T = 4 - }; - -enum { DFT_INVERSE = 1, - DFT_SCALE = 2, - DFT_ROWS = 4, - DFT_COMPLEX_OUTPUT = 16, - DFT_REAL_OUTPUT = 32, - DCT_INVERSE = DFT_INVERSE, - DCT_ROWS = DFT_ROWS - }; - -//! Various border types, image boundaries are denoted with '|' -enum { - BORDER_CONSTANT = 0, // iiiiii|abcdefgh|iiiiiii with some specified 'i' - BORDER_REPLICATE = 1, // aaaaaa|abcdefgh|hhhhhhh - BORDER_REFLECT = 2, // fedcba|abcdefgh|hgfedcb - BORDER_WRAP = 3, // cdefgh|abcdefgh|abcdefg - BORDER_REFLECT_101 = 4, // gfedcb|abcdefgh|gfedcba - BORDER_TRANSPARENT = 5, // uvwxyz|absdefgh|ijklmno - - BORDER_REFLECT101 = BORDER_REFLECT_101, - BORDER_DEFAULT = BORDER_REFLECT_101, - BORDER_ISOLATED = 16 // do not look outside of ROI - }; +//! @} core_utils + +//! @addtogroup core_array +//! @{ + +//! matrix decomposition types +enum DecompTypes { + /** Gaussian elimination with the optimal pivot element chosen. */ + DECOMP_LU = 0, + /** singular value decomposition (SVD) method; the system can be over-defined and/or the matrix + src1 can be singular */ + DECOMP_SVD = 1, + /** eigenvalue decomposition; the matrix src1 must be symmetrical */ + DECOMP_EIG = 2, + /** Cholesky \f$LL^T\f$ factorization; the matrix src1 must be symmetrical and positively + defined */ + DECOMP_CHOLESKY = 3, + /** QR factorization; the system can be over-defined and/or the matrix src1 can be singular */ + DECOMP_QR = 4, + /** while all the previous flags are mutually exclusive, this flag can be used together with + any of the previous; it means that the normal equations + \f$\texttt{src1}^T\cdot\texttt{src1}\cdot\texttt{dst}=\texttt{src1}^T\texttt{src2}\f$ are + solved instead of the original system + \f$\texttt{src1}\cdot\texttt{dst}=\texttt{src2}\f$ */ + DECOMP_NORMAL = 16 +}; +/** norm types +- For one array: +\f[norm = \forkthree{\|\texttt{src1}\|_{L_{\infty}} = \max _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM\_INF}\) } +{ \| \texttt{src1} \| _{L_1} = \sum _I | \texttt{src1} (I)|}{if \(\texttt{normType} = \texttt{NORM\_L1}\) } +{ \| \texttt{src1} \| _{L_2} = \sqrt{\sum_I \texttt{src1}(I)^2} }{if \(\texttt{normType} = \texttt{NORM\_L2}\) }\f] + +- Absolute norm for two arrays +\f[norm = \forkthree{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} = \max _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM\_INF}\) } +{ \| \texttt{src1} - \texttt{src2} \| _{L_1} = \sum _I | \texttt{src1} (I) - \texttt{src2} (I)|}{if \(\texttt{normType} = \texttt{NORM\_L1}\) } +{ \| \texttt{src1} - \texttt{src2} \| _{L_2} = \sqrt{\sum_I (\texttt{src1}(I) - \texttt{src2}(I))^2} }{if \(\texttt{normType} = \texttt{NORM\_L2}\) }\f] + +- Relative norm for two arrays +\f[norm = \forkthree{\frac{\|\texttt{src1}-\texttt{src2}\|_{L_{\infty}} }{\|\texttt{src2}\|_{L_{\infty}} }}{if \(\texttt{normType} = \texttt{NORM\_RELATIVE\_INF}\) } +{ \frac{\|\texttt{src1}-\texttt{src2}\|_{L_1} }{\|\texttt{src2}\|_{L_1}} }{if \(\texttt{normType} = \texttt{NORM\_RELATIVE\_L1}\) } +{ \frac{\|\texttt{src1}-\texttt{src2}\|_{L_2} }{\|\texttt{src2}\|_{L_2}} }{if \(\texttt{normType} = \texttt{NORM\_RELATIVE\_L2}\) }\f] + */ +enum NormTypes { NORM_INF = 1, + NORM_L1 = 2, + NORM_L2 = 4, + NORM_L2SQR = 5, + NORM_HAMMING = 6, + NORM_HAMMING2 = 7, + NORM_TYPE_MASK = 7, + NORM_RELATIVE = 8, //!< flag + NORM_MINMAX = 32 //!< flag + }; + +//! comparison types +enum CmpTypes { CMP_EQ = 0, //!< src1 is equal to src2. + CMP_GT = 1, //!< src1 is greater than src2. + CMP_GE = 2, //!< src1 is greater than or equal to src2. + CMP_LT = 3, //!< src1 is less than src2. + CMP_LE = 4, //!< src1 is less than or equal to src2. + CMP_NE = 5 //!< src1 is unequal to src2. + }; + +//! generalized matrix multiplication flags +enum GemmFlags { GEMM_1_T = 1, //!< transposes src1 + GEMM_2_T = 2, //!< transposes src2 + GEMM_3_T = 4 //!< transposes src3 + }; + +enum DftFlags { + /** performs an inverse 1D or 2D transform instead of the default forward + transform. */ + DFT_INVERSE = 1, + /** scales the result: divide it by the number of array elements. Normally, it is + combined with DFT_INVERSE. */ + DFT_SCALE = 2, + /** performs a forward or inverse transform of every individual row of the input + matrix; this flag enables you to transform multiple vectors simultaneously and can be used to + decrease the overhead (which is sometimes several times larger than the processing itself) to + perform 3D and higher-dimensional transformations and so forth.*/ + DFT_ROWS = 4, + /** performs a forward transformation of 1D or 2D real array; the result, + though being a complex array, has complex-conjugate symmetry (*CCS*, see the function + description below for details), and such an array can be packed into a real array of the same + size as input, which is the fastest option and which is what the function does by default; + however, you may wish to get a full complex array (for simpler spectrum analysis, and so on) - + pass the flag to enable the function to produce a full-size complex output array. */ + DFT_COMPLEX_OUTPUT = 16, + /** performs an inverse transformation of a 1D or 2D complex array; the + result is normally a complex array of the same size, however, if the input array has + conjugate-complex symmetry (for example, it is a result of forward transformation with + DFT_COMPLEX_OUTPUT flag), the output is a real array; while the function itself does not + check whether the input is symmetrical or not, you can pass the flag and then the function + will assume the symmetry and produce the real output array (note that when the input is packed + into a real array and inverse transformation is executed, the function treats the input as a + packed complex-conjugate symmetrical array, and the output will also be a real array). */ + DFT_REAL_OUTPUT = 32, + /** performs an inverse 1D or 2D transform instead of the default forward transform. */ + DCT_INVERSE = DFT_INVERSE, + /** performs a forward or inverse transform of every individual row of the input + matrix. This flag enables you to transform multiple vectors simultaneously and can be used to + decrease the overhead (which is sometimes several times larger than the processing itself) to + perform 3D and higher-dimensional transforms and so forth.*/ + DCT_ROWS = DFT_ROWS +}; +//! Various border types, image boundaries are denoted with `|` +//! @see borderInterpolate, copyMakeBorder +enum BorderTypes { + BORDER_CONSTANT = 0, //!< `iiiiii|abcdefgh|iiiiiii` with some specified `i` + BORDER_REPLICATE = 1, //!< `aaaaaa|abcdefgh|hhhhhhh` + BORDER_REFLECT = 2, //!< `fedcba|abcdefgh|hgfedcb` + BORDER_WRAP = 3, //!< `cdefgh|abcdefgh|abcdefg` + BORDER_REFLECT_101 = 4, //!< `gfedcb|abcdefgh|gfedcba` + BORDER_TRANSPARENT = 5, //!< `uvwxyz|absdefgh|ijklmno` + + BORDER_REFLECT101 = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101 + BORDER_DEFAULT = BORDER_REFLECT_101, //!< same as BORDER_REFLECT_101 + BORDER_ISOLATED = 16 //!< do not look outside of ROI +}; -//////////////// static assert ///////////////// +//! @} core_array + +//! @addtogroup core_utils +//! @{ + +//! @cond IGNORED +//////////////// static assert ///////////////// #define CVAUX_CONCAT_EXP(a, b) a##b #define CVAUX_CONCAT(a, b) CVAUX_CONCAT_EXP(a,b) @@ -210,8 +280,7 @@ enum { # endif #endif -//! Suppress warning "-Wdeprecated-declarations" / C4996 - +// Suppress warning "-Wdeprecated-declarations" / C4996 #if defined(_MSC_VER) #define CV_DO_PRAGMA(x) __pragma(x) #elif defined(__GNUC__) @@ -225,7 +294,7 @@ enum { CV_DO_PRAGMA(warning(push)) \ CV_DO_PRAGMA(warning(disable: 4996)) #define CV_SUPPRESS_DEPRECATED_END CV_DO_PRAGMA(warning(pop)) -#elif defined __GNUC__ +#elif defined (__clang__) || ((__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) #define CV_SUPPRESS_DEPRECATED_START \ CV_DO_PRAGMA(GCC diagnostic push) \ CV_DO_PRAGMA(GCC diagnostic ignored "-Wdeprecated-declarations") @@ -234,16 +303,19 @@ enum { #define CV_SUPPRESS_DEPRECATED_START #define CV_SUPPRESS_DEPRECATED_END #endif +//! @endcond /*! @brief Signals an error and raises the exception. - By default the function prints information about the error to stderr, - then it either stops if setBreakOnError() had been called before or raises the exception. - It is possible to alternate error processing by using redirectError(). - @param _code - error code @see CVStatus - @param _err - error description - @param _func - function name. Available only when the compiler supports getting it - @param _file - source file name where the error has occured - @param _line - line number in the source file where the error has occured + +By default the function prints information about the error to stderr, +then it either stops if setBreakOnError() had been called before or raises the exception. +It is possible to alternate error processing by using redirectError(). +@param _code - error code (Error::Code) +@param _err - error description +@param _func - function name. Available only when the compiler supports getting it +@param _file - source file name where the error has occured +@param _line - line number in the source file where the error has occured +@see CV_Error, CV_Error_, CV_ErrorNoReturn, CV_ErrorNoReturn_, CV_Assert, CV_DbgAssert */ CV_EXPORTS void error(int _code, const String& _err, const char* _func, const char* _file, int _line); @@ -253,6 +325,8 @@ CV_EXPORTS void error(int _code, const String& _err, const char* _func, const ch # pragma GCC diagnostic ignored "-Winvalid-noreturn" # endif #endif + +/** same as cv::error, but does not return */ CV_INLINE CV_NORETURN void errorNoReturn(int _code, const String& _err, const char* _func, const char* _file, int _line) { error(_code, _err, _func, _file, _line); @@ -270,7 +344,6 @@ CV_INLINE CV_NORETURN void errorNoReturn(int _code, const String& _err, const ch # endif #endif - #if defined __GNUC__ #define CV_Func __func__ #elif defined _MSC_VER @@ -279,13 +352,47 @@ CV_INLINE CV_NORETURN void errorNoReturn(int _code, const String& _err, const ch #define CV_Func "" #endif +/** @brief Call the error handler. + +Currently, the error handler prints the error code and the error message to the standard +error stream `stderr`. In the Debug configuration, it then provokes memory access violation, so that +the execution stack and all the parameters can be analyzed by the debugger. In the Release +configuration, the exception is thrown. + +@param code one of Error::Code +@param msg error message +*/ #define CV_Error( code, msg ) cv::error( code, msg, CV_Func, __FILE__, __LINE__ ) + +/** @brief Call the error handler. + +This macro can be used to construct an error message on-fly to include some dynamic information, +for example: +@code + // note the extra parentheses around the formatted text message + CV_Error_( CV_StsOutOfRange, + ("the value at (%d, %d)=%g is out of range", badPt.x, badPt.y, badValue)); +@endcode +@param code one of Error::Code +@param args printf-like formatted error message in parentheses +*/ #define CV_Error_( code, args ) cv::error( code, cv::format args, CV_Func, __FILE__, __LINE__ ) + +/** @brief Checks a condition at runtime and throws exception if it fails + +The macros CV_Assert (and CV_DbgAssert(expr)) evaluate the specified expression. If it is 0, the macros +raise an error (see cv::error). The macro CV_Assert checks the condition in both Debug and Release +configurations while CV_DbgAssert is only retained in the Debug configuration. +*/ #define CV_Assert( expr ) if(!!(expr)) ; else cv::error( cv::Error::StsAssert, #expr, CV_Func, __FILE__, __LINE__ ) +/** same as CV_Error(code,msg), but does not return */ #define CV_ErrorNoReturn( code, msg ) cv::errorNoReturn( code, msg, CV_Func, __FILE__, __LINE__ ) + +/** same as CV_Error_(code,args), but does not return */ #define CV_ErrorNoReturn_( code, args ) cv::errorNoReturn( code, cv::format args, CV_Func, __FILE__, __LINE__ ) +/** replaced with CV_Assert(expr) in Debug configuration */ #ifdef _DEBUG # define CV_DbgAssert(expr) CV_Assert(expr) #else @@ -293,18 +400,50 @@ CV_INLINE CV_NORETURN void errorNoReturn(int _code, const String& _err, const ch #endif - /////////////// saturate_cast (used in image & signal processing) /////////////////// +/** +Template function for accurate conversion from one primitive type to another. + +The functions saturate_cast resemble the standard C++ cast operations, such as static_cast\() +and others. They perform an efficient and accurate conversion from one primitive type to another +(see the introduction chapter). saturate in the name means that when the input value v is out of the +range of the target type, the result is not formed just by taking low bits of the input, but instead +the value is clipped. For example: +@code + uchar a = saturate_cast(-100); // a = 0 (UCHAR_MIN) + short b = saturate_cast(33333.33333); // b = 32767 (SHRT_MAX) +@endcode +Such clipping is done when the target type is unsigned char , signed char , unsigned short or +signed short . For 32-bit integers, no clipping is done. + +When the parameter is a floating-point value and the target type is an integer (8-, 16- or 32-bit), +the floating-point value is first rounded to the nearest integer and then clipped if needed (when +the target type is 8- or 16-bit). + +This operation is used in the simplest or most complex image processing functions in OpenCV. + +@param v Function parameter. +@sa add, subtract, multiply, divide, Mat::convertTo +*/ template static inline _Tp saturate_cast(uchar v) { return _Tp(v); } +/** @overload */ template static inline _Tp saturate_cast(schar v) { return _Tp(v); } +/** @overload */ template static inline _Tp saturate_cast(ushort v) { return _Tp(v); } +/** @overload */ template static inline _Tp saturate_cast(short v) { return _Tp(v); } +/** @overload */ template static inline _Tp saturate_cast(unsigned v) { return _Tp(v); } +/** @overload */ template static inline _Tp saturate_cast(int v) { return _Tp(v); } +/** @overload */ template static inline _Tp saturate_cast(float v) { return _Tp(v); } +/** @overload */ template static inline _Tp saturate_cast(double v) { return _Tp(v); } +//! @cond IGNORED + template<> inline uchar saturate_cast(schar v) { return (uchar)std::max((int)v, 0); } template<> inline uchar saturate_cast(ushort v) { return (uchar)std::min((unsigned)v, (unsigned)UCHAR_MAX); } template<> inline uchar saturate_cast(int v) { return (uchar)((unsigned)v <= UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0); } @@ -341,7 +480,7 @@ template<> inline int saturate_cast(double v) { return cvRound(v) template<> inline unsigned saturate_cast(float v) { return cvRound(v); } template<> inline unsigned saturate_cast(double v) { return cvRound(v); } - +//! @endcond //////////////////////////////// low-level functions //////////////////////////////// @@ -358,18 +497,31 @@ CV_EXPORTS float normL2Sqr_(const float* a, const float* b, int n); CV_EXPORTS void exp(const float* src, float* dst, int n); CV_EXPORTS void log(const float* src, float* dst, int n); + CV_EXPORTS void fastAtan2(const float* y, const float* x, float* dst, int n, bool angleInDegrees); CV_EXPORTS void magnitude(const float* x, const float* y, float* dst, int n); -//! computes cube root of the argument +/** @brief Computes the cube root of an argument. + +The function cubeRoot computes \f$\sqrt[3]{\texttt{val}}\f$. Negative arguments are handled correctly. +NaN and Inf are not handled. The accuracy approaches the maximum possible accuracy for +single-precision data. +@param val A function argument. + */ CV_EXPORTS_W float cubeRoot(float val); -//! computes the angle in degrees (0..360) of the vector (x,y) -CV_EXPORTS_W float fastAtan2(float y, float x); +/** @brief Calculates the angle of a 2D vector in degrees. +The function fastAtan2 calculates the full-range angle of an input 2D vector. The angle is measured +in degrees and varies from 0 to 360 degrees. The accuracy is about 0.3 degrees. +@param x x-coordinate of the vector. +@param y y-coordinate of the vector. + */ +CV_EXPORTS_W float fastAtan2(float y, float x); /////////////////////////////////// inline norms //////////////////////////////////// + template static inline _AccTp normL2Sqr(const _Tp* a, int n) { @@ -503,9 +655,10 @@ _AccTp normInf(const _Tp* a, const _Tp* b, int n) } - ////////////////// forward declarations for important OpenCV types ////////////////// +//! @cond IGNORED + template class Vec; template class Matx; @@ -573,6 +726,13 @@ CV_EXPORTS void setUseIPP(bool flag); } // ipp +//! @endcond + +//! @} core_utils + +//! @addtogroup core_utils_neon +//! @{ + #if CV_NEON inline int32x2_t cv_vrnd_s32_f32(float32x2_t v) @@ -605,8 +765,52 @@ inline uint32x4_t cv_vrndq_u32_f32(float32x4_t v) return vcvtq_u32_f32(vaddq_f32(v, v_05)); } +inline float32x4_t cv_vrecpq_f32(float32x4_t val) +{ + float32x4_t reciprocal = vrecpeq_f32(val); + reciprocal = vmulq_f32(vrecpsq_f32(val, reciprocal), reciprocal); + reciprocal = vmulq_f32(vrecpsq_f32(val, reciprocal), reciprocal); + return reciprocal; +} + +inline float32x2_t cv_vrecp_f32(float32x2_t val) +{ + float32x2_t reciprocal = vrecpe_f32(val); + reciprocal = vmul_f32(vrecps_f32(val, reciprocal), reciprocal); + reciprocal = vmul_f32(vrecps_f32(val, reciprocal), reciprocal); + return reciprocal; +} + +inline float32x4_t cv_vrsqrtq_f32(float32x4_t val) +{ + float32x4_t e = vrsqrteq_f32(val); + e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(e, e), val), e); + e = vmulq_f32(vrsqrtsq_f32(vmulq_f32(e, e), val), e); + return e; +} + +inline float32x2_t cv_vrsqrt_f32(float32x2_t val) +{ + float32x2_t e = vrsqrte_f32(val); + e = vmul_f32(vrsqrts_f32(vmul_f32(e, e), val), e); + e = vmul_f32(vrsqrts_f32(vmul_f32(e, e), val), e); + return e; +} + +inline float32x4_t cv_vsqrtq_f32(float32x4_t val) +{ + return cv_vrecpq_f32(cv_vrsqrtq_f32(val)); +} + +inline float32x2_t cv_vsqrt_f32(float32x2_t val) +{ + return cv_vrecp_f32(cv_vrsqrt_f32(val)); +} + #endif +//! @} core_utils_neon + } // cv #endif //__OPENCV_CORE_BASE_HPP__ diff --git a/modules/core/include/opencv2/core/bufferpool.hpp b/modules/core/include/opencv2/core/bufferpool.hpp index c2de95a9f2..76df2d29fb 100644 --- a/modules/core/include/opencv2/core/bufferpool.hpp +++ b/modules/core/include/opencv2/core/bufferpool.hpp @@ -10,6 +10,9 @@ namespace cv { +//! @addtogroup core +//! @{ + class BufferPoolController { protected: @@ -21,6 +24,8 @@ public: virtual void freeAllReservedBuffers() = 0; }; +//! @} + } #endif // __OPENCV_CORE_BUFFER_POOL_HPP__ diff --git a/modules/core/include/opencv2/core/core_c.h b/modules/core/include/opencv2/core/core_c.h index 61a93a46e9..a0ed632642 100644 --- a/modules/core/include/opencv2/core/core_c.h +++ b/modules/core/include/opencv2/core/core_c.h @@ -65,17 +65,21 @@ extern "C" { #endif +/** @addtogroup core_c + @{ +*/ + /****************************************************************************************\ * Array allocation, deallocation, initialization and access to elements * \****************************************************************************************/ -/* wrapper. +/** `malloc` wrapper. If there is no enough memory, the function (as well as other OpenCV functions that call cvAlloc) raises an error. */ CVAPI(void*) cvAlloc( size_t size ); -/* wrapper. +/** `free` wrapper. Here and further all the memory releasing functions (that all call cvFree) take double pointer in order to to clear pointer to the data after releasing it. @@ -84,61 +88,213 @@ CVAPI(void*) cvAlloc( size_t size ); CVAPI(void) cvFree_( void* ptr ); #define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0) -/* Allocates and initializes IplImage header */ +/** @brief Creates an image header but does not allocate the image data. + +@param size Image width and height +@param depth Image depth (see cvCreateImage ) +@param channels Number of channels (see cvCreateImage ) + */ CVAPI(IplImage*) cvCreateImageHeader( CvSize size, int depth, int channels ); -/* Inializes IplImage header */ +/** @brief Initializes an image header that was previously allocated. + +The returned IplImage\* points to the initialized header. +@param image Image header to initialize +@param size Image width and height +@param depth Image depth (see cvCreateImage ) +@param channels Number of channels (see cvCreateImage ) +@param origin Top-left IPL_ORIGIN_TL or bottom-left IPL_ORIGIN_BL +@param align Alignment for image rows, typically 4 or 8 bytes + */ CVAPI(IplImage*) cvInitImageHeader( IplImage* image, CvSize size, int depth, int channels, int origin CV_DEFAULT(0), int align CV_DEFAULT(4)); -/* Creates IPL image (header and data) */ +/** @brief Creates an image header and allocates the image data. + +This function call is equivalent to the following code: +@code + header = cvCreateImageHeader(size, depth, channels); + cvCreateData(header); +@endcode +@param size Image width and height +@param depth Bit depth of image elements. See IplImage for valid depths. +@param channels Number of channels per pixel. See IplImage for details. This function only creates +images with interleaved channels. + */ CVAPI(IplImage*) cvCreateImage( CvSize size, int depth, int channels ); -/* Releases (i.e. deallocates) IPL image header */ +/** @brief Deallocates an image header. + +This call is an analogue of : +@code + if(image ) + { + iplDeallocate(*image, IPL_IMAGE_HEADER | IPL_IMAGE_ROI); + *image = 0; + } +@endcode +but it does not use IPL functions by default (see the CV_TURN_ON_IPL_COMPATIBILITY macro). +@param image Double pointer to the image header + */ CVAPI(void) cvReleaseImageHeader( IplImage** image ); -/* Releases IPL image header and data */ +/** @brief Deallocates the image header and the image data. + +This call is a shortened form of : +@code + if(*image ) + { + cvReleaseData(*image); + cvReleaseImageHeader(image); + } +@endcode +@param image Double pointer to the image header +*/ CVAPI(void) cvReleaseImage( IplImage** image ); -/* Creates a copy of IPL image (widthStep may differ) */ +/** Creates a copy of IPL image (widthStep may differ) */ CVAPI(IplImage*) cvCloneImage( const IplImage* image ); -/* Sets a Channel Of Interest (only a few functions support COI) - - use cvCopy to extract the selected channel and/or put it back */ +/** @brief Sets the channel of interest in an IplImage. + +If the ROI is set to NULL and the coi is *not* 0, the ROI is allocated. Most OpenCV functions do +*not* support the COI setting, so to process an individual image/matrix channel one may copy (via +cvCopy or cvSplit) the channel to a separate image/matrix, process it and then copy the result +back (via cvCopy or cvMerge) if needed. +@param image A pointer to the image header +@param coi The channel of interest. 0 - all channels are selected, 1 - first channel is selected, +etc. Note that the channel indices become 1-based. + */ CVAPI(void) cvSetImageCOI( IplImage* image, int coi ); -/* Retrieves image Channel Of Interest */ +/** @brief Returns the index of the channel of interest. + +Returns the channel of interest of in an IplImage. Returned values correspond to the coi in +cvSetImageCOI. +@param image A pointer to the image header + */ CVAPI(int) cvGetImageCOI( const IplImage* image ); -/* Sets image ROI (region of interest) (COI is not changed) */ +/** @brief Sets an image Region Of Interest (ROI) for a given rectangle. + +If the original image ROI was NULL and the rect is not the whole image, the ROI structure is +allocated. + +Most OpenCV functions support the use of ROI and treat the image rectangle as a separate image. For +example, all of the pixel coordinates are counted from the top-left (or bottom-left) corner of the +ROI, not the original image. +@param image A pointer to the image header +@param rect The ROI rectangle + */ CVAPI(void) cvSetImageROI( IplImage* image, CvRect rect ); -/* Resets image ROI and COI */ +/** @brief Resets the image ROI to include the entire image and releases the ROI structure. + +This produces a similar result to the following, but in addition it releases the ROI structure. : +@code + cvSetImageROI(image, cvRect(0, 0, image->width, image->height )); + cvSetImageCOI(image, 0); +@endcode +@param image A pointer to the image header + */ CVAPI(void) cvResetImageROI( IplImage* image ); -/* Retrieves image ROI */ +/** @brief Returns the image ROI. + +If there is no ROI set, cvRect(0,0,image-\>width,image-\>height) is returned. +@param image A pointer to the image header + */ CVAPI(CvRect) cvGetImageROI( const IplImage* image ); -/* Allocates and initializes CvMat header */ +/** @brief Creates a matrix header but does not allocate the matrix data. + +The function allocates a new matrix header and returns a pointer to it. The matrix data can then be +allocated using cvCreateData or set explicitly to user-allocated data via cvSetData. +@param rows Number of rows in the matrix +@param cols Number of columns in the matrix +@param type Type of the matrix elements, see cvCreateMat + */ CVAPI(CvMat*) cvCreateMatHeader( int rows, int cols, int type ); #define CV_AUTOSTEP 0x7fffffff -/* Initializes CvMat header */ +/** @brief Initializes a pre-allocated matrix header. + +This function is often used to process raw data with OpenCV matrix functions. For example, the +following code computes the matrix product of two matrices, stored as ordinary arrays: +@code + double a[] = { 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12 }; + + double b[] = { 1, 5, 9, + 2, 6, 10, + 3, 7, 11, + 4, 8, 12 }; + + double c[9]; + CvMat Ma, Mb, Mc ; + + cvInitMatHeader(&Ma, 3, 4, CV_64FC1, a); + cvInitMatHeader(&Mb, 4, 3, CV_64FC1, b); + cvInitMatHeader(&Mc, 3, 3, CV_64FC1, c); + + cvMatMulAdd(&Ma, &Mb, 0, &Mc); + // the c array now contains the product of a (3x4) and b (4x3) +@endcode +@param mat A pointer to the matrix header to be initialized +@param rows Number of rows in the matrix +@param cols Number of columns in the matrix +@param type Type of the matrix elements, see cvCreateMat . +@param data Optional: data pointer assigned to the matrix header +@param step Optional: full row width in bytes of the assigned data. By default, the minimal +possible step is used which assumes there are no gaps between subsequent rows of the matrix. + */ CVAPI(CvMat*) cvInitMatHeader( CvMat* mat, int rows, int cols, int type, void* data CV_DEFAULT(NULL), int step CV_DEFAULT(CV_AUTOSTEP) ); -/* Allocates and initializes CvMat header and allocates data */ +/** @brief Creates a matrix header and allocates the matrix data. + +The function call is equivalent to the following code: +@code + CvMat* mat = cvCreateMatHeader(rows, cols, type); + cvCreateData(mat); +@endcode +@param rows Number of rows in the matrix +@param cols Number of columns in the matrix +@param type The type of the matrix elements in the form +CV_\\C\ , where S=signed, U=unsigned, F=float. For +example, CV _ 8UC1 means the elements are 8-bit unsigned and the there is 1 channel, and CV _ +32SC2 means the elements are 32-bit signed and there are 2 channels. + */ CVAPI(CvMat*) cvCreateMat( int rows, int cols, int type ); -/* Releases CvMat header and deallocates matrix data - (reference counting is used for data) */ +/** @brief Deallocates a matrix. + +The function decrements the matrix data reference counter and deallocates matrix header. If the data +reference counter is 0, it also deallocates the data. : +@code + if(*mat ) + cvDecRefData(*mat); + cvFree((void**)mat); +@endcode +@param mat Double pointer to the matrix + */ CVAPI(void) cvReleaseMat( CvMat** mat ); -/* Decrements CvMat data reference counter and deallocates the data if - it reaches 0 */ +/** @brief Decrements an array data reference counter. + +The function decrements the data reference counter in a CvMat or CvMatND if the reference counter + +pointer is not NULL. If the counter reaches zero, the data is deallocated. In the current +implementation the reference counter is not NULL only if the data was allocated using the +cvCreateData function. The counter will be NULL in other cases such as: external data was assigned +to the header using cvSetData, header is part of a larger matrix or image, or the header was +converted from an image or n-dimensional matrix header. +@param arr Pointer to an array header + */ CV_INLINE void cvDecRefData( CvArr* arr ) { if( CV_IS_MAT( arr )) @@ -159,7 +315,12 @@ CV_INLINE void cvDecRefData( CvArr* arr ) } } -/* Increments CvMat data reference counter */ +/** @brief Increments array data reference counter. + +The function increments CvMat or CvMatND data reference counter and returns the new counter value if +the reference counter pointer is not NULL, otherwise it returns zero. +@param arr Array header + */ CV_INLINE int cvIncRefData( CvArr* arr ) { int refcount = 0; @@ -179,84 +340,205 @@ CV_INLINE int cvIncRefData( CvArr* arr ) } -/* Creates an exact copy of the input matrix (except, may be, step value) */ +/** Creates an exact copy of the input matrix (except, may be, step value) */ CVAPI(CvMat*) cvCloneMat( const CvMat* mat ); -/* Makes a new matrix from subrectangle of input array. - No data is copied */ +/** @brief Returns matrix header corresponding to the rectangular sub-array of input image or matrix. + +The function returns header, corresponding to a specified rectangle of the input array. In other + +words, it allows the user to treat a rectangular part of input array as a stand-alone array. ROI is +taken into account by the function so the sub-array of ROI is actually extracted. +@param arr Input array +@param submat Pointer to the resultant sub-array header +@param rect Zero-based coordinates of the rectangle of interest + */ CVAPI(CvMat*) cvGetSubRect( const CvArr* arr, CvMat* submat, CvRect rect ); #define cvGetSubArr cvGetSubRect -/* Selects row span of the input array: arr(start_row:delta_row:end_row,:) - (end_row is not included into the span). */ +/** @brief Returns array row or row span. + +The functions return the header, corresponding to a specified row/row span of the input array. +cvGetRow(arr, submat, row) is a shortcut for cvGetRows(arr, submat, row, row+1). +@param arr Input array +@param submat Pointer to the resulting sub-array header +@param start_row Zero-based index of the starting row (inclusive) of the span +@param end_row Zero-based index of the ending row (exclusive) of the span +@param delta_row Index step in the row span. That is, the function extracts every delta_row -th +row from start_row and up to (but not including) end_row . + */ CVAPI(CvMat*) cvGetRows( const CvArr* arr, CvMat* submat, int start_row, int end_row, int delta_row CV_DEFAULT(1)); +/** @overload +@param arr Input array +@param submat Pointer to the resulting sub-array header +@param row Zero-based index of the selected row +*/ CV_INLINE CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row ) { return cvGetRows( arr, submat, row, row + 1, 1 ); } -/* Selects column span of the input array: arr(:,start_col:end_col) - (end_col is not included into the span) */ +/** @brief Returns one of more array columns. + +The functions return the header, corresponding to a specified column span of the input array. That + +is, no data is copied. Therefore, any modifications of the submatrix will affect the original array. +If you need to copy the columns, use cvCloneMat. cvGetCol(arr, submat, col) is a shortcut for +cvGetCols(arr, submat, col, col+1). +@param arr Input array +@param submat Pointer to the resulting sub-array header +@param start_col Zero-based index of the starting column (inclusive) of the span +@param end_col Zero-based index of the ending column (exclusive) of the span + */ CVAPI(CvMat*) cvGetCols( const CvArr* arr, CvMat* submat, int start_col, int end_col ); +/** @overload +@param arr Input array +@param submat Pointer to the resulting sub-array header +@param col Zero-based index of the selected column +*/ CV_INLINE CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col ) { return cvGetCols( arr, submat, col, col + 1 ); } -/* Select a diagonal of the input array. - (diag = 0 means the main diagonal, >0 means a diagonal above the main one, - <0 - below the main one). - The diagonal will be represented as a column (nx1 matrix). */ +/** @brief Returns one of array diagonals. + +The function returns the header, corresponding to a specified diagonal of the input array. +@param arr Input array +@param submat Pointer to the resulting sub-array header +@param diag Index of the array diagonal. Zero value corresponds to the main diagonal, -1 +corresponds to the diagonal above the main, 1 corresponds to the diagonal below the main, and so +forth. + */ CVAPI(CvMat*) cvGetDiag( const CvArr* arr, CvMat* submat, int diag CV_DEFAULT(0)); -/* low-level scalar <-> raw data conversion functions */ +/** low-level scalar <-> raw data conversion functions */ CVAPI(void) cvScalarToRawData( const CvScalar* scalar, void* data, int type, int extend_to_12 CV_DEFAULT(0) ); CVAPI(void) cvRawDataToScalar( const void* data, int type, CvScalar* scalar ); -/* Allocates and initializes CvMatND header */ +/** @brief Creates a new matrix header but does not allocate the matrix data. + +The function allocates a header for a multi-dimensional dense array. The array data can further be +allocated using cvCreateData or set explicitly to user-allocated data via cvSetData. +@param dims Number of array dimensions +@param sizes Array of dimension sizes +@param type Type of array elements, see cvCreateMat + */ CVAPI(CvMatND*) cvCreateMatNDHeader( int dims, const int* sizes, int type ); -/* Allocates and initializes CvMatND header and allocates data */ +/** @brief Creates the header and allocates the data for a multi-dimensional dense array. + +This function call is equivalent to the following code: +@code + CvMatND* mat = cvCreateMatNDHeader(dims, sizes, type); + cvCreateData(mat); +@endcode +@param dims Number of array dimensions. This must not exceed CV_MAX_DIM (32 by default, but can be +changed at build time). +@param sizes Array of dimension sizes. +@param type Type of array elements, see cvCreateMat . + */ CVAPI(CvMatND*) cvCreateMatND( int dims, const int* sizes, int type ); -/* Initializes preallocated CvMatND header */ +/** @brief Initializes a pre-allocated multi-dimensional array header. + +@param mat A pointer to the array header to be initialized +@param dims The number of array dimensions +@param sizes An array of dimension sizes +@param type Type of array elements, see cvCreateMat +@param data Optional data pointer assigned to the matrix header + */ CVAPI(CvMatND*) cvInitMatNDHeader( CvMatND* mat, int dims, const int* sizes, int type, void* data CV_DEFAULT(NULL) ); -/* Releases CvMatND */ +/** @brief Deallocates a multi-dimensional array. + +The function decrements the array data reference counter and releases the array header. If the +reference counter reaches 0, it also deallocates the data. : +@code + if(*mat ) + cvDecRefData(*mat); + cvFree((void**)mat); +@endcode +@param mat Double pointer to the array + */ CV_INLINE void cvReleaseMatND( CvMatND** mat ) { cvReleaseMat( (CvMat**)mat ); } -/* Creates a copy of CvMatND (except, may be, steps) */ +/** Creates a copy of CvMatND (except, may be, steps) */ CVAPI(CvMatND*) cvCloneMatND( const CvMatND* mat ); -/* Allocates and initializes CvSparseMat header and allocates data */ +/** @brief Creates sparse array. + +The function allocates a multi-dimensional sparse array. Initially the array contain no elements, +that is PtrND and other related functions will return 0 for every index. +@param dims Number of array dimensions. In contrast to the dense matrix, the number of dimensions is +practically unlimited (up to \f$2^{16}\f$ ). +@param sizes Array of dimension sizes +@param type Type of array elements. The same as for CvMat + */ CVAPI(CvSparseMat*) cvCreateSparseMat( int dims, const int* sizes, int type ); -/* Releases CvSparseMat */ +/** @brief Deallocates sparse array. + +The function releases the sparse array and clears the array pointer upon exit. +@param mat Double pointer to the array + */ CVAPI(void) cvReleaseSparseMat( CvSparseMat** mat ); -/* Creates a copy of CvSparseMat (except, may be, zero items) */ +/** Creates a copy of CvSparseMat (except, may be, zero items) */ CVAPI(CvSparseMat*) cvCloneSparseMat( const CvSparseMat* mat ); -/* Initializes sparse array iterator - (returns the first node or NULL if the array is empty) */ +/** @brief Initializes sparse array elements iterator. + +The function initializes iterator of sparse array elements and returns pointer to the first element, +or NULL if the array is empty. +@param mat Input array +@param mat_iterator Initialized iterator + */ CVAPI(CvSparseNode*) cvInitSparseMatIterator( const CvSparseMat* mat, CvSparseMatIterator* mat_iterator ); -// returns next sparse array node (or NULL if there is no more nodes) +/** @brief Returns the next sparse matrix element + +The function moves iterator to the next sparse matrix element and returns pointer to it. In the +current version there is no any particular order of the elements, because they are stored in the +hash table. The sample below demonstrates how to iterate through the sparse matrix: +@code + // print all the non-zero sparse matrix elements and compute their sum + double sum = 0; + int i, dims = cvGetDims(sparsemat); + CvSparseMatIterator it; + CvSparseNode* node = cvInitSparseMatIterator(sparsemat, &it); + + for(; node != 0; node = cvGetNextSparseNode(&it)) + { + int* idx = CV_NODE_IDX(array, node); + float val = *(float*)CV_NODE_VAL(array, node); + printf("M"); + for(i = 0; i < dims; i++ ) + printf("[%d]", idx[i]); + printf("=%g\n", val); + + sum += val; + } + + printf("nTotal sum = %g\n", sum); +@endcode +@param mat_iterator Sparse array iterator + */ CV_INLINE CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator ) { if( mat_iterator->node->next ) @@ -277,18 +559,18 @@ CV_INLINE CvSparseNode* cvGetNextSparseNode( CvSparseMatIterator* mat_iterator ) } } -/**************** matrix iterator: used for n-ary operations on dense arrays *********/ #define CV_MAX_ARR 10 +/** matrix iterator: used for n-ary operations on dense arrays */ typedef struct CvNArrayIterator { - int count; /* number of arrays */ - int dims; /* number of dimensions to iterate */ - CvSize size; /* maximal common linear size: { width = size, height = 1 } */ - uchar* ptr[CV_MAX_ARR]; /* pointers to the array slices */ - int stack[CV_MAX_DIM]; /* for internal use */ - CvMatND* hdr[CV_MAX_ARR]; /* pointers to the headers of the + int count; /**< number of arrays */ + int dims; /**< number of dimensions to iterate */ + CvSize size; /**< maximal common linear size: { width = size, height = 1 } */ + uchar* ptr[CV_MAX_ARR]; /**< pointers to the array slices */ + int stack[CV_MAX_DIM]; /**< for internal use */ + CvMatND* hdr[CV_MAX_ARR]; /**< pointers to the headers of the matrices that are processed */ } CvNArrayIterator; @@ -297,7 +579,7 @@ CvNArrayIterator; #define CV_NO_CN_CHECK 2 #define CV_NO_SIZE_CHECK 4 -/* initializes iterator that traverses through several arrays simulteneously +/** initializes iterator that traverses through several arrays simulteneously (the function together with cvNextArraySlice is used for N-ari element-wise operations) */ CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs, @@ -305,92 +587,248 @@ CVAPI(int) cvInitNArrayIterator( int count, CvArr** arrs, CvNArrayIterator* array_iterator, int flags CV_DEFAULT(0) ); -/* returns zero value if iteration is finished, non-zero (slice length) otherwise */ +/** returns zero value if iteration is finished, non-zero (slice length) otherwise */ CVAPI(int) cvNextNArraySlice( CvNArrayIterator* array_iterator ); -/* Returns type of array elements: - CV_8UC1 ... CV_64FC4 ... */ +/** @brief Returns type of array elements. + +The function returns type of the array elements. In the case of IplImage the type is converted to +CvMat-like representation. For example, if the image has been created as: +@code + IplImage* img = cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 3); +@endcode +The code cvGetElemType(img) will return CV_8UC3. +@param arr Input array + */ CVAPI(int) cvGetElemType( const CvArr* arr ); -/* Retrieves number of an array dimensions and - optionally sizes of the dimensions */ +/** @brief Return number of array dimensions + +The function returns the array dimensionality and the array of dimension sizes. In the case of +IplImage or CvMat it always returns 2 regardless of number of image/matrix rows. For example, the +following code calculates total number of array elements: +@code + int sizes[CV_MAX_DIM]; + int i, total = 1; + int dims = cvGetDims(arr, size); + for(i = 0; i < dims; i++ ) + total *= sizes[i]; +@endcode +@param arr Input array +@param sizes Optional output vector of the array dimension sizes. For 2d arrays the number of rows +(height) goes first, number of columns (width) next. + */ CVAPI(int) cvGetDims( const CvArr* arr, int* sizes CV_DEFAULT(NULL) ); -/* Retrieves size of a particular array dimension. - For 2d arrays cvGetDimSize(arr,0) returns number of rows (image height) - and cvGetDimSize(arr,1) returns number of columns (image width) */ +/** @brief Returns array size along the specified dimension. + +@param arr Input array +@param index Zero-based dimension index (for matrices 0 means number of rows, 1 means number of +columns; for images 0 means height, 1 means width) + */ CVAPI(int) cvGetDimSize( const CvArr* arr, int index ); -/* ptr = &arr(idx0,idx1,...). All indexes are zero-based, - the major dimensions go first (e.g. (y,x) for 2D, (z,y,x) for 3D */ +/** @brief Return pointer to a particular array element. + +The functions return a pointer to a specific array element. Number of array dimension should match +to the number of indices passed to the function except for cvPtr1D function that can be used for +sequential access to 1D, 2D or nD dense arrays. + +The functions can be used for sparse arrays as well - if the requested node does not exist they +create it and set it to zero. + +All these as well as other functions accessing array elements ( cvGetND , cvGetRealND , cvSet +, cvSetND , cvSetRealND ) raise an error in case if the element index is out of range. +@param arr Input array +@param idx0 The first zero-based component of the element index +@param type Optional output parameter: type of matrix elements + */ CVAPI(uchar*) cvPtr1D( const CvArr* arr, int idx0, int* type CV_DEFAULT(NULL)); +/** @overload */ CVAPI(uchar*) cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) ); +/** @overload */ CVAPI(uchar*) cvPtr3D( const CvArr* arr, int idx0, int idx1, int idx2, int* type CV_DEFAULT(NULL)); - -/* For CvMat or IplImage number of indices should be 2 - (row index (y) goes first, column index (x) goes next). - For CvMatND or CvSparseMat number of infices should match number of and - indices order should match the array dimension order. */ +/** @overload +@param arr Input array +@param idx Array of the element indices +@param type Optional output parameter: type of matrix elements +@param create_node Optional input parameter for sparse matrices. Non-zero value of the parameter +means that the requested element is created if it does not exist already. +@param precalc_hashval Optional input parameter for sparse matrices. If the pointer is not NULL, +the function does not recalculate the node hash value, but takes it from the specified location. +It is useful for speeding up pair-wise operations (TODO: provide an example) +*/ CVAPI(uchar*) cvPtrND( const CvArr* arr, const int* idx, int* type CV_DEFAULT(NULL), int create_node CV_DEFAULT(1), unsigned* precalc_hashval CV_DEFAULT(NULL)); -/* value = arr(idx0,idx1,...) */ +/** @brief Return a specific array element. + +The functions return a specific array element. In the case of a sparse array the functions return 0 +if the requested node does not exist (no new node is created by the functions). +@param arr Input array +@param idx0 The first zero-based component of the element index + */ CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 ); +/** @overload */ CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 ); +/** @overload */ CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 ); +/** @overload +@param arr Input array +@param idx Array of the element indices +*/ CVAPI(CvScalar) cvGetND( const CvArr* arr, const int* idx ); -/* for 1-channel arrays */ +/** @brief Return a specific element of single-channel 1D, 2D, 3D or nD array. + +Returns a specific element of a single-channel array. If the array has multiple channels, a runtime +error is raised. Note that Get?D functions can be used safely for both single-channel and +multiple-channel arrays though they are a bit slower. + +In the case of a sparse array the functions return 0 if the requested node does not exist (no new +node is created by the functions). +@param arr Input array. Must have a single channel. +@param idx0 The first zero-based component of the element index + */ CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 ); +/** @overload */ CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 ); +/** @overload */ CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 ); +/** @overload +@param arr Input array. Must have a single channel. +@param idx Array of the element indices +*/ CVAPI(double) cvGetRealND( const CvArr* arr, const int* idx ); -/* arr(idx0,idx1,...) = value */ +/** @brief Change the particular array element. + +The functions assign the new value to a particular array element. In the case of a sparse array the +functions create the node if it does not exist yet. +@param arr Input array +@param idx0 The first zero-based component of the element index +@param value The assigned value + */ CVAPI(void) cvSet1D( CvArr* arr, int idx0, CvScalar value ); +/** @overload */ CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value ); +/** @overload */ CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value ); +/** @overload +@param arr Input array +@param idx Array of the element indices +@param value The assigned value +*/ CVAPI(void) cvSetND( CvArr* arr, const int* idx, CvScalar value ); -/* for 1-channel arrays */ +/** @brief Change a specific array element. + +The functions assign a new value to a specific element of a single-channel array. If the array has +multiple channels, a runtime error is raised. Note that the Set\*D function can be used safely for +both single-channel and multiple-channel arrays, though they are a bit slower. + +In the case of a sparse array the functions create the node if it does not yet exist. +@param arr Input array +@param idx0 The first zero-based component of the element index +@param value The assigned value + */ CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value ); +/** @overload */ CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value ); +/** @overload */ CVAPI(void) cvSetReal3D( CvArr* arr, int idx0, int idx1, int idx2, double value ); +/** @overload +@param arr Input array +@param idx Array of the element indices +@param value The assigned value +*/ CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value ); -/* clears element of ND dense array, +/** clears element of ND dense array, in case of sparse arrays it deletes the specified node */ CVAPI(void) cvClearND( CvArr* arr, const int* idx ); -/* Converts CvArr (IplImage or CvMat,...) to CvMat. - If the last parameter is non-zero, function can - convert multi(>2)-dimensional array to CvMat as long as - the last array's dimension is continous. The resultant - matrix will be have appropriate (a huge) number of rows */ +/** @brief Returns matrix header for arbitrary array. + +The function returns a matrix header for the input array that can be a matrix - CvMat, an image - +IplImage, or a multi-dimensional dense array - CvMatND (the third option is allowed only if +allowND != 0) . In the case of matrix the function simply returns the input pointer. In the case of +IplImage\* or CvMatND it initializes the header structure with parameters of the current image ROI +and returns &header. Because COI is not supported by CvMat, it is returned separately. + +The function provides an easy way to handle both types of arrays - IplImage and CvMat using the same +code. Input array must have non-zero data pointer, otherwise the function will report an error. + +@note If the input array is IplImage with planar data layout and COI set, the function returns the +pointer to the selected plane and COI == 0. This feature allows user to process IplImage structures +with planar data layout, even though OpenCV does not support such images. +@param arr Input array +@param header Pointer to CvMat structure used as a temporary buffer +@param coi Optional output parameter for storing COI +@param allowND If non-zero, the function accepts multi-dimensional dense arrays (CvMatND\*) and +returns 2D matrix (if CvMatND has two dimensions) or 1D matrix (when CvMatND has 1 dimension or +more than 2 dimensions). The CvMatND array must be continuous. +@sa cvGetImage, cvarrToMat. + */ CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header, int* coi CV_DEFAULT(NULL), int allowND CV_DEFAULT(0)); -/* Converts CvArr (IplImage or CvMat) to IplImage */ +/** @brief Returns image header for arbitrary array. + +The function returns the image header for the input array that can be a matrix (CvMat) or image +(IplImage). In the case of an image the function simply returns the input pointer. In the case of +CvMat it initializes an image_header structure with the parameters of the input matrix. Note that +if we transform IplImage to CvMat using cvGetMat and then transform CvMat back to IplImage using +this function, we will get different headers if the ROI is set in the original image. +@param arr Input array +@param image_header Pointer to IplImage structure used as a temporary buffer + */ CVAPI(IplImage*) cvGetImage( const CvArr* arr, IplImage* image_header ); -/* Changes a shape of multi-dimensional array. - new_cn == 0 means that number of channels remains unchanged. - new_dims == 0 means that number and sizes of dimensions remain the same - (unless they need to be changed to set the new number of channels) - if new_dims == 1, there is no need to specify new dimension sizes - The resultant configuration should be achievable w/o data copying. - If the resultant array is sparse, CvSparseMat header should be passed - to the function else if the result is 1 or 2 dimensional, - CvMat header should be passed to the function - else CvMatND header should be passed */ +/** @brief Changes the shape of a multi-dimensional array without copying the data. + +The function is an advanced version of cvReshape that can work with multi-dimensional arrays as +well (though it can work with ordinary images and matrices) and change the number of dimensions. + +Below are the two samples from the cvReshape description rewritten using cvReshapeMatND: +@code + IplImage* color_img = cvCreateImage(cvSize(320,240), IPL_DEPTH_8U, 3); + IplImage gray_img_hdr, *gray_img; + gray_img = (IplImage*)cvReshapeMatND(color_img, sizeof(gray_img_hdr), &gray_img_hdr, 1, 0, 0); + ... + int size[] = { 2, 2, 2 }; + CvMatND* mat = cvCreateMatND(3, size, CV_32F); + CvMat row_header, *row; + row = (CvMat*)cvReshapeMatND(mat, sizeof(row_header), &row_header, 0, 1, 0); +@endcode +In C, the header file for this function includes a convenient macro cvReshapeND that does away with +the sizeof_header parameter. So, the lines containing the call to cvReshapeMatND in the examples +may be replaced as follow: +@code + gray_img = (IplImage*)cvReshapeND(color_img, &gray_img_hdr, 1, 0, 0); + ... + row = (CvMat*)cvReshapeND(mat, &row_header, 0, 1, 0); +@endcode +@param arr Input array +@param sizeof_header Size of output header to distinguish between IplImage, CvMat and CvMatND +output headers +@param header Output header to be filled +@param new_cn New number of channels. new_cn = 0 means that the number of channels remains +unchanged. +@param new_dims New number of dimensions. new_dims = 0 means that the number of dimensions +remains the same. +@param new_sizes Array of new dimension sizes. Only new_dims-1 values are used, because the +total number of elements must remain the same. Thus, if new_dims = 1, new_sizes array is not +used. + */ CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr, int sizeof_header, CvArr* header, int new_cn, int new_dims, int* new_sizes ); @@ -399,70 +837,184 @@ CVAPI(CvArr*) cvReshapeMatND( const CvArr* arr, cvReshapeMatND( (arr), sizeof(*(header)), (header), \ (new_cn), (new_dims), (new_sizes)) +/** @brief Changes shape of matrix/image without copying data. + +The function initializes the CvMat header so that it points to the same data as the original array +but has a different shape - different number of channels, different number of rows, or both. + +The following example code creates one image buffer and two image headers, the first is for a +320x240x3 image and the second is for a 960x240x1 image: +@code + IplImage* color_img = cvCreateImage(cvSize(320,240), IPL_DEPTH_8U, 3); + CvMat gray_mat_hdr; + IplImage gray_img_hdr, *gray_img; + cvReshape(color_img, &gray_mat_hdr, 1); + gray_img = cvGetImage(&gray_mat_hdr, &gray_img_hdr); +@endcode +And the next example converts a 3x3 matrix to a single 1x9 vector: +@code + CvMat* mat = cvCreateMat(3, 3, CV_32F); + CvMat row_header, *row; + row = cvReshape(mat, &row_header, 0, 1); +@endcode +@param arr Input array +@param header Output header to be filled +@param new_cn New number of channels. 'new_cn = 0' means that the number of channels remains +unchanged. +@param new_rows New number of rows. 'new_rows = 0' means that the number of rows remains +unchanged unless it needs to be changed according to new_cn value. +*/ CVAPI(CvMat*) cvReshape( const CvArr* arr, CvMat* header, int new_cn, int new_rows CV_DEFAULT(0) ); -/* Repeats source 2d array several times in both horizontal and +/** Repeats source 2d array several times in both horizontal and vertical direction to fill destination array */ CVAPI(void) cvRepeat( const CvArr* src, CvArr* dst ); -/* Allocates array data */ +/** @brief Allocates array data + +The function allocates image, matrix or multi-dimensional dense array data. Note that in the case of +matrix types OpenCV allocation functions are used. In the case of IplImage they are used unless +CV_TURN_ON_IPL_COMPATIBILITY() has been called before. In the latter case IPL functions are used +to allocate the data. +@param arr Array header + */ CVAPI(void) cvCreateData( CvArr* arr ); -/* Releases array data */ +/** @brief Releases array data. + +The function releases the array data. In the case of CvMat or CvMatND it simply calls +cvDecRefData(), that is the function can not deallocate external data. See also the note to +cvCreateData . +@param arr Array header + */ CVAPI(void) cvReleaseData( CvArr* arr ); -/* Attaches user data to the array header. The step is reffered to - the pre-last dimension. That is, all the planes of the array - must be joint (w/o gaps) */ +/** @brief Assigns user data to the array header. + +The function assigns user data to the array header. Header should be initialized before using +cvCreateMatHeader, cvCreateImageHeader, cvCreateMatNDHeader, cvInitMatHeader, +cvInitImageHeader or cvInitMatNDHeader. +@param arr Array header +@param data User data +@param step Full row length in bytes + */ CVAPI(void) cvSetData( CvArr* arr, void* data, int step ); -/* Retrieves raw data of CvMat, IplImage or CvMatND. - In the latter case the function raises an error if - the array can not be represented as a matrix */ +/** @brief Retrieves low-level information about the array. + +The function fills output variables with low-level information about the array data. All output + +parameters are optional, so some of the pointers may be set to NULL. If the array is IplImage with +ROI set, the parameters of ROI are returned. + +The following example shows how to get access to array elements. It computes absolute values of the +array elements : +@code + float* data; + int step; + CvSize size; + + cvGetRawData(array, (uchar**)&data, &step, &size); + step /= sizeof(data[0]); + + for(int y = 0; y < size.height; y++, data += step ) + for(int x = 0; x < size.width; x++ ) + data[x] = (float)fabs(data[x]); +@endcode +@param arr Array header +@param data Output pointer to the whole image origin or ROI origin if ROI is set +@param step Output full row length in bytes +@param roi_size Output ROI size + */ CVAPI(void) cvGetRawData( const CvArr* arr, uchar** data, int* step CV_DEFAULT(NULL), CvSize* roi_size CV_DEFAULT(NULL)); -/* Returns width and height of array in elements */ +/** @brief Returns size of matrix or image ROI. + +The function returns number of rows (CvSize::height) and number of columns (CvSize::width) of the +input matrix or image. In the case of image the size of ROI is returned. +@param arr array header + */ CVAPI(CvSize) cvGetSize( const CvArr* arr ); -/* Copies source array to destination array */ +/** @brief Copies one array to another. + +The function copies selected elements from an input array to an output array: + +\f[\texttt{dst} (I)= \texttt{src} (I) \quad \text{if} \quad \texttt{mask} (I) \ne 0.\f] + +If any of the passed arrays is of IplImage type, then its ROI and COI fields are used. Both arrays +must have the same type, the same number of dimensions, and the same size. The function can also +copy sparse arrays (mask is not supported in this case). +@param src The source array +@param dst The destination array +@param mask Operation mask, 8-bit single channel array; specifies elements of the destination array +to be changed + */ CVAPI(void) cvCopy( const CvArr* src, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL) ); -/* Sets all or "masked" elements of input array - to the same value*/ +/** @brief Sets every element of an array to a given value. + +The function copies the scalar value to every selected element of the destination array: +\f[\texttt{arr} (I)= \texttt{value} \quad \text{if} \quad \texttt{mask} (I) \ne 0\f] +If array arr is of IplImage type, then is ROI used, but COI must not be set. +@param arr The destination array +@param value Fill value +@param mask Operation mask, 8-bit single channel array; specifies elements of the destination +array to be changed + */ CVAPI(void) cvSet( CvArr* arr, CvScalar value, const CvArr* mask CV_DEFAULT(NULL) ); -/* Clears all the array elements (sets them to 0) */ +/** @brief Clears the array. + +The function clears the array. In the case of dense arrays (CvMat, CvMatND or IplImage), +cvZero(array) is equivalent to cvSet(array,cvScalarAll(0),0). In the case of sparse arrays all the +elements are removed. +@param arr Array to be cleared + */ CVAPI(void) cvSetZero( CvArr* arr ); #define cvZero cvSetZero -/* Splits a multi-channel array into the set of single-channel arrays or +/** Splits a multi-channel array into the set of single-channel arrays or extracts particular [color] plane */ CVAPI(void) cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1, CvArr* dst2, CvArr* dst3 ); -/* Merges a set of single-channel arrays into the single multi-channel array +/** Merges a set of single-channel arrays into the single multi-channel array or inserts one particular [color] plane to the array */ CVAPI(void) cvMerge( const CvArr* src0, const CvArr* src1, const CvArr* src2, const CvArr* src3, CvArr* dst ); -/* Copies several channels from input arrays to +/** Copies several channels from input arrays to certain channels of output arrays */ CVAPI(void) cvMixChannels( const CvArr** src, int src_count, CvArr** dst, int dst_count, const int* from_to, int pair_count ); -/* Performs linear transformation on every source array element: - dst(x,y,c) = scale*src(x,y,c)+shift. - Arbitrary combination of input and output array depths are allowed - (number of channels must be the same), thus the function can be used - for type conversion */ +/** @brief Converts one array to another with optional linear transformation. + +The function has several different purposes, and thus has several different names. It copies one +array to another with optional scaling, which is performed first, and/or optional type conversion, +performed after: + +\f[\texttt{dst} (I) = \texttt{scale} \texttt{src} (I) + ( \texttt{shift} _0, \texttt{shift} _1,...)\f] + +All the channels of multi-channel arrays are processed independently. + +The type of conversion is done with rounding and saturation, that is if the result of scaling + +conversion can not be represented exactly by a value of the destination array element type, it is +set to the nearest representable value on the real axis. +@param src Source array +@param dst Destination array +@param scale Scale factor +@param shift Value added to the scaled source array elements + */ CVAPI(void) cvConvertScale( const CvArr* src, CvArr* dst, double scale CV_DEFAULT(1), double shift CV_DEFAULT(0) ); @@ -471,7 +1023,7 @@ CVAPI(void) cvConvertScale( const CvArr* src, CvArr* dst, #define cvConvert( src, dst ) cvConvertScale( (src), (dst), 1, 0 ) -/* Performs linear transformation on every source array element, +/** Performs linear transformation on every source array element, stores absolute value of the result: dst(x,y,c) = abs(scale*src(x,y,c)+shift). destination array must have 8u type. @@ -482,7 +1034,7 @@ CVAPI(void) cvConvertScaleAbs( const CvArr* src, CvArr* dst, #define cvCvtScaleAbs cvConvertScaleAbs -/* checks termination criteria validity and +/** checks termination criteria validity and sets eps to default_eps (if it is not set), max_iter to default_max_iters (if it is not set) */ @@ -494,19 +1046,19 @@ CVAPI(CvTermCriteria) cvCheckTermCriteria( CvTermCriteria criteria, * Arithmetic, logic and comparison operations * \****************************************************************************************/ -/* dst(mask) = src1(mask) + src2(mask) */ +/** dst(mask) = src1(mask) + src2(mask) */ CVAPI(void) cvAdd( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); -/* dst(mask) = src(mask) + value */ +/** dst(mask) = src(mask) + value */ CVAPI(void) cvAddS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); -/* dst(mask) = src1(mask) - src2(mask) */ +/** dst(mask) = src1(mask) - src2(mask) */ CVAPI(void) cvSub( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); -/* dst(mask) = src(mask) - value = src(mask) + (-value) */ +/** dst(mask) = src(mask) - value = src(mask) + (-value) */ CV_INLINE void cvSubS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)) { @@ -514,66 +1066,77 @@ CV_INLINE void cvSubS( const CvArr* src, CvScalar value, CvArr* dst, dst, mask ); } -/* dst(mask) = value - src(mask) */ +/** dst(mask) = value - src(mask) */ CVAPI(void) cvSubRS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); -/* dst(idx) = src1(idx) * src2(idx) * scale +/** dst(idx) = src1(idx) * src2(idx) * scale (scaled element-wise multiplication of 2 arrays) */ CVAPI(void) cvMul( const CvArr* src1, const CvArr* src2, CvArr* dst, double scale CV_DEFAULT(1) ); -/* element-wise division/inversion with scaling: +/** element-wise division/inversion with scaling: dst(idx) = src1(idx) * scale / src2(idx) or dst(idx) = scale / src2(idx) if src1 == 0 */ CVAPI(void) cvDiv( const CvArr* src1, const CvArr* src2, CvArr* dst, double scale CV_DEFAULT(1)); -/* dst = src1 * scale + src2 */ +/** dst = src1 * scale + src2 */ CVAPI(void) cvScaleAdd( const CvArr* src1, CvScalar scale, const CvArr* src2, CvArr* dst ); #define cvAXPY( A, real_scalar, B, C ) cvScaleAdd(A, cvRealScalar(real_scalar), B, C) -/* dst = src1 * alpha + src2 * beta + gamma */ +/** dst = src1 * alpha + src2 * beta + gamma */ CVAPI(void) cvAddWeighted( const CvArr* src1, double alpha, const CvArr* src2, double beta, double gamma, CvArr* dst ); -/* result = sum_i(src1(i) * src2(i)) (results for all channels are accumulated together) */ +/** @brief Calculates the dot product of two arrays in Euclidean metrics. + +The function calculates and returns the Euclidean dot product of two arrays. + +\f[src1 \bullet src2 = \sum _I ( \texttt{src1} (I) \texttt{src2} (I))\f] + +In the case of multiple channel arrays, the results for all channels are accumulated. In particular, +cvDotProduct(a,a) where a is a complex vector, will return \f$||\texttt{a}||^2\f$. The function can +process multi-dimensional arrays, row by row, layer by layer, and so on. +@param src1 The first source array +@param src2 The second source array + */ CVAPI(double) cvDotProduct( const CvArr* src1, const CvArr* src2 ); -/* dst(idx) = src1(idx) & src2(idx) */ +/** dst(idx) = src1(idx) & src2(idx) */ CVAPI(void) cvAnd( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); -/* dst(idx) = src(idx) & value */ +/** dst(idx) = src(idx) & value */ CVAPI(void) cvAndS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); -/* dst(idx) = src1(idx) | src2(idx) */ +/** dst(idx) = src1(idx) | src2(idx) */ CVAPI(void) cvOr( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); -/* dst(idx) = src(idx) | value */ +/** dst(idx) = src(idx) | value */ CVAPI(void) cvOrS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); -/* dst(idx) = src1(idx) ^ src2(idx) */ +/** dst(idx) = src1(idx) ^ src2(idx) */ CVAPI(void) cvXor( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); -/* dst(idx) = src(idx) ^ value */ +/** dst(idx) = src(idx) ^ value */ CVAPI(void) cvXorS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL)); -/* dst(idx) = ~src(idx) */ +/** dst(idx) = ~src(idx) */ CVAPI(void) cvNot( const CvArr* src, CvArr* dst ); -/* dst(idx) = lower(idx) <= src(idx) < upper(idx) */ +/** dst(idx) = lower(idx) <= src(idx) < upper(idx) */ CVAPI(void) cvInRange( const CvArr* src, const CvArr* lower, const CvArr* upper, CvArr* dst ); -/* dst(idx) = lower <= src(idx) < upper */ +/** dst(idx) = lower <= src(idx) < upper */ CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower, CvScalar upper, CvArr* dst ); @@ -584,31 +1147,31 @@ CVAPI(void) cvInRangeS( const CvArr* src, CvScalar lower, #define CV_CMP_LE 4 #define CV_CMP_NE 5 -/* The comparison operation support single-channel arrays only. +/** The comparison operation support single-channel arrays only. Destination image should be 8uC1 or 8sC1 */ -/* dst(idx) = src1(idx) _cmp_op_ src2(idx) */ +/** dst(idx) = src1(idx) _cmp_op_ src2(idx) */ CVAPI(void) cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op ); -/* dst(idx) = src1(idx) _cmp_op_ value */ +/** dst(idx) = src1(idx) _cmp_op_ value */ CVAPI(void) cvCmpS( const CvArr* src, double value, CvArr* dst, int cmp_op ); -/* dst(idx) = min(src1(idx),src2(idx)) */ +/** dst(idx) = min(src1(idx),src2(idx)) */ CVAPI(void) cvMin( const CvArr* src1, const CvArr* src2, CvArr* dst ); -/* dst(idx) = max(src1(idx),src2(idx)) */ +/** dst(idx) = max(src1(idx),src2(idx)) */ CVAPI(void) cvMax( const CvArr* src1, const CvArr* src2, CvArr* dst ); -/* dst(idx) = min(src(idx),value) */ +/** dst(idx) = min(src(idx),value) */ CVAPI(void) cvMinS( const CvArr* src, double value, CvArr* dst ); -/* dst(idx) = max(src(idx),value) */ +/** dst(idx) = max(src(idx),value) */ CVAPI(void) cvMaxS( const CvArr* src, double value, CvArr* dst ); -/* dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c)) */ +/** dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c)) */ CVAPI(void) cvAbsDiff( const CvArr* src1, const CvArr* src2, CvArr* dst ); -/* dst(x,y,c) = abs(src(x,y,c) - value(c)) */ +/** dst(x,y,c) = abs(src(x,y,c) - value(c)) */ CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value ); #define cvAbs( src, dst ) cvAbsDiffS( (src), (dst), cvScalarAll(0)) @@ -616,51 +1179,68 @@ CVAPI(void) cvAbsDiffS( const CvArr* src, CvArr* dst, CvScalar value ); * Math operations * \****************************************************************************************/ -/* Does cartesian->polar coordinates conversion. +/** Does cartesian->polar coordinates conversion. Either of output components (magnitude or angle) is optional */ CVAPI(void) cvCartToPolar( const CvArr* x, const CvArr* y, CvArr* magnitude, CvArr* angle CV_DEFAULT(NULL), int angle_in_degrees CV_DEFAULT(0)); -/* Does polar->cartesian coordinates conversion. +/** Does polar->cartesian coordinates conversion. Either of output components (magnitude or angle) is optional. If magnitude is missing it is assumed to be all 1's */ CVAPI(void) cvPolarToCart( const CvArr* magnitude, const CvArr* angle, CvArr* x, CvArr* y, int angle_in_degrees CV_DEFAULT(0)); -/* Does powering: dst(idx) = src(idx)^power */ +/** Does powering: dst(idx) = src(idx)^power */ CVAPI(void) cvPow( const CvArr* src, CvArr* dst, double power ); -/* Does exponention: dst(idx) = exp(src(idx)). +/** Does exponention: dst(idx) = exp(src(idx)). Overflow is not handled yet. Underflow is handled. Maximal relative error is ~7e-6 for single-precision input */ CVAPI(void) cvExp( const CvArr* src, CvArr* dst ); -/* Calculates natural logarithms: dst(idx) = log(abs(src(idx))). +/** Calculates natural logarithms: dst(idx) = log(abs(src(idx))). Logarithm of 0 gives large negative number(~-700) Maximal relative error is ~3e-7 for single-precision output */ CVAPI(void) cvLog( const CvArr* src, CvArr* dst ); -/* Fast arctangent calculation */ +/** Fast arctangent calculation */ CVAPI(float) cvFastArctan( float y, float x ); -/* Fast cubic root calculation */ +/** Fast cubic root calculation */ CVAPI(float) cvCbrt( float value ); -/* Checks array values for NaNs, Infs or simply for too large numbers +#define CV_CHECK_RANGE 1 +#define CV_CHECK_QUIET 2 +/** Checks array values for NaNs, Infs or simply for too large numbers (if CV_CHECK_RANGE is set). If CV_CHECK_QUIET is set, no runtime errors is raised (function returns zero value in case of "bad" values). Otherwise cvError is called */ -#define CV_CHECK_RANGE 1 -#define CV_CHECK_QUIET 2 CVAPI(int) cvCheckArr( const CvArr* arr, int flags CV_DEFAULT(0), double min_val CV_DEFAULT(0), double max_val CV_DEFAULT(0)); #define cvCheckArray cvCheckArr #define CV_RAND_UNI 0 #define CV_RAND_NORMAL 1 + +/** @brief Fills an array with random numbers and updates the RNG state. + +The function fills the destination array with uniformly or normally distributed random numbers. +@param rng CvRNG state initialized by cvRNG +@param arr The destination array +@param dist_type Distribution type +> - **CV_RAND_UNI** uniform distribution +> - **CV_RAND_NORMAL** normal or Gaussian distribution +@param param1 The first parameter of the distribution. In the case of a uniform distribution it is +the inclusive lower boundary of the random numbers range. In the case of a normal distribution it +is the mean value of the random numbers. +@param param2 The second parameter of the distribution. In the case of a uniform distribution it +is the exclusive upper boundary of the random numbers range. In the case of a normal distribution +it is the standard deviation of the random numbers. +@sa randu, randn, RNG::fill. + */ CVAPI(void) cvRandArr( CvRNG* rng, CvArr* arr, int dist_type, CvScalar param1, CvScalar param2 ); @@ -676,10 +1256,10 @@ CVAPI(void) cvSort( const CvArr* src, CvArr* dst CV_DEFAULT(NULL), CvArr* idxmat CV_DEFAULT(NULL), int flags CV_DEFAULT(0)); -/* Finds real roots of a cubic equation */ +/** Finds real roots of a cubic equation */ CVAPI(int) cvSolveCubic( const CvMat* coeffs, CvMat* roots ); -/* Finds all real and complex roots of a polynomial equation */ +/** Finds all real and complex roots of a polynomial equation */ CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots2, int maxiter CV_DEFAULT(20), int fig CV_DEFAULT(100)); @@ -687,47 +1267,56 @@ CVAPI(void) cvSolvePoly(const CvMat* coeffs, CvMat *roots2, * Matrix operations * \****************************************************************************************/ -/* Calculates cross product of two 3d vectors */ +/** @brief Calculates the cross product of two 3D vectors. + +The function calculates the cross product of two 3D vectors: +\f[\texttt{dst} = \texttt{src1} \times \texttt{src2}\f] +or: +\f[\begin{array}{l} \texttt{dst} _1 = \texttt{src1} _2 \texttt{src2} _3 - \texttt{src1} _3 \texttt{src2} _2 \\ \texttt{dst} _2 = \texttt{src1} _3 \texttt{src2} _1 - \texttt{src1} _1 \texttt{src2} _3 \\ \texttt{dst} _3 = \texttt{src1} _1 \texttt{src2} _2 - \texttt{src1} _2 \texttt{src2} _1 \end{array}\f] +@param src1 The first source vector +@param src2 The second source vector +@param dst The destination vector + */ CVAPI(void) cvCrossProduct( const CvArr* src1, const CvArr* src2, CvArr* dst ); -/* Matrix transform: dst = A*B + C, C is optional */ +/** Matrix transform: dst = A*B + C, C is optional */ #define cvMatMulAdd( src1, src2, src3, dst ) cvGEMM( (src1), (src2), 1., (src3), 1., (dst), 0 ) #define cvMatMul( src1, src2, dst ) cvMatMulAdd( (src1), (src2), NULL, (dst)) #define CV_GEMM_A_T 1 #define CV_GEMM_B_T 2 #define CV_GEMM_C_T 4 -/* Extended matrix transform: +/** Extended matrix transform: dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T */ CVAPI(void) cvGEMM( const CvArr* src1, const CvArr* src2, double alpha, const CvArr* src3, double beta, CvArr* dst, int tABC CV_DEFAULT(0)); #define cvMatMulAddEx cvGEMM -/* Transforms each element of source array and stores +/** Transforms each element of source array and stores resultant vectors in destination array */ CVAPI(void) cvTransform( const CvArr* src, CvArr* dst, const CvMat* transmat, const CvMat* shiftvec CV_DEFAULT(NULL)); #define cvMatMulAddS cvTransform -/* Does perspective transform on every element of input array */ +/** Does perspective transform on every element of input array */ CVAPI(void) cvPerspectiveTransform( const CvArr* src, CvArr* dst, const CvMat* mat ); -/* Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1) */ +/** Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1) */ CVAPI(void) cvMulTransposed( const CvArr* src, CvArr* dst, int order, const CvArr* delta CV_DEFAULT(NULL), double scale CV_DEFAULT(1.) ); -/* Tranposes matrix. Square matrices can be transposed in-place */ +/** Tranposes matrix. Square matrices can be transposed in-place */ CVAPI(void) cvTranspose( const CvArr* src, CvArr* dst ); #define cvT cvTranspose -/* Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part */ +/** Completes the symmetric matrix from the lower (LtoR=0) or from the upper (LtoR!=0) part */ CVAPI(void) cvCompleteSymm( CvMat* matrix, int LtoR CV_DEFAULT(0) ); -/* Mirror array data around horizontal (flip=0), +/** Mirror array data around horizontal (flip=0), vertical (flip=1) or both(flip=-1) axises: cvFlip(src) flips images vertically and sequences horizontally (inplace) */ CVAPI(void) cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL), @@ -739,11 +1328,11 @@ CVAPI(void) cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL), #define CV_SVD_U_T 2 #define CV_SVD_V_T 4 -/* Performs Singular Value Decomposition of a matrix */ +/** Performs Singular Value Decomposition of a matrix */ CVAPI(void) cvSVD( CvArr* A, CvArr* W, CvArr* U CV_DEFAULT(NULL), CvArr* V CV_DEFAULT(NULL), int flags CV_DEFAULT(0)); -/* Performs Singular Value Back Substitution (solves A*X = B): +/** Performs Singular Value Back Substitution (solves A*X = B): flags must be the same as in cvSVD */ CVAPI(void) cvSVBkSb( const CvArr* W, const CvArr* U, const CvArr* V, const CvArr* B, @@ -756,23 +1345,23 @@ CVAPI(void) cvSVBkSb( const CvArr* W, const CvArr* U, #define CV_QR 4 #define CV_NORMAL 16 -/* Inverts matrix */ +/** Inverts matrix */ CVAPI(double) cvInvert( const CvArr* src, CvArr* dst, int method CV_DEFAULT(CV_LU)); #define cvInv cvInvert -/* Solves linear system (src1)*(dst) = (src2) +/** Solves linear system (src1)*(dst) = (src2) (returns 0 if src1 is a singular and CV_LU method is used) */ CVAPI(int) cvSolve( const CvArr* src1, const CvArr* src2, CvArr* dst, int method CV_DEFAULT(CV_LU)); -/* Calculates determinant of input matrix */ +/** Calculates determinant of input matrix */ CVAPI(double) cvDet( const CvArr* mat ); -/* Calculates trace of the matrix (sum of elements on the main diagonal) */ +/** Calculates trace of the matrix (sum of elements on the main diagonal) */ CVAPI(CvScalar) cvTrace( const CvArr* mat ); -/* Finds eigen values and vectors of a symmetric matrix */ +/** Finds eigen values and vectors of a symmetric matrix */ CVAPI(void) cvEigenVV( CvArr* mat, CvArr* evects, CvArr* evals, double eps CV_DEFAULT(0), int lowindex CV_DEFAULT(-1), @@ -782,32 +1371,42 @@ CVAPI(void) cvEigenVV( CvArr* mat, CvArr* evects, CvArr* evals, //CVAPI(void) cvSelectedEigenVV( CvArr* mat, CvArr* evects, CvArr* evals, // int lowindex, int highindex ); -/* Makes an identity matrix (mat_ij = i == j) */ +/** Makes an identity matrix (mat_ij = i == j) */ CVAPI(void) cvSetIdentity( CvArr* mat, CvScalar value CV_DEFAULT(cvRealScalar(1)) ); -/* Fills matrix with given range of numbers */ +/** Fills matrix with given range of numbers */ CVAPI(CvArr*) cvRange( CvArr* mat, double start, double end ); -/* Calculates covariation matrix for a set of vectors */ -/* transpose([v1-avg, v2-avg,...]) * [v1-avg,v2-avg,...] */ +/** @anchor core_c_CovarFlags +@name Flags for cvCalcCovarMatrix +@see cvCalcCovarMatrix + @{ +*/ + +/** flag for cvCalcCovarMatrix, transpose([v1-avg, v2-avg,...]) * [v1-avg,v2-avg,...] */ #define CV_COVAR_SCRAMBLED 0 -/* [v1-avg, v2-avg,...] * transpose([v1-avg,v2-avg,...]) */ +/** flag for cvCalcCovarMatrix, [v1-avg, v2-avg,...] * transpose([v1-avg,v2-avg,...]) */ #define CV_COVAR_NORMAL 1 -/* do not calc average (i.e. mean vector) - use the input vector instead +/** flag for cvCalcCovarMatrix, do not calc average (i.e. mean vector) - use the input vector instead (useful for calculating covariance matrix by parts) */ #define CV_COVAR_USE_AVG 2 -/* scale the covariance matrix coefficients by number of the vectors */ +/** flag for cvCalcCovarMatrix, scale the covariance matrix coefficients by number of the vectors */ #define CV_COVAR_SCALE 4 -/* all the input vectors are stored in a single matrix, as its rows */ +/** flag for cvCalcCovarMatrix, all the input vectors are stored in a single matrix, as its rows */ #define CV_COVAR_ROWS 8 -/* all the input vectors are stored in a single matrix, as its columns */ +/** flag for cvCalcCovarMatrix, all the input vectors are stored in a single matrix, as its columns */ #define CV_COVAR_COLS 16 +/** @} */ + +/** Calculates covariation matrix for a set of vectors +@see @ref core_c_CovarFlags "flags" +*/ CVAPI(void) cvCalcCovarMatrix( const CvArr** vects, int count, CvArr* cov_mat, CvArr* avg, int flags ); @@ -823,7 +1422,7 @@ CVAPI(void) cvProjectPCA( const CvArr* data, const CvArr* mean, CVAPI(void) cvBackProjectPCA( const CvArr* proj, const CvArr* mean, const CvArr* eigenvects, CvArr* result ); -/* Calculates Mahalanobis(weighted) distance */ +/** Calculates Mahalanobis(weighted) distance */ CVAPI(double) cvMahalanobis( const CvArr* vec1, const CvArr* vec2, const CvArr* mat ); #define cvMahalonobis cvMahalanobis @@ -831,26 +1430,29 @@ CVAPI(double) cvMahalanobis( const CvArr* vec1, const CvArr* vec2, const CvArr* * Array Statistics * \****************************************************************************************/ -/* Finds sum of array elements */ +/** Finds sum of array elements */ CVAPI(CvScalar) cvSum( const CvArr* arr ); -/* Calculates number of non-zero pixels */ +/** Calculates number of non-zero pixels */ CVAPI(int) cvCountNonZero( const CvArr* arr ); -/* Calculates mean value of array elements */ +/** Calculates mean value of array elements */ CVAPI(CvScalar) cvAvg( const CvArr* arr, const CvArr* mask CV_DEFAULT(NULL) ); -/* Calculates mean and standard deviation of pixel values */ +/** Calculates mean and standard deviation of pixel values */ CVAPI(void) cvAvgSdv( const CvArr* arr, CvScalar* mean, CvScalar* std_dev, const CvArr* mask CV_DEFAULT(NULL) ); -/* Finds global minimum, maximum and their positions */ +/** Finds global minimum, maximum and their positions */ CVAPI(void) cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val, CvPoint* min_loc CV_DEFAULT(NULL), CvPoint* max_loc CV_DEFAULT(NULL), const CvArr* mask CV_DEFAULT(NULL) ); -/* types of array norm */ +/** @anchor core_c_NormFlags + @name Flags for cvNorm and cvNormalize + @{ +*/ #define CV_C 1 #define CV_L1 2 #define CV_L2 4 @@ -865,23 +1467,32 @@ CVAPI(void) cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val, #define CV_RELATIVE_C (CV_RELATIVE | CV_C) #define CV_RELATIVE_L1 (CV_RELATIVE | CV_L1) #define CV_RELATIVE_L2 (CV_RELATIVE | CV_L2) +/** @} */ -/* Finds norm, difference norm or relative difference norm for an array (or two arrays) */ +/** Finds norm, difference norm or relative difference norm for an array (or two arrays) +@see ref core_c_NormFlags "flags" +*/ CVAPI(double) cvNorm( const CvArr* arr1, const CvArr* arr2 CV_DEFAULT(NULL), int norm_type CV_DEFAULT(CV_L2), const CvArr* mask CV_DEFAULT(NULL) ); +/** @see ref core_c_NormFlags "flags" */ CVAPI(void) cvNormalize( const CvArr* src, CvArr* dst, double a CV_DEFAULT(1.), double b CV_DEFAULT(0.), int norm_type CV_DEFAULT(CV_L2), const CvArr* mask CV_DEFAULT(NULL) ); - +/** @anchor core_c_ReduceFlags + @name Flags for cvReduce + @{ +*/ #define CV_REDUCE_SUM 0 #define CV_REDUCE_AVG 1 #define CV_REDUCE_MAX 2 #define CV_REDUCE_MIN 3 +/** @} */ +/** @see @ref core_c_ReduceFlags "flags" */ CVAPI(void) cvReduce( const CvArr* src, CvArr* dst, int dim CV_DEFAULT(-1), int op CV_DEFAULT(CV_REDUCE_SUM) ); @@ -889,182 +1500,193 @@ CVAPI(void) cvReduce( const CvArr* src, CvArr* dst, int dim CV_DEFAULT(-1), * Discrete Linear Transforms and Related Functions * \****************************************************************************************/ +/** @anchor core_c_DftFlags + @name Flags for cvDFT, cvDCT and cvMulSpectrums + @{ + */ #define CV_DXT_FORWARD 0 #define CV_DXT_INVERSE 1 -#define CV_DXT_SCALE 2 /* divide result by size of array */ +#define CV_DXT_SCALE 2 /**< divide result by size of array */ #define CV_DXT_INV_SCALE (CV_DXT_INVERSE + CV_DXT_SCALE) #define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE -#define CV_DXT_ROWS 4 /* transform each row individually */ -#define CV_DXT_MUL_CONJ 8 /* conjugate the second argument of cvMulSpectrums */ +#define CV_DXT_ROWS 4 /**< transform each row individually */ +#define CV_DXT_MUL_CONJ 8 /**< conjugate the second argument of cvMulSpectrums */ +/** @} */ -/* Discrete Fourier Transform: +/** Discrete Fourier Transform: complex->complex, real->ccs (forward), - ccs->real (inverse) */ + ccs->real (inverse) +@see core_c_DftFlags "flags" +*/ CVAPI(void) cvDFT( const CvArr* src, CvArr* dst, int flags, int nonzero_rows CV_DEFAULT(0) ); #define cvFFT cvDFT -/* Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y)) */ +/** Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y)) +@see core_c_DftFlags "flags" +*/ CVAPI(void) cvMulSpectrums( const CvArr* src1, const CvArr* src2, CvArr* dst, int flags ); -/* Finds optimal DFT vector size >= size0 */ +/** Finds optimal DFT vector size >= size0 */ CVAPI(int) cvGetOptimalDFTSize( int size0 ); -/* Discrete Cosine Transform */ +/** Discrete Cosine Transform +@see core_c_DftFlags "flags" +*/ CVAPI(void) cvDCT( const CvArr* src, CvArr* dst, int flags ); /****************************************************************************************\ * Dynamic data structures * \****************************************************************************************/ -/* Calculates length of sequence slice (with support of negative indices). */ +/** Calculates length of sequence slice (with support of negative indices). */ CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq ); -/* Creates new memory storage. +/** Creates new memory storage. block_size == 0 means that default, somewhat optimal size, is used (currently, it is 64K) */ CVAPI(CvMemStorage*) cvCreateMemStorage( int block_size CV_DEFAULT(0)); -/* Creates a memory storage that will borrow memory blocks from parent storage */ +/** Creates a memory storage that will borrow memory blocks from parent storage */ CVAPI(CvMemStorage*) cvCreateChildMemStorage( CvMemStorage* parent ); -/* Releases memory storage. All the children of a parent must be released before +/** Releases memory storage. All the children of a parent must be released before the parent. A child storage returns all the blocks to parent when it is released */ CVAPI(void) cvReleaseMemStorage( CvMemStorage** storage ); -/* Clears memory storage. This is the only way(!!!) (besides cvRestoreMemStoragePos) +/** Clears memory storage. This is the only way(!!!) (besides cvRestoreMemStoragePos) to reuse memory allocated for the storage - cvClearSeq,cvClearSet ... do not free any memory. A child storage returns all the blocks to the parent when it is cleared */ CVAPI(void) cvClearMemStorage( CvMemStorage* storage ); -/* Remember a storage "free memory" position */ +/** Remember a storage "free memory" position */ CVAPI(void) cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos ); -/* Restore a storage "free memory" position */ +/** Restore a storage "free memory" position */ CVAPI(void) cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos ); -/* Allocates continuous buffer of the specified size in the storage */ +/** Allocates continuous buffer of the specified size in the storage */ CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size ); -/* Allocates string in memory storage */ +/** Allocates string in memory storage */ CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char* ptr, int len CV_DEFAULT(-1) ); -/* Creates new empty sequence that will reside in the specified storage */ +/** Creates new empty sequence that will reside in the specified storage */ CVAPI(CvSeq*) cvCreateSeq( int seq_flags, size_t header_size, size_t elem_size, CvMemStorage* storage ); -/* Changes default size (granularity) of sequence blocks. +/** Changes default size (granularity) of sequence blocks. The default size is ~1Kbyte */ CVAPI(void) cvSetSeqBlockSize( CvSeq* seq, int delta_elems ); -/* Adds new element to the end of sequence. Returns pointer to the element */ +/** Adds new element to the end of sequence. Returns pointer to the element */ CVAPI(schar*) cvSeqPush( CvSeq* seq, const void* element CV_DEFAULT(NULL)); -/* Adds new element to the beginning of sequence. Returns pointer to it */ +/** Adds new element to the beginning of sequence. Returns pointer to it */ CVAPI(schar*) cvSeqPushFront( CvSeq* seq, const void* element CV_DEFAULT(NULL)); -/* Removes the last element from sequence and optionally saves it */ +/** Removes the last element from sequence and optionally saves it */ CVAPI(void) cvSeqPop( CvSeq* seq, void* element CV_DEFAULT(NULL)); -/* Removes the first element from sequence and optioanally saves it */ +/** Removes the first element from sequence and optioanally saves it */ CVAPI(void) cvSeqPopFront( CvSeq* seq, void* element CV_DEFAULT(NULL)); #define CV_FRONT 1 #define CV_BACK 0 -/* Adds several new elements to the end of sequence */ +/** Adds several new elements to the end of sequence */ CVAPI(void) cvSeqPushMulti( CvSeq* seq, const void* elements, int count, int in_front CV_DEFAULT(0) ); -/* Removes several elements from the end of sequence and optionally saves them */ +/** Removes several elements from the end of sequence and optionally saves them */ CVAPI(void) cvSeqPopMulti( CvSeq* seq, void* elements, int count, int in_front CV_DEFAULT(0) ); -/* Inserts a new element in the middle of sequence. +/** Inserts a new element in the middle of sequence. cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem) */ CVAPI(schar*) cvSeqInsert( CvSeq* seq, int before_index, const void* element CV_DEFAULT(NULL)); -/* Removes specified sequence element */ +/** Removes specified sequence element */ CVAPI(void) cvSeqRemove( CvSeq* seq, int index ); -/* Removes all the elements from the sequence. The freed memory +/** Removes all the elements from the sequence. The freed memory can be reused later only by the same sequence unless cvClearMemStorage or cvRestoreMemStoragePos is called */ CVAPI(void) cvClearSeq( CvSeq* seq ); -/* Retrieves pointer to specified sequence element. +/** Retrieves pointer to specified sequence element. Negative indices are supported and mean counting from the end (e.g -1 means the last sequence element) */ CVAPI(schar*) cvGetSeqElem( const CvSeq* seq, int index ); -/* Calculates index of the specified sequence element. +/** Calculates index of the specified sequence element. Returns -1 if element does not belong to the sequence */ CVAPI(int) cvSeqElemIdx( const CvSeq* seq, const void* element, CvSeqBlock** block CV_DEFAULT(NULL) ); -/* Initializes sequence writer. The new elements will be added to the end of sequence */ +/** Initializes sequence writer. The new elements will be added to the end of sequence */ CVAPI(void) cvStartAppendToSeq( CvSeq* seq, CvSeqWriter* writer ); -/* Combination of cvCreateSeq and cvStartAppendToSeq */ +/** Combination of cvCreateSeq and cvStartAppendToSeq */ CVAPI(void) cvStartWriteSeq( int seq_flags, int header_size, int elem_size, CvMemStorage* storage, CvSeqWriter* writer ); -/* Closes sequence writer, updates sequence header and returns pointer +/** Closes sequence writer, updates sequence header and returns pointer to the resultant sequence (which may be useful if the sequence was created using cvStartWriteSeq)) */ CVAPI(CvSeq*) cvEndWriteSeq( CvSeqWriter* writer ); -/* Updates sequence header. May be useful to get access to some of previously +/** Updates sequence header. May be useful to get access to some of previously written elements via cvGetSeqElem or sequence reader */ CVAPI(void) cvFlushSeqWriter( CvSeqWriter* writer ); -/* Initializes sequence reader. +/** Initializes sequence reader. The sequence can be read in forward or backward direction */ CVAPI(void) cvStartReadSeq( const CvSeq* seq, CvSeqReader* reader, int reverse CV_DEFAULT(0) ); -/* Returns current sequence reader position (currently observed sequence element) */ +/** Returns current sequence reader position (currently observed sequence element) */ CVAPI(int) cvGetSeqReaderPos( CvSeqReader* reader ); -/* Changes sequence reader position. It may seek to an absolute or +/** Changes sequence reader position. It may seek to an absolute or to relative to the current position */ CVAPI(void) cvSetSeqReaderPos( CvSeqReader* reader, int index, int is_relative CV_DEFAULT(0)); -/* Copies sequence content to a continuous piece of memory */ +/** Copies sequence content to a continuous piece of memory */ CVAPI(void*) cvCvtSeqToArray( const CvSeq* seq, void* elements, CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) ); -/* Creates sequence header for array. +/** Creates sequence header for array. After that all the operations on sequences that do not alter the content can be applied to the resultant sequence */ CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size, int elem_size, void* elements, int total, CvSeq* seq, CvSeqBlock* block ); -/* Extracts sequence slice (with or without copying sequence elements) */ +/** Extracts sequence slice (with or without copying sequence elements) */ CVAPI(CvSeq*) cvSeqSlice( const CvSeq* seq, CvSlice slice, CvMemStorage* storage CV_DEFAULT(NULL), int copy_data CV_DEFAULT(0)); @@ -1074,27 +1696,27 @@ CV_INLINE CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage CV_DEFAULT( return cvSeqSlice( seq, CV_WHOLE_SEQ, storage, 1 ); } -/* Removes sequence slice */ +/** Removes sequence slice */ CVAPI(void) cvSeqRemoveSlice( CvSeq* seq, CvSlice slice ); -/* Inserts a sequence or array into another sequence */ +/** Inserts a sequence or array into another sequence */ CVAPI(void) cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr ); -/* a < b ? -1 : a > b ? 1 : 0 */ +/** a < b ? -1 : a > b ? 1 : 0 */ typedef int (CV_CDECL* CvCmpFunc)(const void* a, const void* b, void* userdata ); -/* Sorts sequence in-place given element comparison function */ +/** Sorts sequence in-place given element comparison function */ CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) ); -/* Finds element in a [sorted] sequence */ +/** Finds element in a [sorted] sequence */ CVAPI(schar*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func, int is_sorted, int* elem_idx, void* userdata CV_DEFAULT(NULL) ); -/* Reverses order of sequence elements in-place */ +/** Reverses order of sequence elements in-place */ CVAPI(void) cvSeqInvert( CvSeq* seq ); -/* Splits sequence into one or more equivalence classes using the specified criteria */ +/** Splits sequence into one or more equivalence classes using the specified criteria */ CVAPI(int) cvSeqPartition( const CvSeq* seq, CvMemStorage* storage, CvSeq** labels, CvCmpFunc is_equal, void* userdata ); @@ -1103,15 +1725,15 @@ CVAPI(void) cvChangeSeqBlock( void* reader, int direction ); CVAPI(void) cvCreateSeqBlock( CvSeqWriter* writer ); -/* Creates a new set */ +/** Creates a new set */ CVAPI(CvSet*) cvCreateSet( int set_flags, int header_size, int elem_size, CvMemStorage* storage ); -/* Adds new element to the set and returns pointer to it */ +/** Adds new element to the set and returns pointer to it */ CVAPI(int) cvSetAdd( CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL), CvSetElem** inserted_elem CV_DEFAULT(NULL) ); -/* Fast variant of cvSetAdd */ +/** Fast variant of cvSetAdd */ CV_INLINE CvSetElem* cvSetNew( CvSet* set_header ) { CvSetElem* elem = set_header->free_elems; @@ -1126,7 +1748,7 @@ CV_INLINE CvSetElem* cvSetNew( CvSet* set_header ) return elem; } -/* Removes set element given its pointer */ +/** Removes set element given its pointer */ CV_INLINE void cvSetRemoveByPtr( CvSet* set_header, void* elem ) { CvSetElem* _elem = (CvSetElem*)elem; @@ -1137,10 +1759,10 @@ CV_INLINE void cvSetRemoveByPtr( CvSet* set_header, void* elem ) set_header->active_count--; } -/* Removes element from the set by its index */ +/** Removes element from the set by its index */ CVAPI(void) cvSetRemove( CvSet* set_header, int index ); -/* Returns a set element by index. If the element doesn't belong to the set, +/** Returns a set element by index. If the element doesn't belong to the set, NULL is returned */ CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int idx ) { @@ -1148,25 +1770,25 @@ CV_INLINE CvSetElem* cvGetSetElem( const CvSet* set_header, int idx ) return elem && CV_IS_SET_ELEM( elem ) ? elem : 0; } -/* Removes all the elements from the set */ +/** Removes all the elements from the set */ CVAPI(void) cvClearSet( CvSet* set_header ); -/* Creates new graph */ +/** Creates new graph */ CVAPI(CvGraph*) cvCreateGraph( int graph_flags, int header_size, int vtx_size, int edge_size, CvMemStorage* storage ); -/* Adds new vertex to the graph */ +/** Adds new vertex to the graph */ CVAPI(int) cvGraphAddVtx( CvGraph* graph, const CvGraphVtx* vtx CV_DEFAULT(NULL), CvGraphVtx** inserted_vtx CV_DEFAULT(NULL) ); -/* Removes vertex from the graph together with all incident edges */ +/** Removes vertex from the graph together with all incident edges */ CVAPI(int) cvGraphRemoveVtx( CvGraph* graph, int index ); CVAPI(int) cvGraphRemoveVtxByPtr( CvGraph* graph, CvGraphVtx* vtx ); -/* Link two vertices specifed by indices or pointers if they +/** Link two vertices specifed by indices or pointers if they are not connected or return pointer to already existing edge connecting the vertices. Functions return 1 if a new edge was created, 0 otherwise */ @@ -1180,12 +1802,12 @@ CVAPI(int) cvGraphAddEdgeByPtr( CvGraph* graph, const CvGraphEdge* edge CV_DEFAULT(NULL), CvGraphEdge** inserted_edge CV_DEFAULT(NULL) ); -/* Remove edge connecting two vertices */ +/** Remove edge connecting two vertices */ CVAPI(void) cvGraphRemoveEdge( CvGraph* graph, int start_idx, int end_idx ); CVAPI(void) cvGraphRemoveEdgeByPtr( CvGraph* graph, CvGraphVtx* start_vtx, CvGraphVtx* end_vtx ); -/* Find edge connecting two vertices */ +/** Find edge connecting two vertices */ CVAPI(CvGraphEdge*) cvFindGraphEdge( const CvGraph* graph, int start_idx, int end_idx ); CVAPI(CvGraphEdge*) cvFindGraphEdgeByPtr( const CvGraph* graph, const CvGraphVtx* start_vtx, @@ -1193,22 +1815,22 @@ CVAPI(CvGraphEdge*) cvFindGraphEdgeByPtr( const CvGraph* graph, #define cvGraphFindEdge cvFindGraphEdge #define cvGraphFindEdgeByPtr cvFindGraphEdgeByPtr -/* Remove all vertices and edges from the graph */ +/** Remove all vertices and edges from the graph */ CVAPI(void) cvClearGraph( CvGraph* graph ); -/* Count number of edges incident to the vertex */ +/** Count number of edges incident to the vertex */ CVAPI(int) cvGraphVtxDegree( const CvGraph* graph, int vtx_idx ); CVAPI(int) cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx ); -/* Retrieves graph vertex by given index */ +/** Retrieves graph vertex by given index */ #define cvGetGraphVtx( graph, idx ) (CvGraphVtx*)cvGetSetElem((CvSet*)(graph), (idx)) -/* Retrieves index of a graph vertex given its pointer */ +/** Retrieves index of a graph vertex given its pointer */ #define cvGraphVtxIdx( graph, vtx ) ((vtx)->flags & CV_SET_ELEM_IDX_MASK) -/* Retrieves index of a graph edge given its pointer */ +/** Retrieves index of a graph edge given its pointer */ #define cvGraphEdgeIdx( graph, edge ) ((edge)->flags & CV_SET_ELEM_IDX_MASK) #define cvGraphGetVtxCount( graph ) ((graph)->active_count) @@ -1226,7 +1848,7 @@ CVAPI(int) cvGraphVtxDegreeByPtr( const CvGraph* graph, const CvGraphVtx* vtx ) #define CV_GRAPH_ALL_ITEMS -1 -/* flags for graph vertices and edges */ +/** flags for graph vertices and edges */ #define CV_GRAPH_ITEM_VISITED_FLAG (1 << 30) #define CV_IS_GRAPH_VERTEX_VISITED(vtx) \ (((CvGraphVtx*)(vtx))->flags & CV_GRAPH_ITEM_VISITED_FLAG) @@ -1248,22 +1870,22 @@ typedef struct CvGraphScanner } CvGraphScanner; -/* Creates new graph scanner. */ +/** Creates new graph scanner. */ CVAPI(CvGraphScanner*) cvCreateGraphScanner( CvGraph* graph, CvGraphVtx* vtx CV_DEFAULT(NULL), int mask CV_DEFAULT(CV_GRAPH_ALL_ITEMS)); -/* Releases graph scanner. */ +/** Releases graph scanner. */ CVAPI(void) cvReleaseGraphScanner( CvGraphScanner** scanner ); -/* Get next graph element */ +/** Get next graph element */ CVAPI(int) cvNextGraphItem( CvGraphScanner* scanner ); -/* Creates a copy of graph */ +/** Creates a copy of graph */ CVAPI(CvGraph*) cvCloneGraph( const CvGraph* graph, CvMemStorage* storage ); -/* Does look-up transformation. Elements of the source array +/** Does look-up transformation. Elements of the source array (that should be 8uC1 or 8sC1) are used as indexes in lutarr 256-element table */ CVAPI(void) cvLUT( const CvArr* src, CvArr* dst, const CvArr* lut ); @@ -1282,20 +1904,20 @@ CVAPI(void) cvInitTreeNodeIterator( CvTreeNodeIterator* tree_iterator, CVAPI(void*) cvNextTreeNode( CvTreeNodeIterator* tree_iterator ); CVAPI(void*) cvPrevTreeNode( CvTreeNodeIterator* tree_iterator ); -/* Inserts sequence into tree with specified "parent" sequence. +/** Inserts sequence into tree with specified "parent" sequence. If parent is equal to frame (e.g. the most external contour), then added contour will have null pointer to parent. */ CVAPI(void) cvInsertNodeIntoTree( void* node, void* parent, void* frame ); -/* Removes contour from tree (together with the contour children). */ +/** Removes contour from tree (together with the contour children). */ CVAPI(void) cvRemoveNodeFromTree( void* node, void* frame ); -/* Gathers pointers to all the sequences, - accessible from the , to the single sequence */ +/** Gathers pointers to all the sequences, + accessible from the `first`, to the single sequence */ CVAPI(CvSeq*) cvTreeToNodeSeq( const void* first, int header_size, CvMemStorage* storage ); -/* The function implements the K-means algorithm for clustering an array of sample +/** The function implements the K-means algorithm for clustering an array of sample vectors in a specified number of classes */ #define CV_KMEANS_USE_INITIAL_LABELS 1 CVAPI(int) cvKMeans2( const CvArr* samples, int cluster_count, CvArr* labels, @@ -1307,7 +1929,7 @@ CVAPI(int) cvKMeans2( const CvArr* samples, int cluster_count, CvArr* labels, * System functions * \****************************************************************************************/ -/* Loads optimized functions from IPP, MKL etc. or switches back to pure C code */ +/** Loads optimized functions from IPP, MKL etc. or switches back to pure C code */ CVAPI(int) cvUseOptimized( int on_off ); typedef IplImage* (CV_STDCALL* Cv_iplCreateImageHeader) @@ -1318,7 +1940,22 @@ typedef void (CV_STDCALL* Cv_iplDeallocate)(IplImage*,int); typedef IplROI* (CV_STDCALL* Cv_iplCreateROI)(int,int,int,int,int); typedef IplImage* (CV_STDCALL* Cv_iplCloneImage)(const IplImage*); -/* Makes OpenCV use IPL functions for IplImage allocation/deallocation */ +/** @brief Makes OpenCV use IPL functions for allocating IplImage and IplROI structures. + +Normally, the function is not called directly. Instead, a simple macro +CV_TURN_ON_IPL_COMPATIBILITY() is used that calls cvSetIPLAllocators and passes there pointers +to IPL allocation functions. : +@code + ... + CV_TURN_ON_IPL_COMPATIBILITY() + ... +@endcode +@param create_header pointer to a function, creating IPL image header. +@param allocate_data pointer to a function, allocating IPL image data. +@param deallocate pointer to a function, deallocating IPL image. +@param create_roi pointer to a function, creating IPL image ROI (i.e. Region of Interest). +@param clone_image pointer to a function, cloning an IPL image. + */ CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header, Cv_iplAllocateImageData allocate_data, Cv_iplDeallocate deallocate, @@ -1335,72 +1972,347 @@ CVAPI(void) cvSetIPLAllocators( Cv_iplCreateImageHeader create_header, /********************************** High-level functions ********************************/ -/* opens existing or creates new file storage */ +/** @brief Opens file storage for reading or writing data. + +The function opens file storage for reading or writing data. In the latter case, a new file is +created or an existing file is rewritten. The type of the read or written file is determined by the +filename extension: .xml for XML and .yml or .yaml for YAML. The function returns a pointer to the +CvFileStorage structure. If the file cannot be opened then the function returns NULL. +@param filename Name of the file associated with the storage +@param memstorage Memory storage used for temporary data and for +: storing dynamic structures, such as CvSeq or CvGraph . If it is NULL, a temporary memory + storage is created and used. +@param flags Can be one of the following: +> - **CV_STORAGE_READ** the storage is open for reading +> - **CV_STORAGE_WRITE** the storage is open for writing +@param encoding + */ CVAPI(CvFileStorage*) cvOpenFileStorage( const char* filename, CvMemStorage* memstorage, int flags, const char* encoding CV_DEFAULT(NULL) ); -/* closes file storage and deallocates buffers */ +/** @brief Releases file storage. + +The function closes the file associated with the storage and releases all the temporary structures. +It must be called after all I/O operations with the storage are finished. +@param fs Double pointer to the released file storage + */ CVAPI(void) cvReleaseFileStorage( CvFileStorage** fs ); -/* returns attribute value or 0 (NULL) if there is no such attribute */ +/** returns attribute value or 0 (NULL) if there is no such attribute */ CVAPI(const char*) cvAttrValue( const CvAttrList* attr, const char* attr_name ); -/* starts writing compound structure (map or sequence) */ +/** @brief Starts writing a new structure. + +The function starts writing a compound structure (collection) that can be a sequence or a map. After +all the structure fields, which can be scalars or structures, are written, cvEndWriteStruct should +be called. The function can be used to group some objects or to implement the write function for a +some user object (see CvTypeInfo). +@param fs File storage +@param name Name of the written structure. The structure can be accessed by this name when the +storage is read. +@param struct_flags A combination one of the following values: +- **CV_NODE_SEQ** the written structure is a sequence (see discussion of CvFileStorage ), + that is, its elements do not have a name. +- **CV_NODE_MAP** the written structure is a map (see discussion of CvFileStorage ), that + is, all its elements have names. +One and only one of the two above flags must be specified +- **CV_NODE_FLOW** the optional flag that makes sense only for YAML streams. It means that + the structure is written as a flow (not as a block), which is more compact. It is + recommended to use this flag for structures or arrays whose elements are all scalars. +@param type_name Optional parameter - the object type name. In + case of XML it is written as a type_id attribute of the structure opening tag. In the case of + YAML it is written after a colon following the structure name (see the example in + CvFileStorage description). Mainly it is used with user objects. When the storage is read, the + encoded type name is used to determine the object type (see CvTypeInfo and cvFindType ). +@param attributes This parameter is not used in the current implementation + */ CVAPI(void) cvStartWriteStruct( CvFileStorage* fs, const char* name, int struct_flags, const char* type_name CV_DEFAULT(NULL), CvAttrList attributes CV_DEFAULT(cvAttrList())); -/* finishes writing compound structure */ +/** @brief Finishes writing to a file node collection. +@param fs File storage +@sa cvStartWriteStruct. + */ CVAPI(void) cvEndWriteStruct( CvFileStorage* fs ); -/* writes an integer */ +/** @brief Writes an integer value. + +The function writes a single integer value (with or without a name) to the file storage. +@param fs File storage +@param name Name of the written value. Should be NULL if and only if the parent structure is a +sequence. +@param value The written value + */ CVAPI(void) cvWriteInt( CvFileStorage* fs, const char* name, int value ); -/* writes a floating-point number */ +/** @brief Writes a floating-point value. + +The function writes a single floating-point value (with or without a name) to file storage. Special +values are encoded as follows: NaN (Not A Number) as .NaN, infinity as +.Inf or -.Inf. + +The following example shows how to use the low-level writing functions to store custom structures, +such as termination criteria, without registering a new type. : +@code + void write_termcriteria( CvFileStorage* fs, const char* struct_name, + CvTermCriteria* termcrit ) + { + cvStartWriteStruct( fs, struct_name, CV_NODE_MAP, NULL, cvAttrList(0,0)); + cvWriteComment( fs, "termination criteria", 1 ); // just a description + if( termcrit->type & CV_TERMCRIT_ITER ) + cvWriteInteger( fs, "max_iterations", termcrit->max_iter ); + if( termcrit->type & CV_TERMCRIT_EPS ) + cvWriteReal( fs, "accuracy", termcrit->epsilon ); + cvEndWriteStruct( fs ); + } +@endcode +@param fs File storage +@param name Name of the written value. Should be NULL if and only if the parent structure is a +sequence. +@param value The written value +*/ CVAPI(void) cvWriteReal( CvFileStorage* fs, const char* name, double value ); -/* writes a string */ +/** @brief Writes a text string. + +The function writes a text string to file storage. +@param fs File storage +@param name Name of the written string . Should be NULL if and only if the parent structure is a +sequence. +@param str The written text string +@param quote If non-zero, the written string is put in quotes, regardless of whether they are +required. Otherwise, if the flag is zero, quotes are used only when they are required (e.g. when +the string starts with a digit or contains spaces). + */ CVAPI(void) cvWriteString( CvFileStorage* fs, const char* name, const char* str, int quote CV_DEFAULT(0) ); -/* writes a comment */ +/** @brief Writes a comment. + +The function writes a comment into file storage. The comments are skipped when the storage is read. +@param fs File storage +@param comment The written comment, single-line or multi-line +@param eol_comment If non-zero, the function tries to put the comment at the end of current line. +If the flag is zero, if the comment is multi-line, or if it does not fit at the end of the current +line, the comment starts a new line. + */ CVAPI(void) cvWriteComment( CvFileStorage* fs, const char* comment, int eol_comment ); -/* writes instance of a standard type (matrix, image, sequence, graph etc.) - or user-defined type */ +/** @brief Writes an object to file storage. + +The function writes an object to file storage. First, the appropriate type info is found using +cvTypeOf. Then, the write method associated with the type info is called. + +Attributes are used to customize the writing procedure. The standard types support the following +attributes (all the dt attributes have the same format as in cvWriteRawData): + +-# CvSeq + - **header_dt** description of user fields of the sequence header that follow CvSeq, or + CvChain (if the sequence is a Freeman chain) or CvContour (if the sequence is a contour or + point sequence) + - **dt** description of the sequence elements. + - **recursive** if the attribute is present and is not equal to "0" or "false", the whole + tree of sequences (contours) is stored. +-# CvGraph + - **header_dt** description of user fields of the graph header that follows CvGraph; + - **vertex_dt** description of user fields of graph vertices + - **edge_dt** description of user fields of graph edges (note that the edge weight is + always written, so there is no need to specify it explicitly) + +Below is the code that creates the YAML file shown in the CvFileStorage description: +@code + #include "cxcore.h" + + int main( int argc, char** argv ) + { + CvMat* mat = cvCreateMat( 3, 3, CV_32F ); + CvFileStorage* fs = cvOpenFileStorage( "example.yml", 0, CV_STORAGE_WRITE ); + + cvSetIdentity( mat ); + cvWrite( fs, "A", mat, cvAttrList(0,0) ); + + cvReleaseFileStorage( &fs ); + cvReleaseMat( &mat ); + return 0; + } +@endcode +@param fs File storage +@param name Name of the written object. Should be NULL if and only if the parent structure is a +sequence. +@param ptr Pointer to the object +@param attributes The attributes of the object. They are specific for each particular type (see +the discussion below). + */ CVAPI(void) cvWrite( CvFileStorage* fs, const char* name, const void* ptr, CvAttrList attributes CV_DEFAULT(cvAttrList())); -/* starts the next stream */ +/** @brief Starts the next stream. + +The function finishes the currently written stream and starts the next stream. In the case of XML +the file with multiple streams looks like this: +@code{.xml} + + + + + + + ... +@endcode +The YAML file will look like this: +@code{.yaml} + %YAML:1.0 + # stream #1 data + ... + --- + # stream #2 data +@endcode +This is useful for concatenating files or for resuming the writing process. +@param fs File storage + */ CVAPI(void) cvStartNextStream( CvFileStorage* fs ); -/* helper function: writes multiple integer or floating-point numbers */ +/** @brief Writes multiple numbers. + +The function writes an array, whose elements consist of single or multiple numbers. The function +call can be replaced with a loop containing a few cvWriteInt and cvWriteReal calls, but a single +call is more efficient. Note that because none of the elements have a name, they should be written +to a sequence rather than a map. +@param fs File storage +@param src Pointer to the written array +@param len Number of the array elements to write +@param dt Specification of each array element, see @ref format_spec "format specification" + */ CVAPI(void) cvWriteRawData( CvFileStorage* fs, const void* src, int len, const char* dt ); -/* returns the hash entry corresponding to the specified literal key string or 0 - if there is no such a key in the storage */ +/** @brief Returns a unique pointer for a given name. + +The function returns a unique pointer for each particular file node name. This pointer can be then +passed to the cvGetFileNode function that is faster than cvGetFileNodeByName because it compares +text strings by comparing pointers rather than the strings' content. + +Consider the following example where an array of points is encoded as a sequence of 2-entry maps: +@code + points: + - { x: 10, y: 10 } + - { x: 20, y: 20 } + - { x: 30, y: 30 } + # ... +@endcode +Then, it is possible to get hashed "x" and "y" pointers to speed up decoding of the points. : +@code + #include "cxcore.h" + + int main( int argc, char** argv ) + { + CvFileStorage* fs = cvOpenFileStorage( "points.yml", 0, CV_STORAGE_READ ); + CvStringHashNode* x_key = cvGetHashedNode( fs, "x", -1, 1 ); + CvStringHashNode* y_key = cvGetHashedNode( fs, "y", -1, 1 ); + CvFileNode* points = cvGetFileNodeByName( fs, 0, "points" ); + + if( CV_NODE_IS_SEQ(points->tag) ) + { + CvSeq* seq = points->data.seq; + int i, total = seq->total; + CvSeqReader reader; + cvStartReadSeq( seq, &reader, 0 ); + for( i = 0; i < total; i++ ) + { + CvFileNode* pt = (CvFileNode*)reader.ptr; + #if 1 // faster variant + CvFileNode* xnode = cvGetFileNode( fs, pt, x_key, 0 ); + CvFileNode* ynode = cvGetFileNode( fs, pt, y_key, 0 ); + assert( xnode && CV_NODE_IS_INT(xnode->tag) && + ynode && CV_NODE_IS_INT(ynode->tag)); + int x = xnode->data.i; // or x = cvReadInt( xnode, 0 ); + int y = ynode->data.i; // or y = cvReadInt( ynode, 0 ); + #elif 1 // slower variant; does not use x_key & y_key + CvFileNode* xnode = cvGetFileNodeByName( fs, pt, "x" ); + CvFileNode* ynode = cvGetFileNodeByName( fs, pt, "y" ); + assert( xnode && CV_NODE_IS_INT(xnode->tag) && + ynode && CV_NODE_IS_INT(ynode->tag)); + int x = xnode->data.i; // or x = cvReadInt( xnode, 0 ); + int y = ynode->data.i; // or y = cvReadInt( ynode, 0 ); + #else // the slowest yet the easiest to use variant + int x = cvReadIntByName( fs, pt, "x", 0 ); + int y = cvReadIntByName( fs, pt, "y", 0 ); + #endif + CV_NEXT_SEQ_ELEM( seq->elem_size, reader ); + printf(" + } + } + cvReleaseFileStorage( &fs ); + return 0; + } +@endcode +Please note that whatever method of accessing a map you are using, it is still much slower than +using plain sequences; for example, in the above example, it is more efficient to encode the points +as pairs of integers in a single numeric sequence. +@param fs File storage +@param name Literal node name +@param len Length of the name (if it is known apriori), or -1 if it needs to be calculated +@param create_missing Flag that specifies, whether an absent key should be added into the hash table +*/ CVAPI(CvStringHashNode*) cvGetHashedKey( CvFileStorage* fs, const char* name, int len CV_DEFAULT(-1), int create_missing CV_DEFAULT(0)); -/* returns file node with the specified key within the specified map - (collection of named nodes) */ +/** @brief Retrieves one of the top-level nodes of the file storage. + +The function returns one of the top-level file nodes. The top-level nodes do not have a name, they +correspond to the streams that are stored one after another in the file storage. If the index is out +of range, the function returns a NULL pointer, so all the top-level nodes can be iterated by +subsequent calls to the function with stream_index=0,1,..., until the NULL pointer is returned. +This function can be used as a base for recursive traversal of the file storage. +@param fs File storage +@param stream_index Zero-based index of the stream. See cvStartNextStream . In most cases, +there is only one stream in the file; however, there can be several. + */ CVAPI(CvFileNode*) cvGetRootFileNode( const CvFileStorage* fs, int stream_index CV_DEFAULT(0) ); -/* returns file node with the specified key within the specified map - (collection of named nodes) */ +/** @brief Finds a node in a map or file storage. + +The function finds a file node. It is a faster version of cvGetFileNodeByName (see +cvGetHashedKey discussion). Also, the function can insert a new node, if it is not in the map yet. +@param fs File storage +@param map The parent map. If it is NULL, the function searches a top-level node. If both map and +key are NULLs, the function returns the root file node - a map that contains top-level nodes. +@param key Unique pointer to the node name, retrieved with cvGetHashedKey +@param create_missing Flag that specifies whether an absent node should be added to the map + */ CVAPI(CvFileNode*) cvGetFileNode( CvFileStorage* fs, CvFileNode* map, const CvStringHashNode* key, int create_missing CV_DEFAULT(0) ); -/* this is a slower version of cvGetFileNode that takes the key as a literal string */ +/** @brief Finds a node in a map or file storage. + +The function finds a file node by name. The node is searched either in map or, if the pointer is +NULL, among the top-level file storage nodes. Using this function for maps and cvGetSeqElem (or +sequence reader) for sequences, it is possible to navigate through the file storage. To speed up +multiple queries for a certain key (e.g., in the case of an array of structures) one may use a +combination of cvGetHashedKey and cvGetFileNode. +@param fs File storage +@param map The parent map. If it is NULL, the function searches in all the top-level nodes +(streams), starting with the first one. +@param name The file node name + */ CVAPI(CvFileNode*) cvGetFileNodeByName( const CvFileStorage* fs, const CvFileNode* map, const char* name ); +/** @brief Retrieves an integer value from a file node. + +The function returns an integer that is represented by the file node. If the file node is NULL, the +default_value is returned (thus, it is convenient to call the function right after cvGetFileNode +without checking for a NULL pointer). If the file node has type CV_NODE_INT, then node-\>data.i is +returned. If the file node has type CV_NODE_REAL, then node-\>data.f is converted to an integer +and returned. Otherwise the error is reported. +@param node File node +@param default_value The value that is returned if node is NULL + */ CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) ) { return !node ? default_value : @@ -1408,14 +2320,30 @@ CV_INLINE int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) CV_NODE_IS_REAL(node->tag) ? cvRound(node->data.f) : 0x7fffffff; } +/** @brief Finds a file node and returns its value. +The function is a simple superposition of cvGetFileNodeByName and cvReadInt. +@param fs File storage +@param map The parent map. If it is NULL, the function searches a top-level node. +@param name The node name +@param default_value The value that is returned if the file node is not found + */ CV_INLINE int cvReadIntByName( const CvFileStorage* fs, const CvFileNode* map, const char* name, int default_value CV_DEFAULT(0) ) { return cvReadInt( cvGetFileNodeByName( fs, map, name ), default_value ); } +/** @brief Retrieves a floating-point value from a file node. +The function returns a floating-point value that is represented by the file node. If the file node +is NULL, the default_value is returned (thus, it is convenient to call the function right after +cvGetFileNode without checking for a NULL pointer). If the file node has type CV_NODE_REAL , +then node-\>data.f is returned. If the file node has type CV_NODE_INT , then node-:math:\>data.f +is converted to floating-point and returned. Otherwise the result is not determined. +@param node File node +@param default_value The value that is returned if node is NULL + */ CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEFAULT(0.) ) { return !node ? default_value : @@ -1423,21 +2351,43 @@ CV_INLINE double cvReadReal( const CvFileNode* node, double default_value CV_DEF CV_NODE_IS_REAL(node->tag) ? node->data.f : 1e300; } +/** @brief Finds a file node and returns its value. +The function is a simple superposition of cvGetFileNodeByName and cvReadReal . +@param fs File storage +@param map The parent map. If it is NULL, the function searches a top-level node. +@param name The node name +@param default_value The value that is returned if the file node is not found + */ CV_INLINE double cvReadRealByName( const CvFileStorage* fs, const CvFileNode* map, const char* name, double default_value CV_DEFAULT(0.) ) { return cvReadReal( cvGetFileNodeByName( fs, map, name ), default_value ); } +/** @brief Retrieves a text string from a file node. +The function returns a text string that is represented by the file node. If the file node is NULL, +the default_value is returned (thus, it is convenient to call the function right after +cvGetFileNode without checking for a NULL pointer). If the file node has type CV_NODE_STR , then +node-:math:\>data.str.ptr is returned. Otherwise the result is not determined. +@param node File node +@param default_value The value that is returned if node is NULL + */ CV_INLINE const char* cvReadString( const CvFileNode* node, const char* default_value CV_DEFAULT(NULL) ) { return !node ? default_value : CV_NODE_IS_STRING(node->tag) ? node->data.str.ptr : 0; } +/** @brief Finds a file node by its name and returns its value. +The function is a simple superposition of cvGetFileNodeByName and cvReadString . +@param fs File storage +@param map The parent map. If it is NULL, the function searches a top-level node. +@param name The node name +@param default_value The value that is returned if the file node is not found + */ CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileNode* map, const char* name, const char* default_value CV_DEFAULT(NULL) ) { @@ -1445,11 +2395,31 @@ CV_INLINE const char* cvReadStringByName( const CvFileStorage* fs, const CvFileN } -/* decodes standard or user-defined object and returns it */ +/** @brief Decodes an object and returns a pointer to it. + +The function decodes a user object (creates an object in a native representation from the file +storage subtree) and returns it. The object to be decoded must be an instance of a registered type +that supports the read method (see CvTypeInfo). The type of the object is determined by the type +name that is encoded in the file. If the object is a dynamic structure, it is created either in +memory storage and passed to cvOpenFileStorage or, if a NULL pointer was passed, in temporary +memory storage, which is released when cvReleaseFileStorage is called. Otherwise, if the object is +not a dynamic structure, it is created in a heap and should be released with a specialized function +or by using the generic cvRelease. +@param fs File storage +@param node The root object node +@param attributes Unused parameter + */ CVAPI(void*) cvRead( CvFileStorage* fs, CvFileNode* node, CvAttrList* attributes CV_DEFAULT(NULL)); -/* decodes standard or user-defined object and returns it */ +/** @brief Finds an object by name and decodes it. + +The function is a simple superposition of cvGetFileNodeByName and cvRead. +@param fs File storage +@param map The parent map. If it is NULL, the function searches a top-level node. +@param name The node name +@param attributes Unused parameter + */ CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map, const char* name, CvAttrList* attributes CV_DEFAULT(NULL) ) { @@ -1457,42 +2427,158 @@ CV_INLINE void* cvReadByName( CvFileStorage* fs, const CvFileNode* map, } -/* starts reading data from sequence or scalar numeric node */ +/** @brief Initializes the file node sequence reader. + +The function initializes the sequence reader to read data from a file node. The initialized reader +can be then passed to cvReadRawDataSlice. +@param fs File storage +@param src The file node (a sequence) to read numbers from +@param reader Pointer to the sequence reader + */ CVAPI(void) cvStartReadRawData( const CvFileStorage* fs, const CvFileNode* src, CvSeqReader* reader ); -/* reads multiple numbers and stores them to array */ +/** @brief Initializes file node sequence reader. + +The function reads one or more elements from the file node, representing a sequence, to a +user-specified array. The total number of read sequence elements is a product of total and the +number of components in each array element. For example, if dt=2if, the function will read total\*3 +sequence elements. As with any sequence, some parts of the file node sequence can be skipped or read +repeatedly by repositioning the reader using cvSetSeqReaderPos. +@param fs File storage +@param reader The sequence reader. Initialize it with cvStartReadRawData . +@param count The number of elements to read +@param dst Pointer to the destination array +@param dt Specification of each array element. It has the same format as in cvWriteRawData . + */ CVAPI(void) cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader, int count, void* dst, const char* dt ); -/* combination of two previous functions for easier reading of whole sequences */ +/** @brief Reads multiple numbers. + +The function reads elements from a file node that represents a sequence of scalars. +@param fs File storage +@param src The file node (a sequence) to read numbers from +@param dst Pointer to the destination array +@param dt Specification of each array element. It has the same format as in cvWriteRawData . + */ CVAPI(void) cvReadRawData( const CvFileStorage* fs, const CvFileNode* src, void* dst, const char* dt ); -/* writes a copy of file node to file storage */ +/** @brief Writes a file node to another file storage. + +The function writes a copy of a file node to file storage. Possible applications of the function are +merging several file storages into one and conversion between XML and YAML formats. +@param fs Destination file storage +@param new_node_name New name of the file node in the destination file storage. To keep the +existing name, use cvcvGetFileNodeName +@param node The written node +@param embed If the written node is a collection and this parameter is not zero, no extra level of +hierarchy is created. Instead, all the elements of node are written into the currently written +structure. Of course, map elements can only be embedded into another map, and sequence elements +can only be embedded into another sequence. + */ CVAPI(void) cvWriteFileNode( CvFileStorage* fs, const char* new_node_name, const CvFileNode* node, int embed ); -/* returns name of file node */ +/** @brief Returns the name of a file node. + +The function returns the name of a file node or NULL, if the file node does not have a name or if +node is NULL. +@param node File node + */ CVAPI(const char*) cvGetFileNodeName( const CvFileNode* node ); /*********************************** Adding own types ***********************************/ +/** @brief Registers a new type. + +The function registers a new type, which is described by info . The function creates a copy of the +structure, so the user should delete it after calling the function. +@param info Type info structure + */ CVAPI(void) cvRegisterType( const CvTypeInfo* info ); + +/** @brief Unregisters the type. + +The function unregisters a type with a specified name. If the name is unknown, it is possible to +locate the type info by an instance of the type using cvTypeOf or by iterating the type list, +starting from cvFirstType, and then calling cvUnregisterType(info-\>typeName). +@param type_name Name of an unregistered type + */ CVAPI(void) cvUnregisterType( const char* type_name ); + +/** @brief Returns the beginning of a type list. + +The function returns the first type in the list of registered types. Navigation through the list can +be done via the prev and next fields of the CvTypeInfo structure. + */ CVAPI(CvTypeInfo*) cvFirstType(void); + +/** @brief Finds a type by its name. + +The function finds a registered type by its name. It returns NULL if there is no type with the +specified name. +@param type_name Type name + */ CVAPI(CvTypeInfo*) cvFindType( const char* type_name ); + +/** @brief Returns the type of an object. + +The function finds the type of a given object. It iterates through the list of registered types and +calls the is_instance function/method for every type info structure with that object until one of +them returns non-zero or until the whole list has been traversed. In the latter case, the function +returns NULL. +@param struct_ptr The object pointer + */ CVAPI(CvTypeInfo*) cvTypeOf( const void* struct_ptr ); -/* universal functions */ +/** @brief Releases an object. + +The function finds the type of a given object and calls release with the double pointer. +@param struct_ptr Double pointer to the object + */ CVAPI(void) cvRelease( void** struct_ptr ); + +/** @brief Makes a clone of an object. + +The function finds the type of a given object and calls clone with the passed object. Of course, if +you know the object type, for example, struct_ptr is CvMat\*, it is faster to call the specific +function, like cvCloneMat. +@param struct_ptr The object to clone + */ CVAPI(void*) cvClone( const void* struct_ptr ); -/* simple API for reading/writing data */ +/** @brief Saves an object to a file. + +The function saves an object to a file. It provides a simple interface to cvWrite . +@param filename File name +@param struct_ptr Object to save +@param name Optional object name. If it is NULL, the name will be formed from filename . +@param comment Optional comment to put in the beginning of the file +@param attributes Optional attributes passed to cvWrite + */ CVAPI(void) cvSave( const char* filename, const void* struct_ptr, const char* name CV_DEFAULT(NULL), const char* comment CV_DEFAULT(NULL), CvAttrList attributes CV_DEFAULT(cvAttrList())); + +/** @brief Loads an object from a file. + +The function loads an object from a file. It basically reads the specified file, find the first +top-level node and calls cvRead for that node. If the file node does not have type information or +the type information can not be found by the type name, the function returns NULL. After the object +is loaded, the file storage is closed and all the temporary buffers are deleted. Thus, to load a +dynamic structure, such as a sequence, contour, or graph, one should pass a valid memory storage +destination to the function. +@param filename File name +@param memstorage Memory storage for dynamic structures, such as CvSeq or CvGraph . It is not used +for matrices or images. +@param name Optional object name. If it is NULL, the first top-level object in the storage will be +loaded. +@param real_name Optional output parameter that will contain the name of the loaded object +(useful if name=NULL ) + */ CVAPI(void*) cvLoad( const char* filename, CvMemStorage* memstorage CV_DEFAULT(NULL), const char* name CV_DEFAULT(NULL), @@ -1500,7 +2586,7 @@ CVAPI(void*) cvLoad( const char* filename, /*********************************** Measuring Execution Time ***************************/ -/* helper functions for RNG initialization and accurate time measurement: +/** helper functions for RNG initialization and accurate time measurement: uses internal clock counter on x86 */ CVAPI(int64) cvGetTickCount( void ); CVAPI(double) cvGetTickFrequency( void ); @@ -1511,67 +2597,64 @@ CVAPI(int) cvCheckHardwareSupport(int feature); /*********************************** Multi-Threading ************************************/ -/* retrieve/set the number of threads used in OpenMP implementations */ +/** retrieve/set the number of threads used in OpenMP implementations */ CVAPI(int) cvGetNumThreads( void ); CVAPI(void) cvSetNumThreads( int threads CV_DEFAULT(0) ); -/* get index of the thread being executed */ +/** get index of the thread being executed */ CVAPI(int) cvGetThreadNum( void ); /********************************** Error Handling **************************************/ -/* Get current OpenCV error status */ +/** Get current OpenCV error status */ CVAPI(int) cvGetErrStatus( void ); -/* Sets error status silently */ +/** Sets error status silently */ CVAPI(void) cvSetErrStatus( int status ); #define CV_ErrModeLeaf 0 /* Print error and exit program */ #define CV_ErrModeParent 1 /* Print error and continue */ #define CV_ErrModeSilent 2 /* Don't print and continue */ -/* Retrives current error processing mode */ +/** Retrives current error processing mode */ CVAPI(int) cvGetErrMode( void ); -/* Sets error processing mode, returns previously used mode */ +/** Sets error processing mode, returns previously used mode */ CVAPI(int) cvSetErrMode( int mode ); -/* Sets error status and performs some additonal actions (displaying message box, +/** Sets error status and performs some additonal actions (displaying message box, writing message to stderr, terminating application etc.) depending on the current error mode */ CVAPI(void) cvError( int status, const char* func_name, const char* err_msg, const char* file_name, int line ); -/* Retrieves textual description of the error given its code */ +/** Retrieves textual description of the error given its code */ CVAPI(const char*) cvErrorStr( int status ); -/* Retrieves detailed information about the last error occured */ +/** Retrieves detailed information about the last error occured */ CVAPI(int) cvGetErrInfo( const char** errcode_desc, const char** description, const char** filename, int* line ); -/* Maps IPP error codes to the counterparts from OpenCV */ +/** Maps IPP error codes to the counterparts from OpenCV */ CVAPI(int) cvErrorFromIppStatus( int ipp_status ); typedef int (CV_CDECL *CvErrorCallback)( int status, const char* func_name, const char* err_msg, const char* file_name, int line, void* userdata ); -/* Assigns a new error-handling function */ +/** Assigns a new error-handling function */ CVAPI(CvErrorCallback) cvRedirectError( CvErrorCallback error_handler, void* userdata CV_DEFAULT(NULL), void** prev_userdata CV_DEFAULT(NULL) ); -/* - Output to: - cvNulDevReport - nothing - cvStdErrReport - console(fprintf(stderr,...)) - cvGuiBoxReport - MessageBox(WIN32) - */ +/** Output nothing */ CVAPI(int) cvNulDevReport( int status, const char* func_name, const char* err_msg, const char* file_name, int line, void* userdata ); +/** Output to console(fprintf(stderr,...)) */ CVAPI(int) cvStdErrReport( int status, const char* func_name, const char* err_msg, const char* file_name, int line, void* userdata ); +/** Output to MessageBox(WIN32) */ CVAPI(int) cvGuiBoxReport( int status, const char* func_name, const char* err_msg, const char* file_name, int line, void* userdata ); @@ -1588,7 +2671,7 @@ Func; \ } -/* CV_FUNCNAME macro defines icvFuncName constant which is used by CV_ERROR macro */ +/** CV_FUNCNAME macro defines icvFuncName constant which is used by CV_ERROR macro */ #ifdef CV_NO_FUNC_NAMES #define CV_FUNCNAME( Name ) #define cvFuncName "" @@ -1598,7 +2681,7 @@ static char cvFuncName[] = Name #endif -/* +/** CV_ERROR macro unconditionally raises error with passed code and message. After raising error, control will be transferred to the exit label. */ @@ -1608,7 +2691,7 @@ static char cvFuncName[] = Name __CV_EXIT__; \ } -/* +/** CV_CHECK macro checks error status after CV (or IPL) function call. If error detected, control will be transferred to the exit label. @@ -1620,7 +2703,7 @@ static char cvFuncName[] = Name } -/* +/** CV_CALL macro calls CV (or IPL) function, checks error status and signals a error if the function failed. Useful in "parent node" error procesing mode @@ -1632,7 +2715,7 @@ static char cvFuncName[] = Name } -/* Runtime assertion macro */ +/** Runtime assertion macro */ #define CV_ASSERT( Condition ) \ { \ if( !(Condition) ) \ @@ -1643,12 +2726,18 @@ static char cvFuncName[] = Name #define __CV_END__ goto exit; exit: ; } #define __CV_EXIT__ goto exit +/** @} core_c */ + #ifdef __cplusplus } // extern "C" #endif #ifdef __cplusplus -// class for automatic module/RTTI data registration/unregistration + +//! @addtogroup core_c_glue +//! @{ + +//! class for automatic module/RTTI data registration/unregistration struct CV_EXPORTS CvType { CvType( const char* type_name, @@ -1661,11 +2750,16 @@ struct CV_EXPORTS CvType static CvTypeInfo* last; }; +//! @} + #include "opencv2/core/utility.hpp" namespace cv { +//! @addtogroup core_c_glue +//! @{ + /////////////////////////////////////////// glue /////////////////////////////////////////// //! converts array (CvMat or IplImage) to cv::Mat @@ -2049,6 +3143,8 @@ template inline bool operator != (const SeqIterator<_Tp>& a, return !(a == b); } +//! @} + } // cv #endif diff --git a/modules/core/include/opencv2/core/cuda.hpp b/modules/core/include/opencv2/core/cuda.hpp index 4ae4301665..612b5dbd1d 100644 --- a/modules/core/include/opencv2/core/cuda.hpp +++ b/modules/core/include/opencv2/core/cuda.hpp @@ -51,13 +51,22 @@ #include "opencv2/core.hpp" #include "opencv2/core/cuda_types.hpp" +/** +@defgroup cuda CUDA-accelerated Computer Vision +@{ + @defgroup cuda_struct Data structures +@} + */ + namespace cv { namespace cuda { -//////////////////////////////// GpuMat /////////////////////////////// +//! @addtogroup cuda_struct +//! @{ -// Smart pointer for GPU memory with reference counting. -// Its interface is mostly similar with cv::Mat. +//////////////////////////////// GpuMat /////////////////////////////// +//! Smart pointer for GPU memory with reference counting. +//! Its interface is mostly similar with cv::Mat. class CV_EXPORTS GpuMat { public: @@ -283,11 +292,10 @@ CV_EXPORTS void setBufferPoolConfig(int deviceId, size_t stackSize, int stackCou //////////////////////////////// CudaMem //////////////////////////////// -// CudaMem is limited cv::Mat with page locked memory allocation. -// Page locked memory is only needed for async and faster coping to GPU. -// It is convertable to cv::Mat header without reference counting -// so you can use it with other opencv functions. - +//! CudaMem is limited cv::Mat with page locked memory allocation. +//! Page locked memory is only needed for async and faster coping to GPU. +//! It is convertable to cv::Mat header without reference counting +//! so you can use it with other opencv functions. class CV_EXPORTS CudaMem { public: @@ -363,10 +371,9 @@ CV_EXPORTS void unregisterPageLocked(Mat& m); ///////////////////////////////// Stream ////////////////////////////////// -// Encapculates Cuda Stream. Provides interface for async coping. -// Passed to each function that supports async kernel execution. -// Reference counting is enabled. - +//! Encapculates Cuda Stream. Provides interface for async coping. +//! Passed to each function that supports async kernel execution. +//! Reference counting is enabled. class CV_EXPORTS Stream { typedef void (Stream::*bool_type)() const; @@ -563,10 +570,10 @@ public: enum ComputeMode { - ComputeModeDefault, /**< default compute mode (Multiple threads can use ::cudaSetDevice() with this device) */ - ComputeModeExclusive, /**< compute-exclusive-thread mode (Only one thread in one process will be able to use ::cudaSetDevice() with this device) */ - ComputeModeProhibited, /**< compute-prohibited mode (No threads can use ::cudaSetDevice() with this device) */ - ComputeModeExclusiveProcess /**< compute-exclusive-process mode (Many threads in one process will be able to use ::cudaSetDevice() with this device) */ + ComputeModeDefault, /**< default compute mode (Multiple threads can use cudaSetDevice with this device) */ + ComputeModeExclusive, /**< compute-exclusive-thread mode (Only one thread in one process will be able to use cudaSetDevice with this device) */ + ComputeModeProhibited, /**< compute-prohibited mode (No threads can use cudaSetDevice with this device) */ + ComputeModeExclusiveProcess /**< compute-exclusive-process mode (Many threads in one process will be able to use cudaSetDevice with this device) */ }; //! compute mode @@ -686,6 +693,8 @@ private: CV_EXPORTS void printCudaDeviceInfo(int device); CV_EXPORTS void printShortCudaDeviceInfo(int device); +//! @} + }} // namespace cv { namespace cuda { diff --git a/modules/core/include/opencv2/core/cuda.inl.hpp b/modules/core/include/opencv2/core/cuda.inl.hpp index f111bc45ab..652bcfea29 100644 --- a/modules/core/include/opencv2/core/cuda.inl.hpp +++ b/modules/core/include/opencv2/core/cuda.inl.hpp @@ -46,6 +46,8 @@ #include "opencv2/core/cuda.hpp" +//! @cond IGNORED + namespace cv { namespace cuda { //////////////////////////////// GpuMat /////////////////////////////// @@ -224,7 +226,6 @@ const _Tp* GpuMat::ptr(int y) const return (const _Tp*)ptr(y); } -/** @cond IGNORED */ template inline GpuMat::operator PtrStepSz() const { @@ -236,7 +237,6 @@ GpuMat::operator PtrStep() const { return PtrStep((T*)data, step); } -/** @endcond */ inline GpuMat GpuMat::row(int y) const @@ -589,6 +589,7 @@ bool DeviceInfo::supports(FeatureSet feature_set) const return version >= feature_set; } + }} // namespace cv { namespace cuda { //////////////////////////////// Mat //////////////////////////////// @@ -604,4 +605,6 @@ Mat::Mat(const cuda::GpuMat& m) } +//! @endcond + #endif // __OPENCV_CORE_CUDAINL_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/block.hpp b/modules/core/include/opencv2/core/cuda/block.hpp index 0d596fd348..8377adf213 100644 --- a/modules/core/include/opencv2/core/cuda/block.hpp +++ b/modules/core/include/opencv2/core/cuda/block.hpp @@ -43,8 +43,11 @@ #ifndef __OPENCV_CUDA_DEVICE_BLOCK_HPP__ #define __OPENCV_CUDA_DEVICE_BLOCK_HPP__ + namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ struct Block { static __device__ __forceinline__ unsigned int id() @@ -198,6 +201,7 @@ namespace cv { namespace cuda { namespace device } } }; +//!@} }}} #endif /* __OPENCV_CUDA_DEVICE_BLOCK_HPP__ */ diff --git a/modules/core/include/opencv2/core/cuda/border_interpolate.hpp b/modules/core/include/opencv2/core/cuda/border_interpolate.hpp index e2128abd5a..3d639b4716 100644 --- a/modules/core/include/opencv2/core/cuda/border_interpolate.hpp +++ b/modules/core/include/opencv2/core/cuda/border_interpolate.hpp @@ -49,6 +49,9 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ + ////////////////////////////////////////////////////////////// // BrdConstant @@ -709,6 +712,7 @@ namespace cv { namespace cuda { namespace device int width; D val; }; +//! @} }}} // namespace cv { namespace cuda { namespace cudev #endif // __OPENCV_CUDA_BORDER_INTERPOLATE_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/color.hpp b/modules/core/include/opencv2/core/cuda/color.hpp index 69c68af757..524d2e2a47 100644 --- a/modules/core/include/opencv2/core/cuda/color.hpp +++ b/modules/core/include/opencv2/core/cuda/color.hpp @@ -47,6 +47,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ // All OPENCV_CUDA_IMPLEMENT_*_TRAITS(ColorSpace1_to_ColorSpace2, ...) macros implements // template class ColorSpace1_to_ColorSpace2_traits // { @@ -296,6 +298,7 @@ namespace cv { namespace cuda { namespace device OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS(luv4_to_lbgra, 4, 4, false, 0) #undef OPENCV_CUDA_IMPLEMENT_Luv2RGB_TRAITS +//! @} }}} // namespace cv { namespace cuda { namespace cudev #endif // __OPENCV_CUDA_BORDER_INTERPOLATE_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/common.hpp b/modules/core/include/opencv2/core/cuda/common.hpp index 5e5884153a..022b13ebb6 100644 --- a/modules/core/include/opencv2/core/cuda/common.hpp +++ b/modules/core/include/opencv2/core/cuda/common.hpp @@ -48,6 +48,7 @@ #include "opencv2/core/cvdef.h" #include "opencv2/core/base.hpp" + #ifndef CV_PI_F #ifndef CV_PI #define CV_PI_F 3.14159265f @@ -57,11 +58,14 @@ #endif namespace cv { namespace cuda { +//! @addtogroup cuda +//! @{ static inline void checkCudaError(cudaError_t err, const char* file, const int line, const char* func) { if (cudaSuccess != err) cv::error(cv::Error::GpuApiCallError, cudaGetErrorString(err), func, file, line); } +//! @} }} #ifndef cudaSafeCall @@ -70,6 +74,8 @@ namespace cv { namespace cuda { namespace cv { namespace cuda { +//! @addtogroup cuda +//! @{ template static inline bool isAligned(const T* ptr, size_t size) { return reinterpret_cast(ptr) % size == 0; @@ -79,12 +85,15 @@ namespace cv { namespace cuda { return step % size == 0; } +//! @} }} namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ __host__ __device__ __forceinline__ int divUp(int total, int grain) { return (total + grain - 1) / grain; @@ -95,9 +104,8 @@ namespace cv { namespace cuda cudaChannelFormatDesc desc = cudaCreateChannelDesc(); cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) ); } +//! @} } }} - - #endif // __OPENCV_CUDA_COMMON_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/datamov_utils.hpp b/modules/core/include/opencv2/core/cuda/datamov_utils.hpp index aea88a35cd..4d4035a3a3 100644 --- a/modules/core/include/opencv2/core/cuda/datamov_utils.hpp +++ b/modules/core/include/opencv2/core/cuda/datamov_utils.hpp @@ -47,6 +47,9 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ + #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 200 // for Fermi memory space is detected automatically @@ -100,6 +103,7 @@ namespace cv { namespace cuda { namespace device #undef OPENCV_CUDA_ASM_PTR #endif // __CUDA_ARCH__ >= 200 +//! @} }}} // namespace cv { namespace cuda { namespace cudev #endif // __OPENCV_CUDA_DATAMOV_UTILS_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/detail/color_detail.hpp b/modules/core/include/opencv2/core/cuda/detail/color_detail.hpp index 095ca669e4..1151806764 100644 --- a/modules/core/include/opencv2/core/cuda/detail/color_detail.hpp +++ b/modules/core/include/opencv2/core/cuda/detail/color_detail.hpp @@ -49,6 +49,8 @@ #include "../limits.hpp" #include "../functional.hpp" +//! @cond IGNORED + namespace cv { namespace cuda { namespace device { #ifndef CV_DESCALE @@ -1973,4 +1975,6 @@ namespace cv { namespace cuda { namespace device }}} // namespace cv { namespace cuda { namespace cudev +//! @endcond + #endif // __OPENCV_CUDA_COLOR_DETAIL_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/detail/reduce.hpp b/modules/core/include/opencv2/core/cuda/detail/reduce.hpp index c1ba68c821..0c35eaba65 100644 --- a/modules/core/include/opencv2/core/cuda/detail/reduce.hpp +++ b/modules/core/include/opencv2/core/cuda/detail/reduce.hpp @@ -47,6 +47,8 @@ #include "../warp.hpp" #include "../warp_shuffle.hpp" +//! @cond IGNORED + namespace cv { namespace cuda { namespace device { namespace reduce_detail @@ -358,4 +360,6 @@ namespace cv { namespace cuda { namespace device } }}} +//! @endcond + #endif // __OPENCV_CUDA_REDUCE_DETAIL_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/detail/reduce_key_val.hpp b/modules/core/include/opencv2/core/cuda/detail/reduce_key_val.hpp index ed179ad78c..bab85d70cd 100644 --- a/modules/core/include/opencv2/core/cuda/detail/reduce_key_val.hpp +++ b/modules/core/include/opencv2/core/cuda/detail/reduce_key_val.hpp @@ -47,6 +47,8 @@ #include "../warp.hpp" #include "../warp_shuffle.hpp" +//! @cond IGNORED + namespace cv { namespace cuda { namespace device { namespace reduce_key_val_detail @@ -495,4 +497,6 @@ namespace cv { namespace cuda { namespace device } }}} +//! @endcond + #endif // __OPENCV_CUDA_PRED_VAL_REDUCE_DETAIL_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/detail/transform_detail.hpp b/modules/core/include/opencv2/core/cuda/detail/transform_detail.hpp index a241e0bb38..96031c8cde 100644 --- a/modules/core/include/opencv2/core/cuda/detail/transform_detail.hpp +++ b/modules/core/include/opencv2/core/cuda/detail/transform_detail.hpp @@ -47,6 +47,8 @@ #include "../vec_traits.hpp" #include "../functional.hpp" +//! @cond IGNORED + namespace cv { namespace cuda { namespace device { namespace transform_detail @@ -392,4 +394,6 @@ namespace cv { namespace cuda { namespace device } // namespace transform_detail }}} // namespace cv { namespace cuda { namespace cudev +//! @endcond + #endif // __OPENCV_CUDA_TRANSFORM_DETAIL_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/detail/type_traits_detail.hpp b/modules/core/include/opencv2/core/cuda/detail/type_traits_detail.hpp index 8324a31e0e..3463c78fec 100644 --- a/modules/core/include/opencv2/core/cuda/detail/type_traits_detail.hpp +++ b/modules/core/include/opencv2/core/cuda/detail/type_traits_detail.hpp @@ -46,6 +46,8 @@ #include "../common.hpp" #include "../vec_traits.hpp" +//! @cond IGNORED + namespace cv { namespace cuda { namespace device { namespace type_traits_detail @@ -184,4 +186,6 @@ namespace cv { namespace cuda { namespace device } // namespace type_traits_detail }}} // namespace cv { namespace cuda { namespace cudev +//! @endcond + #endif // __OPENCV_CUDA_TYPE_TRAITS_DETAIL_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/detail/vec_distance_detail.hpp b/modules/core/include/opencv2/core/cuda/detail/vec_distance_detail.hpp index a62c51a573..9ca85a539d 100644 --- a/modules/core/include/opencv2/core/cuda/detail/vec_distance_detail.hpp +++ b/modules/core/include/opencv2/core/cuda/detail/vec_distance_detail.hpp @@ -45,6 +45,8 @@ #include "../datamov_utils.hpp" +//! @cond IGNORED + namespace cv { namespace cuda { namespace device { namespace vec_distance_detail @@ -114,4 +116,6 @@ namespace cv { namespace cuda { namespace device } // namespace vec_distance_detail }}} // namespace cv { namespace cuda { namespace cudev +//! @endcond + #endif // __OPENCV_CUDA_VEC_DISTANCE_DETAIL_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/dynamic_smem.hpp b/modules/core/include/opencv2/core/cuda/dynamic_smem.hpp index 269e18a8f0..8d71532ae7 100644 --- a/modules/core/include/opencv2/core/cuda/dynamic_smem.hpp +++ b/modules/core/include/opencv2/core/cuda/dynamic_smem.hpp @@ -45,6 +45,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ template struct DynamicSharedMem { __device__ __forceinline__ operator T*() @@ -75,6 +77,7 @@ namespace cv { namespace cuda { namespace device return (double*)__smem_d; } }; +//! @} }}} #endif // __OPENCV_CUDA_DYNAMIC_SMEM_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/emulation.hpp b/modules/core/include/opencv2/core/cuda/emulation.hpp index 16fe2986bc..3063266b77 100644 --- a/modules/core/include/opencv2/core/cuda/emulation.hpp +++ b/modules/core/include/opencv2/core/cuda/emulation.hpp @@ -48,6 +48,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ struct Emulation { @@ -256,6 +258,7 @@ namespace cv { namespace cuda { namespace device } }; }; //struct Emulation +//!@} }}} // namespace cv { namespace cuda { namespace cudev #endif /* OPENCV_CUDA_EMULATION_HPP_ */ diff --git a/modules/core/include/opencv2/core/cuda/filters.hpp b/modules/core/include/opencv2/core/cuda/filters.hpp index f3cbf69589..8bec9fe261 100644 --- a/modules/core/include/opencv2/core/cuda/filters.hpp +++ b/modules/core/include/opencv2/core/cuda/filters.hpp @@ -50,6 +50,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ template struct PointFilter { typedef typename Ptr2D::elem_type elem_type; @@ -273,6 +275,7 @@ namespace cv { namespace cuda { namespace device float scale_x, scale_y; int width, haight; }; +//! @} }}} // namespace cv { namespace cuda { namespace cudev #endif // __OPENCV_CUDA_FILTERS_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/funcattrib.hpp b/modules/core/include/opencv2/core/cuda/funcattrib.hpp index 7085cba0f6..fa2039ab2b 100644 --- a/modules/core/include/opencv2/core/cuda/funcattrib.hpp +++ b/modules/core/include/opencv2/core/cuda/funcattrib.hpp @@ -47,6 +47,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ template void printFuncAttrib(Func& func) { @@ -66,6 +68,7 @@ namespace cv { namespace cuda { namespace device printf("\n"); fflush(stdout); } +//! @} }}} // namespace cv { namespace cuda { namespace cudev #endif /* __OPENCV_CUDA_DEVICE_FUNCATTRIB_HPP_ */ diff --git a/modules/core/include/opencv2/core/cuda/functional.hpp b/modules/core/include/opencv2/core/cuda/functional.hpp index bebb8bf070..3060bbc680 100644 --- a/modules/core/include/opencv2/core/cuda/functional.hpp +++ b/modules/core/include/opencv2/core/cuda/functional.hpp @@ -51,6 +51,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ // Function Objects template struct unary_function : public std::unary_function {}; template struct binary_function : public std::binary_function {}; @@ -784,6 +786,7 @@ namespace cv { namespace cuda { namespace device #define OPENCV_CUDA_TRANSFORM_FUNCTOR_TRAITS(type) \ template <> struct TransformFunctorTraits< type > : DefaultTransformFunctorTraits< type > +//! @} }}} // namespace cv { namespace cuda { namespace cudev #endif // __OPENCV_CUDA_FUNCTIONAL_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/limits.hpp b/modules/core/include/opencv2/core/cuda/limits.hpp index abfdca3673..e22d99d00b 100644 --- a/modules/core/include/opencv2/core/cuda/limits.hpp +++ b/modules/core/include/opencv2/core/cuda/limits.hpp @@ -49,7 +49,8 @@ namespace cv { namespace cuda { namespace device { - +//! @addtogroup cuda +//! @{ template struct numeric_limits; template <> struct numeric_limits @@ -116,7 +117,7 @@ template <> struct numeric_limits __device__ __forceinline__ static double epsilon() { return DBL_EPSILON; } static const bool is_signed = true; }; - +//! @} }}} // namespace cv { namespace cuda { namespace cudev { #endif // __OPENCV_CUDA_LIMITS_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/reduce.hpp b/modules/core/include/opencv2/core/cuda/reduce.hpp index 8112203e6c..0f18b1e404 100644 --- a/modules/core/include/opencv2/core/cuda/reduce.hpp +++ b/modules/core/include/opencv2/core/cuda/reduce.hpp @@ -49,6 +49,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ template __device__ __forceinline__ void reduce(volatile T* smem, T& val, unsigned int tid, const Op& op) { @@ -192,6 +194,7 @@ namespace cv { namespace cuda { namespace device { return thrust::make_tuple((volatile T0*) t0, (volatile T1*) t1, (volatile T2*) t2, (volatile T3*) t3, (volatile T4*) t4, (volatile T5*) t5, (volatile T6*) t6, (volatile T7*) t7, (volatile T8*) t8, (volatile T9*) t9); } +//! @} }}} #endif // __OPENCV_CUDA_UTILITY_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/saturate_cast.hpp b/modules/core/include/opencv2/core/cuda/saturate_cast.hpp index 84e1918075..46927a5097 100644 --- a/modules/core/include/opencv2/core/cuda/saturate_cast.hpp +++ b/modules/core/include/opencv2/core/cuda/saturate_cast.hpp @@ -47,6 +47,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ template __device__ __forceinline__ _Tp saturate_cast(uchar v) { return _Tp(v); } template __device__ __forceinline__ _Tp saturate_cast(schar v) { return _Tp(v); } template __device__ __forceinline__ _Tp saturate_cast(ushort v) { return _Tp(v); } @@ -279,6 +281,7 @@ namespace cv { namespace cuda { namespace device return saturate_cast((float)v); #endif } +//! @} }}} #endif /* __OPENCV_CUDA_SATURATE_CAST_HPP__ */ diff --git a/modules/core/include/opencv2/core/cuda/scan.hpp b/modules/core/include/opencv2/core/cuda/scan.hpp index 33cb62e940..e1dbb0059f 100644 --- a/modules/core/include/opencv2/core/cuda/scan.hpp +++ b/modules/core/include/opencv2/core/cuda/scan.hpp @@ -50,6 +50,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ enum ScanKind { EXCLUSIVE = 0, INCLUSIVE = 1 }; template struct WarpScan @@ -245,6 +247,7 @@ namespace cv { namespace cuda { namespace device return warpScanInclusive(idata, s_Data, tid); } } +//! @} }}} #endif // __OPENCV_CUDA_SCAN_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/simd_functions.hpp b/modules/core/include/opencv2/core/cuda/simd_functions.hpp index 0a7889e00d..d6b7435419 100644 --- a/modules/core/include/opencv2/core/cuda/simd_functions.hpp +++ b/modules/core/include/opencv2/core/cuda/simd_functions.hpp @@ -75,7 +75,7 @@ #include "common.hpp" -/* +/** @file This header file contains inline functions that implement intra-word SIMD operations, that are hardware accelerated on sm_3x (Kepler) GPUs. Efficient emulation code paths are provided for earlier architectures (sm_1x, sm_2x) @@ -125,6 +125,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ // 2 static __device__ __forceinline__ unsigned int vadd2(unsigned int a, unsigned int b) @@ -904,6 +906,7 @@ namespace cv { namespace cuda { namespace device return r; } +//! @} }}} #endif // __OPENCV_CUDA_SIMD_FUNCTIONS_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/transform.hpp b/modules/core/include/opencv2/core/cuda/transform.hpp index 236af6690b..bc86bd1e86 100644 --- a/modules/core/include/opencv2/core/cuda/transform.hpp +++ b/modules/core/include/opencv2/core/cuda/transform.hpp @@ -49,6 +49,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ template static inline void transform(PtrStepSz src, PtrStepSz dst, UnOp op, const Mask& mask, cudaStream_t stream) { @@ -62,6 +64,7 @@ namespace cv { namespace cuda { namespace device typedef TransformFunctorTraits ft; transform_detail::TransformDispatcher::cn == 1 && VecTraits::cn == 1 && VecTraits::cn == 1 && ft::smart_shift != 1>::call(src1, src2, dst, op, mask, stream); } +//! @} }}} #endif // __OPENCV_CUDA_TRANSFORM_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/type_traits.hpp b/modules/core/include/opencv2/core/cuda/type_traits.hpp index d06a374c52..a9e9180698 100644 --- a/modules/core/include/opencv2/core/cuda/type_traits.hpp +++ b/modules/core/include/opencv2/core/cuda/type_traits.hpp @@ -47,6 +47,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ template struct IsSimpleParameter { enum {value = type_traits_detail::IsIntegral::value || type_traits_detail::IsFloat::value || @@ -77,6 +79,7 @@ namespace cv { namespace cuda { namespace device typedef typename type_traits_detail::Select::value, T, typename type_traits_detail::AddParameterType::type>::type ParameterType; }; +//! @} }}} #endif // __OPENCV_CUDA_TYPE_TRAITS_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/utility.hpp b/modules/core/include/opencv2/core/cuda/utility.hpp index 841638725f..ad6c7094ac 100644 --- a/modules/core/include/opencv2/core/cuda/utility.hpp +++ b/modules/core/include/opencv2/core/cuda/utility.hpp @@ -48,6 +48,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ #define OPENCV_CUDA_LOG_WARP_SIZE (5) #define OPENCV_CUDA_WARP_SIZE (1 << OPENCV_CUDA_LOG_WARP_SIZE) #define OPENCV_CUDA_LOG_MEM_BANKS ((__CUDA_ARCH__ >= 200) ? 5 : 4) // 32 banks on fermi, 16 on tesla @@ -208,6 +210,7 @@ namespace cv { namespace cuda { namespace device return false; } +//! @} }}} // namespace cv { namespace cuda { namespace cudev #endif // __OPENCV_CUDA_UTILITY_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/vec_distance.hpp b/modules/core/include/opencv2/core/cuda/vec_distance.hpp index 2a00303a33..4bad198e0c 100644 --- a/modules/core/include/opencv2/core/cuda/vec_distance.hpp +++ b/modules/core/include/opencv2/core/cuda/vec_distance.hpp @@ -49,6 +49,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ template struct L1Dist { typedef int value_type; @@ -219,6 +221,7 @@ namespace cv { namespace cuda { namespace device U vec1Vals[MAX_LEN / THREAD_DIM]; }; +//! @} }}} // namespace cv { namespace cuda { namespace cudev #endif // __OPENCV_CUDA_VEC_DISTANCE_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/vec_math.hpp b/modules/core/include/opencv2/core/cuda/vec_math.hpp index 2b774d7f29..ac4a493d68 100644 --- a/modules/core/include/opencv2/core/cuda/vec_math.hpp +++ b/modules/core/include/opencv2/core/cuda/vec_math.hpp @@ -49,6 +49,9 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ + // saturate_cast namespace vec_math_detail @@ -917,6 +920,8 @@ CV_CUDEV_IMPLEMENT_SCALAR_BINARY_FUNC(atan2, ::atan2, double, double, double) #undef CV_CUDEV_IMPLEMENT_SCALAR_BINARY_FUNC +//! @} + }}} // namespace cv { namespace cuda { namespace device #endif // __OPENCV_CUDA_VECMATH_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/vec_traits.hpp b/modules/core/include/opencv2/core/cuda/vec_traits.hpp index 17f0ee746a..6369112ffa 100644 --- a/modules/core/include/opencv2/core/cuda/vec_traits.hpp +++ b/modules/core/include/opencv2/core/cuda/vec_traits.hpp @@ -47,6 +47,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ template struct TypeVec; struct __align__(8) uchar8 @@ -275,6 +277,7 @@ namespace cv { namespace cuda { namespace device static __device__ __host__ __forceinline__ char8 make(schar a0, schar a1, schar a2, schar a3, schar a4, schar a5, schar a6, schar a7) {return make_char8(a0, a1, a2, a3, a4, a5, a6, a7);} static __device__ __host__ __forceinline__ char8 make(const schar* v) {return make_char8(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);} }; +//! @} }}} // namespace cv { namespace cuda { namespace cudev #endif // __OPENCV_CUDA_VEC_TRAITS_HPP__ diff --git a/modules/core/include/opencv2/core/cuda/warp.hpp b/modules/core/include/opencv2/core/cuda/warp.hpp index c9659d6aa8..67abd05728 100644 --- a/modules/core/include/opencv2/core/cuda/warp.hpp +++ b/modules/core/include/opencv2/core/cuda/warp.hpp @@ -45,6 +45,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ struct Warp { enum @@ -126,6 +128,7 @@ namespace cv { namespace cuda { namespace device *t = value; } }; +//! @} }}} // namespace cv { namespace cuda { namespace cudev #endif /* __OPENCV_CUDA_DEVICE_WARP_HPP__ */ diff --git a/modules/core/include/opencv2/core/cuda/warp_reduce.hpp b/modules/core/include/opencv2/core/cuda/warp_reduce.hpp index 5f0f8dbf17..6df04bb028 100644 --- a/modules/core/include/opencv2/core/cuda/warp_reduce.hpp +++ b/modules/core/include/opencv2/core/cuda/warp_reduce.hpp @@ -45,6 +45,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ template __device__ __forceinline__ T warp_reduce(volatile T *ptr , const unsigned int tid = threadIdx.x) { @@ -63,6 +65,7 @@ namespace cv { namespace cuda { namespace device return ptr[tid - lane]; } +//! @} }}} // namespace cv { namespace cuda { namespace cudev { #endif /* OPENCV_CUDA_WARP_REDUCE_HPP__ */ diff --git a/modules/core/include/opencv2/core/cuda/warp_shuffle.hpp b/modules/core/include/opencv2/core/cuda/warp_shuffle.hpp index e75e741395..f614946730 100644 --- a/modules/core/include/opencv2/core/cuda/warp_shuffle.hpp +++ b/modules/core/include/opencv2/core/cuda/warp_shuffle.hpp @@ -45,6 +45,8 @@ namespace cv { namespace cuda { namespace device { +//! @addtogroup cuda +//! @{ template __device__ __forceinline__ T shfl(T val, int srcLane, int width = warpSize) { @@ -140,6 +142,7 @@ namespace cv { namespace cuda { namespace device return 0.0; #endif } +//! @} }}} #endif // __OPENCV_CUDA_WARP_SHUFFLE_HPP__ diff --git a/modules/core/include/opencv2/core/cuda_stream_accessor.hpp b/modules/core/include/opencv2/core/cuda_stream_accessor.hpp index 5b058fa45f..4eb4ba61ad 100644 --- a/modules/core/include/opencv2/core/cuda_stream_accessor.hpp +++ b/modules/core/include/opencv2/core/cuda_stream_accessor.hpp @@ -59,6 +59,10 @@ namespace cv { namespace cuda { + +//! @addtogroup cuda_struct +//! @{ + class Stream; class Event; @@ -71,6 +75,9 @@ namespace cv { CV_EXPORTS static cudaEvent_t getEvent(const Event& event); }; + +//! @} + } } diff --git a/modules/core/include/opencv2/core/cuda_types.hpp b/modules/core/include/opencv2/core/cuda_types.hpp index a82f8ac738..ec67ae08ba 100644 --- a/modules/core/include/opencv2/core/cuda_types.hpp +++ b/modules/core/include/opencv2/core/cuda_types.hpp @@ -57,6 +57,10 @@ namespace cv { namespace cuda { + +//! @addtogroup cuda_struct +//! @{ + // Simple lightweight structures that encapsulates information about an image on device. // It is intended to pass to nvcc-compiled code. GpuMat depends on headers that nvcc can't compile @@ -120,6 +124,9 @@ namespace cv typedef PtrStep PtrStepb; typedef PtrStep PtrStepf; typedef PtrStep PtrStepi; + +//! @} + } } diff --git a/modules/core/include/opencv2/core/cvdef.h b/modules/core/include/opencv2/core/cvdef.h index 1f64cd2ace..482d97240b 100644 --- a/modules/core/include/opencv2/core/cvdef.h +++ b/modules/core/include/opencv2/core/cvdef.h @@ -358,6 +358,14 @@ typedef signed char schar; # include "tegra_round.hpp" #endif +//! @addtogroup core_utils +//! @{ + +/** @brief Rounds floating-point number to the nearest integer + +@param value floating-point number. If the value is outside of INT_MIN ... INT_MAX range, the +result is not defined. + */ CV_INLINE int cvRound( double value ) { #if ((defined _MSC_VER && defined _M_X64) || (defined __GNUC__ && defined __x86_64__ && defined __SSE2__ && !defined __APPLE__)) && !defined(__CUDACC__) @@ -389,6 +397,13 @@ CV_INLINE int cvRound( double value ) #endif } +/** @brief Rounds floating-point number to the nearest integer not larger than the original. + +The function computes an integer i such that: +\f[i \le \texttt{value} < i+1\f] +@param value floating-point number. If the value is outside of INT_MIN ... INT_MAX range, the +result is not defined. + */ CV_INLINE int cvFloor( double value ) { #if (defined _MSC_VER && defined _M_X64 || (defined __GNUC__ && defined __SSE2__ && !defined __APPLE__)) && !defined(__CUDACC__) @@ -405,6 +420,13 @@ CV_INLINE int cvFloor( double value ) #endif } +/** @brief Rounds floating-point number to the nearest integer not larger than the original. + +The function computes an integer i such that: +\f[i \le \texttt{value} < i+1\f] +@param value floating-point number. If the value is outside of INT_MIN ... INT_MAX range, the +result is not defined. +*/ CV_INLINE int cvCeil( double value ) { #if (defined _MSC_VER && defined _M_X64 || (defined __GNUC__ && defined __SSE2__&& !defined __APPLE__)) && !defined(__CUDACC__) @@ -421,6 +443,12 @@ CV_INLINE int cvCeil( double value ) #endif } +/** @brief Determines if the argument is Not A Number. + +@param value The input floating-point value + +The function returns 1 if the argument is Not A Number (as defined by IEEE754 standard), 0 +otherwise. */ CV_INLINE int cvIsNaN( double value ) { union { uint64 u; double f; } ieee754; @@ -429,6 +457,12 @@ CV_INLINE int cvIsNaN( double value ) ((unsigned)ieee754.u != 0) > 0x7ff00000; } +/** @brief Determines if the argument is Infinity. + +@param value The input floating-point value + +The function returns 1 if the argument is a plus or minus infinity (as defined by IEEE754 standard) +and 0 otherwise. */ CV_INLINE int cvIsInf( double value ) { union { uint64 u; double f; } ieee754; @@ -437,6 +471,8 @@ CV_INLINE int cvIsInf( double value ) (unsigned)ieee754.u == 0; } +//! @} core_utils + /****************************************************************************************\ * exchange-add operation for atomic operations on reference counters * \****************************************************************************************/ diff --git a/modules/core/include/opencv2/core/cvstd.hpp b/modules/core/include/opencv2/core/cvstd.hpp index f15e6a9351..800357bd21 100644 --- a/modules/core/include/opencv2/core/cvstd.hpp +++ b/modules/core/include/opencv2/core/cvstd.hpp @@ -102,26 +102,26 @@ namespace cv namespace cv { -//////////////////////////// memory management functions //////////////////////////// +//! @addtogroup core_utils +//! @{ -/*! - Allocates memory buffer +//////////////////////////// memory management functions //////////////////////////// - This is specialized OpenCV memory allocation function that returns properly aligned memory buffers. - The usage is identical to malloc(). The allocated buffers must be freed with cv::fastFree(). - If there is not enough memory, the function calls cv::error(), which raises an exception. +/** @brief Allocates an aligned memory buffer. - \param bufSize buffer size in bytes - \return the allocated memory buffer. -*/ +The function allocates the buffer of the specified size and returns it. When the buffer size is 16 +bytes or more, the returned buffer is aligned to 16 bytes. +@param bufSize Allocated buffer size. + */ CV_EXPORTS void* fastMalloc(size_t bufSize); -/*! - Frees the memory allocated with cv::fastMalloc +/** @brief Deallocates a memory buffer. - This is the corresponding deallocation function for cv::fastMalloc(). - When ptr==NULL, the function has no effect. -*/ +The function deallocates the buffer allocated with fastMalloc . If NULL pointer is passed, the +function does nothing. C version of the function clears the pointer *pptr* to avoid problems with +double memory deallocation. +@param ptr Pointer to the allocated buffer. + */ CV_EXPORTS void fastFree(void* ptr); /*! @@ -158,6 +158,10 @@ public: size_type max_size() const { return cv::max(static_cast<_Tp>(-1)/sizeof(_Tp), 1); } }; +//! @} core_utils + +//! @cond IGNORED + namespace detail { @@ -188,102 +192,219 @@ struct DefaultDeleter void operator () (Y* p) const; }; -/* - A smart shared pointer class with reference counting. - - A Ptr stores a pointer and owns a (potentially different) pointer. - The stored pointer has type T and is the one returned by get() et al, - while the owned pointer can have any type and is the one deleted - when there are no more Ptrs that own it. You can't directly obtain the - owned pointer. - - The interface of this class is mostly a subset of that of C++11's - std::shared_ptr. +//! @endcond + +//! @addtogroup core_basic +//! @{ + +/** @brief Template class for smart pointers with shared ownership + +A Ptr\ pretends to be a pointer to an object of type T. Unlike an ordinary pointer, however, the +object will be automatically cleaned up once all Ptr instances pointing to it are destroyed. + +Ptr is similar to boost::shared_ptr that is part of the Boost library +() and std::shared_ptr from +the [C++11](http://en.wikipedia.org/wiki/C++11) standard. + +This class provides the following advantages: +- Default constructor, copy constructor, and assignment operator for an arbitrary C++ class or C + structure. For some objects, like files, windows, mutexes, sockets, and others, a copy + constructor or an assignment operator are difficult to define. For some other objects, like + complex classifiers in OpenCV, copy constructors are absent and not easy to implement. Finally, + some of complex OpenCV and your own data structures may be written in C. However, copy + constructors and default constructors can simplify programming a lot. Besides, they are often + required (for example, by STL containers). By using a Ptr to such an object instead of the + object itself, you automatically get all of the necessary constructors and the assignment + operator. +- *O(1)* complexity of the above-mentioned operations. While some structures, like std::vector, + provide a copy constructor and an assignment operator, the operations may take a considerable + amount of time if the data structures are large. But if the structures are put into a Ptr, the + overhead is small and independent of the data size. +- Automatic and customizable cleanup, even for C structures. See the example below with FILE\*. +- Heterogeneous collections of objects. The standard STL and most other C++ and OpenCV containers + can store only objects of the same type and the same size. The classical solution to store + objects of different types in the same container is to store pointers to the base class (Base\*) + instead but then you lose the automatic memory management. Again, by using Ptr\ instead + of raw pointers, you can solve the problem. + +A Ptr is said to *own* a pointer - that is, for each Ptr there is a pointer that will be deleted +once all Ptr instances that own it are destroyed. The owned pointer may be null, in which case +nothing is deleted. Each Ptr also *stores* a pointer. The stored pointer is the pointer the Ptr +pretends to be; that is, the one you get when you use Ptr::get or the conversion to T\*. It's +usually the same as the owned pointer, but if you use casts or the general shared-ownership +constructor, the two may diverge: the Ptr will still own the original pointer, but will itself point +to something else. + +The owned pointer is treated as a black box. The only thing Ptr needs to know about it is how to +delete it. This knowledge is encapsulated in the *deleter* - an auxiliary object that is associated +with the owned pointer and shared between all Ptr instances that own it. The default deleter is an +instance of DefaultDeleter, which uses the standard C++ delete operator; as such it will work with +any pointer allocated with the standard new operator. + +However, if the pointer must be deleted in a different way, you must specify a custom deleter upon +Ptr construction. A deleter is simply a callable object that accepts the pointer as its sole +argument. For example, if you want to wrap FILE, you may do so as follows: +@code + Ptr f(fopen("myfile.txt", "w"), fclose); + if(!f) throw ...; + fprintf(f, ....); + ... + // the file will be closed automatically by f's destructor. +@endcode +Alternatively, if you want all pointers of a particular type to be deleted the same way, you can +specialize DefaultDeleter::operator() for that type, like this: +@code + namespace cv { + template<> void DefaultDeleter::operator ()(FILE * obj) const + { + fclose(obj); + } + } +@endcode +For convenience, the following types from the OpenCV C API already have such a specialization that +calls the appropriate release function: +- CvCapture +- CvFileStorage +- CvHaarClassifierCascade +- CvMat +- CvMatND +- CvMemStorage +- CvSparseMat +- CvVideoWriter +- IplImage +@note The shared ownership mechanism is implemented with reference counting. As such, cyclic +ownership (e.g. when object a contains a Ptr to object b, which contains a Ptr to object a) will +lead to all involved objects never being cleaned up. Avoid such situations. +@note It is safe to concurrently read (but not write) a Ptr instance from multiple threads and +therefore it is normally safe to use it in multi-threaded applications. The same is true for Mat and +other C++ OpenCV classes that use internal reference counts. */ template struct Ptr { - /* Generic programming support. */ + /** Generic programming support. */ typedef T element_type; - /* Ptr that owns NULL and stores NULL. */ + /** The default constructor creates a null Ptr - one that owns and stores a null pointer. + */ Ptr(); - /* Ptr that owns p and stores p. The owned pointer will be deleted with - DefaultDeleter. Y must be a complete type and Y* must be - convertible to T*. */ + /** + If p is null, these are equivalent to the default constructor. + Otherwise, these constructors assume ownership of p - that is, the created Ptr owns and stores p + and assumes it is the sole owner of it. Don't use them if p is already owned by another Ptr, or + else p will get deleted twice. + With the first constructor, DefaultDeleter\() becomes the associated deleter (so p will + eventually be deleted with the standard delete operator). Y must be a complete type at the point + of invocation. + With the second constructor, d becomes the associated deleter. + Y\* must be convertible to T\*. + @param p Pointer to own. + @note It is often easier to use makePtr instead. + */ template explicit Ptr(Y* p); - /* Ptr that owns p and stores p. The owned pointer will be deleted by - calling d(p). Y* must be convertible to T*. */ + /** @overload + @param d Deleter to use for the owned pointer. + @param p Pointer to own. + */ template Ptr(Y* p, D d); - /* Same as the constructor below; it exists to suppress the generation - of the implicit copy constructor. */ + /** + These constructors create a Ptr that shares ownership with another Ptr - that is, own the same + pointer as o. + With the first two, the same pointer is stored, as well; for the second, Y\* must be convertible + to T\*. + With the third, p is stored, and Y may be any type. This constructor allows to have completely + unrelated owned and stored pointers, and should be used with care to avoid confusion. A relatively + benign use is to create a non-owning Ptr, like this: + @code + ptr = Ptr(Ptr(), dont_delete_me); // owns nothing; will not delete the pointer. + @endcode + @param o Ptr to share ownership with. + */ Ptr(const Ptr& o); - /* Ptr that owns the same pointer as o and stores the same pointer as o, - converted to T*. Naturally, Y* must be convertible to T*. */ + /** @overload + @param o Ptr to share ownership with. + */ template Ptr(const Ptr& o); - /* Ptr that owns same pointer as o, and stores p. Useful for casts and - creating non-owning Ptrs. */ + /** @overload + @param o Ptr to share ownership with. + @param p Pointer to store. + */ template Ptr(const Ptr& o, T* p); - /* Equivalent to release(). */ + /** The destructor is equivalent to calling Ptr::release. */ ~Ptr(); - /* Same as assignment below; exists to suppress the generation of the - implicit assignment operator. */ + /** + Assignment replaces the current Ptr instance with one that owns and stores same pointers as o and + then destroys the old instance. + @param o Ptr to share ownership with. + */ Ptr& operator = (const Ptr& o); + /** @overload */ template Ptr& operator = (const Ptr& o); - /* Resets both the owned and stored pointers to NULL. Deletes the owned - pointer with the associated deleter if it's not owned by any other - Ptr and is non-zero. It's called reset() in std::shared_ptr; here - it is release() for compatibility with old OpenCV versions. */ + /** If no other Ptr instance owns the owned pointer, deletes it with the associated deleter. Then sets + both the owned and the stored pointers to NULL. + */ void release(); - /* Equivalent to assigning from Ptr(p). */ + /** + `ptr.reset(...)` is equivalent to `ptr = Ptr(...)`. + @param p Pointer to own. + */ template void reset(Y* p); - /* Equivalent to assigning from Ptr(p, d). */ + /** @overload + @param d Deleter to use for the owned pointer. + @param p Pointer to own. + */ template void reset(Y* p, D d); - /* Swaps the stored and owned pointers of this and o. */ + /** + Swaps the owned and stored pointers (and deleters, if any) of this and o. + @param o Ptr to swap with. + */ void swap(Ptr& o); - /* Returns the stored pointer. */ + /** Returns the stored pointer. */ T* get() const; - /* Ordinary pointer emulation. */ + /** Ordinary pointer emulation. */ typename detail::RefOrVoid::type operator * () const; + + /** Ordinary pointer emulation. */ T* operator -> () const; - /* Equivalent to get(). */ + /** Equivalent to get(). */ operator T* () const; - /* Equivalent to !*this. */ + /** ptr.empty() is equivalent to `!ptr.get()`. */ bool empty() const; - /* Returns a Ptr that owns the same pointer as this, and stores the same - pointer as this, except converted via static_cast to Y*. */ + /** Returns a Ptr that owns the same pointer as this, and stores the same + pointer as this, except converted via static_cast to Y*. + */ template Ptr staticCast() const; - /* Ditto for const_cast. */ + /** Ditto for const_cast. */ template Ptr constCast() const; - /* Ditto for dynamic_cast. */ + /** Ditto for dynamic_cast. */ template Ptr dynamicCast() const; @@ -295,41 +416,55 @@ private: friend struct Ptr; // have to do this for the cross-type copy constructor }; -/* Overload of the generic swap. */ +/** Equivalent to ptr1.swap(ptr2). Provided to help write generic algorithms. */ template void swap(Ptr& ptr1, Ptr& ptr2); -/* Obvious comparisons. */ +/** Return whether ptr1.get() and ptr2.get() are equal and not equal, respectively. */ template bool operator == (const Ptr& ptr1, const Ptr& ptr2); template bool operator != (const Ptr& ptr1, const Ptr& ptr2); -/* Convenience creation functions. In the far future, there may be variadic templates here. */ +/** `makePtr(...)` is equivalent to `Ptr(new T(...))`. It is shorter than the latter, and it's +marginally safer than using a constructor or Ptr::reset, since it ensures that the owned pointer +is new and thus not owned by any other Ptr instance. +Unfortunately, perfect forwarding is impossible to implement in C++03, and so makePtr is limited +to constructors of T that have up to 10 arguments, none of which are non-const references. + */ template Ptr makePtr(); +/** @overload */ template Ptr makePtr(const A1& a1); +/** @overload */ template Ptr makePtr(const A1& a1, const A2& a2); +/** @overload */ template Ptr makePtr(const A1& a1, const A2& a2, const A3& a3); +/** @overload */ template Ptr makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4); +/** @overload */ template Ptr makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5); +/** @overload */ template Ptr makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6); +/** @overload */ template Ptr makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7); +/** @overload */ template Ptr makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8); +/** @overload */ template Ptr makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9); +/** @overload */ template Ptr makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10); - //////////////////////////////// string class //////////////////////////////// class CV_EXPORTS FileNode; //for string constructor from FileNode @@ -435,9 +570,12 @@ private: void deallocate(); }; +//! @} core_basic ////////////////////////// cv::String implementation ///////////////////////// +//! @cond IGNORED + inline String::String() : cstr_(0), len_(0) @@ -815,8 +953,13 @@ String String::toLowerCase() const return res; } +//! @endcond + // ************************* cv::String non-member functions ************************* +//! @relates cv::String +//! @{ + inline String operator + (const String& lhs, const String& rhs) { @@ -888,6 +1031,8 @@ static inline bool operator>= (const String& lhs, const String& rhs) { return lh static inline bool operator>= (const char* lhs, const String& rhs) { return rhs.compare(lhs) <= 0; } static inline bool operator>= (const String& lhs, const char* rhs) { return lhs.compare(rhs) >= 0; } +//! @} relates cv::String + } // cv #ifndef OPENCV_NOSTL_TRANSITIONAL diff --git a/modules/core/include/opencv2/core/cvstd.inl.hpp b/modules/core/include/opencv2/core/cvstd.inl.hpp index 724f2f3815..03bac3729c 100644 --- a/modules/core/include/opencv2/core/cvstd.inl.hpp +++ b/modules/core/include/opencv2/core/cvstd.inl.hpp @@ -49,6 +49,8 @@ # include #endif +//! @cond IGNORED + namespace cv { #ifndef OPENCV_NOSTL @@ -260,4 +262,6 @@ std::ostream& operator << (std::ostream& out, const Rect_<_Tp>& rect) #endif // OPENCV_NOSTL } // cv +//! @endcond + #endif // __OPENCV_CORE_CVSTDINL_HPP__ diff --git a/modules/core/include/opencv2/core/directx.hpp b/modules/core/include/opencv2/core/directx.hpp index d7e38a12a1..837548e51b 100644 --- a/modules/core/include/opencv2/core/directx.hpp +++ b/modules/core/include/opencv2/core/directx.hpp @@ -61,19 +61,28 @@ struct IDirect3DDevice9Ex; struct IDirect3DSurface9; #endif + namespace cv { namespace directx { namespace ocl { using namespace cv::ocl; +//! @addtogroup core_directx +//! @{ + // TODO static functions in the Context class CV_EXPORTS Context& initializeContextFromD3D11Device(ID3D11Device* pD3D11Device); CV_EXPORTS Context& initializeContextFromD3D10Device(ID3D10Device* pD3D10Device); CV_EXPORTS Context& initializeContextFromDirect3DDevice9Ex(IDirect3DDevice9Ex* pDirect3DDevice9Ex); CV_EXPORTS Context& initializeContextFromDirect3DDevice9(IDirect3DDevice9* pDirect3DDevice9); +//! @} + } // namespace cv::directx::ocl +//! @addtogroup core_directx +//! @{ + CV_EXPORTS void convertToD3D11Texture2D(InputArray src, ID3D11Texture2D* pD3D11Texture2D); CV_EXPORTS void convertFromD3D11Texture2D(ID3D11Texture2D* pD3D11Texture2D, OutputArray dst); @@ -89,6 +98,7 @@ CV_EXPORTS int getTypeFromDXGI_FORMAT(const int iDXGI_FORMAT); // enum DXGI_FORM // Get OpenCV type from DirectX type, return -1 if there is no equivalent CV_EXPORTS int getTypeFromD3DFORMAT(const int iD3DFORMAT); // enum D3DTYPE for D3D9 +//! @} } } // namespace cv::directx diff --git a/modules/core/include/opencv2/core/eigen.hpp b/modules/core/include/opencv2/core/eigen.hpp index 3005bfbfd4..44df04c506 100644 --- a/modules/core/include/opencv2/core/eigen.hpp +++ b/modules/core/include/opencv2/core/eigen.hpp @@ -56,6 +56,9 @@ namespace cv { +//! @addtogroup core_eigen +//! @{ + template static inline void eigen2cv( const Eigen::Matrix<_Tp, _rows, _cols, _options, _maxRows, _maxCols>& src, Mat& dst ) { @@ -270,6 +273,8 @@ void cv2eigen( const Matx<_Tp, 1, _cols>& src, } } +//! @} + } // cv #endif diff --git a/modules/core/include/opencv2/core/ippasync.hpp b/modules/core/include/opencv2/core/ippasync.hpp index e40a0aa2f1..2fce5d5b93 100644 --- a/modules/core/include/opencv2/core/ippasync.hpp +++ b/modules/core/include/opencv2/core/ippasync.hpp @@ -12,7 +12,16 @@ namespace cv namespace hpp { - //convert OpenCV data type to hppDataType + +/** @addtogroup core_ipp +This section describes conversion between OpenCV and [Intel® IPP Asynchronous +C/C++](http://software.intel.com/en-us/intel-ipp-preview) library. [Getting Started +Guide](http://registrationcenter.intel.com/irc_nas/3727/ipp_async_get_started.htm) help you to +install the library, configure header and library build paths. + */ +//! @{ + + //! convert OpenCV data type to hppDataType inline int toHppType(const int cvType) { int depth = CV_MAT_DEPTH(cvType); @@ -26,7 +35,7 @@ namespace hpp return hppType; } - //convert hppDataType to OpenCV data type + //! convert hppDataType to OpenCV data type inline int toCvType(const int hppType) { int cvType = hppType == HPP_DATA_TYPE_8U ? CV_8U : @@ -39,6 +48,15 @@ namespace hpp return cvType; } + /** @brief Convert hppiMatrix to Mat. + + This function allocates and initializes new matrix (if needed) that has the same size and type as + input matrix. Supports CV_8U, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F. + @param src input hppiMatrix. + @param dst output matrix. + @param accel accelerator instance (see hpp::getHpp for the list of acceleration framework types). + @param cn number of channels. + */ inline void copyHppToMat(hppiMatrix* src, Mat& dst, hppAccel accel, int cn) { hppDataType type; @@ -67,7 +85,15 @@ namespace hpp CV_Assert( sts == HPP_STATUS_NO_ERROR); } - //create cv::Mat from hppiMatrix + /** @brief Create Mat from hppiMatrix. + + This function allocates and initializes the Mat that has the same size and type as input matrix. + Supports CV_8U, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F. + @param src input hppiMatrix. + @param accel accelerator instance (see hpp::getHpp for the list of acceleration framework types). + @param cn number of channels. + @sa howToUseIPPAconversion, hpp::copyHppToMat, hpp::getHpp. + */ inline Mat getMat(hppiMatrix* src, hppAccel accel, int cn) { Mat dst; @@ -75,7 +101,26 @@ namespace hpp return dst; } - //create hppiMatrix from cv::Mat + /** @brief Create hppiMatrix from Mat. + + This function allocates and initializes the hppiMatrix that has the same size and type as input + matrix, returns the hppiMatrix*. + + If you want to use zero-copy for GPU you should to have 4KB aligned matrix data. See details + [hppiCreateSharedMatrix](http://software.intel.com/ru-ru/node/501697). + + Supports CV_8U, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F. + + @note The hppiMatrix pointer to the image buffer in system memory refers to the src.data. Control + the lifetime of the matrix and don't change its data, if there is no special need. + @param src input matrix. + @param accel accelerator instance. Supports type: + - **HPP_ACCEL_TYPE_CPU** - accelerated by optimized CPU instructions. + - **HPP_ACCEL_TYPE_GPU** - accelerated by GPU programmable units or fixed-function + accelerators. + - **HPP_ACCEL_TYPE_ANY** - any acceleration or no acceleration available. + @sa howToUseIPPAconversion, hpp::getMat + */ inline hppiMatrix* getHpp(const Mat& src, hppAccel accel) { int htype = toHppType(src.type()); @@ -98,8 +143,9 @@ namespace hpp return hppiCreateMatrix(htype, src.cols*cn, src.rows, src.data, (hpp32s)(src.step));; } +//! @} }} #endif -#endif \ No newline at end of file +#endif diff --git a/modules/core/include/opencv2/core/mat.hpp b/modules/core/include/opencv2/core/mat.hpp index cc589a0675..2e4abf4030 100644 --- a/modules/core/include/opencv2/core/mat.hpp +++ b/modules/core/include/opencv2/core/mat.hpp @@ -56,6 +56,9 @@ namespace cv { +//! @addtogroup core_basic +//! @{ + enum { ACCESS_READ=1<<24, ACCESS_WRITE=1<<25, ACCESS_RW=3<<24, ACCESS_MASK=ACCESS_RW, ACCESS_FAST=1<<26 }; @@ -63,8 +66,82 @@ class CV_EXPORTS _OutputArray; //////////////////////// Input/Output Array Arguments ///////////////////////////////// -/*! - Proxy datatype for passing Mat's and vector<>'s as input parameters +/** @brief This is the proxy class for passing read-only input arrays into OpenCV functions. + +It is defined as: +@code + typedef const _InputArray& InputArray; +@endcode +where _InputArray is a class that can be constructed from `Mat`, `Mat_`, `Matx`, +`std::vector`, `std::vector >` or `std::vector`. It can also be constructed +from a matrix expression. + +Since this is mostly implementation-level class, and its interface may change in future versions, we +do not describe it in details. There are a few key things, though, that should be kept in mind: + +- When you see in the reference manual or in OpenCV source code a function that takes + InputArray, it means that you can actually pass `Mat`, `Matx`, `vector` etc. (see above the + complete list). +- Optional input arguments: If some of the input arrays may be empty, pass cv::noArray() (or + simply cv::Mat() as you probably did before). +- The class is designed solely for passing parameters. That is, normally you *should not* + declare class members, local and global variables of this type. +- If you want to design your own function or a class method that can operate of arrays of + multiple types, you can use InputArray (or OutputArray) for the respective parameters. Inside + a function you should use _InputArray::getMat() method to construct a matrix header for the + array (without copying data). _InputArray::kind() can be used to distinguish Mat from + `vector<>` etc., but normally it is not needed. + +Here is how you can use a function that takes InputArray : +@code + std::vector vec; + // points or a circle + for( int i = 0; i < 30; i++ ) + vec.push_back(Point2f((float)(100 + 30*cos(i*CV_PI*2/5)), + (float)(100 - 30*sin(i*CV_PI*2/5)))); + cv::transform(vec, vec, cv::Matx23f(0.707, -0.707, 10, 0.707, 0.707, 20)); +@endcode +That is, we form an STL vector containing points, and apply in-place affine transformation to the +vector using the 2x3 matrix created inline as `Matx` instance. + +Here is how such a function can be implemented (for simplicity, we implement a very specific case of +it, according to the assertion statement inside) : +@code + void myAffineTransform(InputArray _src, OutputArray _dst, InputArray _m) + { + // get Mat headers for input arrays. This is O(1) operation, + // unless _src and/or _m are matrix expressions. + Mat src = _src.getMat(), m = _m.getMat(); + CV_Assert( src.type() == CV_32FC2 && m.type() == CV_32F && m.size() == Size(3, 2) ); + + // [re]create the output array so that it has the proper size and type. + // In case of Mat it calls Mat::create, in case of STL vector it calls vector::resize. + _dst.create(src.size(), src.type()); + Mat dst = _dst.getMat(); + + for( int i = 0; i < src.rows; i++ ) + for( int j = 0; j < src.cols; j++ ) + { + Point2f pt = src.at(i, j); + dst.at(i, j) = Point2f(m.at(0, 0)*pt.x + + m.at(0, 1)*pt.y + + m.at(0, 2), + m.at(1, 0)*pt.x + + m.at(1, 1)*pt.y + + m.at(1, 2)); + } + } +@endcode +There is another related type, InputArrayOfArrays, which is currently defined as a synonym for +InputArray: +@code + typedef InputArray InputArrayOfArrays; +@endcode +It denotes function arguments that are either vectors of vectors or vectors of matrices. A separate +synonym is needed to generate Python/Java etc. wrappers properly. At the function implementation +level their use is similar, but _InputArray::getMat(idx) should be used to get header for the +idx-th component of the outer vector and _InputArray::size().area() should be used to find the +number of components (vectors/matrices) of the outer vector. */ class CV_EXPORTS _InputArray { @@ -152,8 +229,30 @@ protected: }; -/*! - Proxy datatype for passing Mat's and vector<>'s as input parameters +/** @brief This type is very similar to InputArray except that it is used for input/output and output function +parameters. + +Just like with InputArray, OpenCV users should not care about OutputArray, they just pass `Mat`, +`vector` etc. to the functions. The same limitation as for `InputArray`: *Do not explicitly +create OutputArray instances* applies here too. + +If you want to make your function polymorphic (i.e. accept different arrays as output parameters), +it is also not very difficult. Take the sample above as the reference. Note that +_OutputArray::create() needs to be called before _OutputArray::getMat(). This way you guarantee +that the output array is properly allocated. + +Optional output parameters. If you do not need certain output array to be computed and returned to +you, pass cv::noArray(), just like you would in the case of optional input array. At the +implementation level, use _OutputArray::needed() to check if certain output array needs to be +computed or not. + +There are several synonyms for OutputArray that are used to assist automatic Python/Java/... wrapper +generators: +@code + typedef OutputArray OutputArrayOfArrays; + typedef OutputArray InputOutputArray; + typedef OutputArray InputOutputArrayOfArrays; +@endcode */ class CV_EXPORTS _OutputArray : public _InputArray { @@ -286,9 +385,7 @@ enum UMatUsageFlags struct CV_EXPORTS UMatData; -/*! - Custom array allocator - +/** @brief Custom array allocator */ class CV_EXPORTS MatAllocator { @@ -323,8 +420,7 @@ public: //////////////////////////////// MatCommaInitializer ////////////////////////////////// -/*! - Comma-separated Matrix Initializer +/** @brief Comma-separated Matrix Initializer The class instances are usually not created explicitly. Instead, they are created on "matrix << firstValue" operator. @@ -429,255 +525,399 @@ protected: MatStep& operator = (const MatStep&); }; - /*! - The n-dimensional matrix class. - - The class represents an n-dimensional dense numerical array that can act as - a matrix, image, optical flow map, 3-focal tensor etc. - It is very similar to CvMat and CvMatND types from earlier versions of OpenCV, - and similarly to those types, the matrix can be multi-channel. It also fully supports ROI mechanism. - - There are many different ways to create cv::Mat object. Here are the some popular ones: -
    -
  • using cv::Mat::create(nrows, ncols, type) method or - the similar constructor cv::Mat::Mat(nrows, ncols, type[, fill_value]) constructor. - A new matrix of the specified size and specifed type will be allocated. - "type" has the same meaning as in cvCreateMat function, - e.g. CV_8UC1 means 8-bit single-channel matrix, CV_32FC2 means 2-channel (i.e. complex) - floating-point matrix etc: - - \code - // make 7x7 complex matrix filled with 1+3j. - cv::Mat M(7,7,CV_32FC2,Scalar(1,3)); - // and now turn M to 100x60 15-channel 8-bit matrix. - // The old content will be deallocated - M.create(100,60,CV_8UC(15)); - \endcode - - As noted in the introduction of this chapter, Mat::create() - will only allocate a new matrix when the current matrix dimensionality - or type are different from the specified. - -
  • by using a copy constructor or assignment operator, where on the right side it can - be a matrix or expression, see below. Again, as noted in the introduction, - matrix assignment is O(1) operation because it only copies the header - and increases the reference counter. cv::Mat::clone() method can be used to get a full - (a.k.a. deep) copy of the matrix when you need it. - -
  • by constructing a header for a part of another matrix. It can be a single row, single column, - several rows, several columns, rectangular region in the matrix (called a minor in algebra) or - a diagonal. Such operations are also O(1), because the new header will reference the same data. - You can actually modify a part of the matrix using this feature, e.g. - - \code - // add 5-th row, multiplied by 3 to the 3rd row - M.row(3) = M.row(3) + M.row(5)*3; - - // now copy 7-th column to the 1-st column - // M.col(1) = M.col(7); // this will not work - Mat M1 = M.col(1); - M.col(7).copyTo(M1); - - // create new 320x240 image - cv::Mat img(Size(320,240),CV_8UC3); - // select a roi - cv::Mat roi(img, Rect(10,10,100,100)); - // fill the ROI with (0,255,0) (which is green in RGB space); - // the original 320x240 image will be modified - roi = Scalar(0,255,0); - \endcode - - Thanks to the additional cv::Mat::datastart and cv::Mat::dataend members, it is possible to - compute the relative sub-matrix position in the main "container" matrix using cv::Mat::locateROI(): - - \code - Mat A = Mat::eye(10, 10, CV_32S); - // extracts A columns, 1 (inclusive) to 3 (exclusive). - Mat B = A(Range::all(), Range(1, 3)); - // extracts B rows, 5 (inclusive) to 9 (exclusive). - // that is, C ~ A(Range(5, 9), Range(1, 3)) - Mat C = B(Range(5, 9), Range::all()); - Size size; Point ofs; - C.locateROI(size, ofs); - // size will be (width=10,height=10) and the ofs will be (x=1, y=5) - \endcode - - As in the case of whole matrices, if you need a deep copy, use cv::Mat::clone() method - of the extracted sub-matrices. - -
  • by making a header for user-allocated-data. It can be useful for -
      -
    1. processing "foreign" data using OpenCV (e.g. when you implement - a DirectShow filter or a processing module for gstreamer etc.), e.g. - - \code - void process_video_frame(const unsigned char* pixels, - int width, int height, int step) - { - cv::Mat img(height, width, CV_8UC3, pixels, step); - cv::GaussianBlur(img, img, cv::Size(7,7), 1.5, 1.5); - } - \endcode - -
    2. for quick initialization of small matrices and/or super-fast element access - - \code - double m[3][3] = {{a, b, c}, {d, e, f}, {g, h, i}}; - cv::Mat M = cv::Mat(3, 3, CV_64F, m).inv(); - \endcode -
    - - partial yet very common cases of this "user-allocated data" case are conversions - from CvMat and IplImage to cv::Mat. For this purpose there are special constructors - taking pointers to CvMat or IplImage and the optional - flag indicating whether to copy the data or not. - - Backward conversion from cv::Mat to CvMat or IplImage is provided via cast operators - cv::Mat::operator CvMat() an cv::Mat::operator IplImage(). - The operators do not copy the data. - - - \code - IplImage* img = cvLoadImage("greatwave.jpg", 1); - Mat mtx(img); // convert IplImage* -> cv::Mat - CvMat oldmat = mtx; // convert cv::Mat -> CvMat - CV_Assert(oldmat.cols == img->width && oldmat.rows == img->height && - oldmat.data.ptr == (uchar*)img->imageData && oldmat.step == img->widthStep); - \endcode - -
  • by using MATLAB-style matrix initializers, cv::Mat::zeros(), cv::Mat::ones(), cv::Mat::eye(), e.g.: - - \code - // create a double-precision identity martix and add it to M. - M += Mat::eye(M.rows, M.cols, CV_64F); - \endcode - -
  • by using comma-separated initializer: - - \code - // create 3x3 double-precision identity matrix - Mat M = (Mat_(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1); - \endcode - - here we first call constructor of cv::Mat_ class (that we describe further) with the proper matrix, - and then we just put "<<" operator followed by comma-separated values that can be constants, - variables, expressions etc. Also, note the extra parentheses that are needed to avoid compiler errors. - -
- - Once matrix is created, it will be automatically managed by using reference-counting mechanism - (unless the matrix header is built on top of user-allocated data, - in which case you should handle the data by yourself). - The matrix data will be deallocated when no one points to it; - if you want to release the data pointed by a matrix header before the matrix destructor is called, - use cv::Mat::release(). - - The next important thing to learn about the matrix class is element access. Here is how the matrix is stored. - The elements are stored in row-major order (row by row). The cv::Mat::data member points to the first element of the first row, - cv::Mat::rows contains the number of matrix rows and cv::Mat::cols - the number of matrix columns. There is yet another member, - cv::Mat::step that is used to actually compute address of a matrix element. cv::Mat::step is needed because the matrix can be - a part of another matrix or because there can some padding space in the end of each row for a proper alignment. - - Given these parameters, address of the matrix element M_{ij} is computed as following: - - addr(M_{ij})=M.data + M.step*i + j*M.elemSize() - - if you know the matrix element type, e.g. it is float, then you can use cv::Mat::at() method: - - addr(M_{ij})=&M.at(i,j) - - (where & is used to convert the reference returned by cv::Mat::at() to a pointer). - if you need to process a whole row of matrix, the most efficient way is to get - the pointer to the row first, and then just use plain C operator []: - - \code - // compute sum of positive matrix elements - // (assuming that M is double-precision matrix) - double sum=0; - for(int i = 0; i < M.rows; i++) - { - const double* Mi = M.ptr(i); - for(int j = 0; j < M.cols; j++) - sum += std::max(Mi[j], 0.); - } - \endcode - - Some operations, like the above one, do not actually depend on the matrix shape, - they just process elements of a matrix one by one (or elements from multiple matrices - that are sitting in the same place, e.g. matrix addition). Such operations are called - element-wise and it makes sense to check whether all the input/output matrices are continuous, - i.e. have no gaps in the end of each row, and if yes, process them as a single long row: - - \code - // compute sum of positive matrix elements, optimized variant - double sum=0; - int cols = M.cols, rows = M.rows; - if(M.isContinuous()) - { - cols *= rows; - rows = 1; - } - for(int i = 0; i < rows; i++) - { - const double* Mi = M.ptr(i); - for(int j = 0; j < cols; j++) - sum += std::max(Mi[j], 0.); - } - \endcode - in the case of continuous matrix the outer loop body will be executed just once, - so the overhead will be smaller, which will be especially noticeable in the case of small matrices. - - Finally, there are STL-style iterators that are smart enough to skip gaps between successive rows: - \code - // compute sum of positive matrix elements, iterator-based variant - double sum=0; - MatConstIterator_ it = M.begin(), it_end = M.end(); - for(; it != it_end; ++it) - sum += std::max(*it, 0.); - \endcode - - The matrix iterators are random-access iterators, so they can be passed - to any STL algorithm, including std::sort(). +/** @example cout_mat.cpp +An example demonstrating the serial out capabilities of cv::Mat +*/ + + /** @brief n-dimensional dense array class + +The class Mat represents an n-dimensional dense numerical single-channel or multi-channel array. It +can be used to store real or complex-valued vectors and matrices, grayscale or color images, voxel +volumes, vector fields, point clouds, tensors, histograms (though, very high-dimensional histograms +may be better stored in a SparseMat ). The data layout of the array `M` is defined by the array +`M.step[]`, so that the address of element \f$(i_0,...,i_{M.dims-1})\f$, where \f$0\leq i_k= M.step[i+1]` (in fact, `M.step[i] >= M.step[i+1]*M.size[i+1]` ). This means +that 2-dimensional matrices are stored row-by-row, 3-dimensional matrices are stored plane-by-plane, +and so on. M.step[M.dims-1] is minimal and always equal to the element size M.elemSize() . + +So, the data layout in Mat is fully compatible with CvMat, IplImage, and CvMatND types from OpenCV +1.x. It is also compatible with the majority of dense array types from the standard toolkits and +SDKs, such as Numpy (ndarray), Win32 (independent device bitmaps), and others, that is, with any +array that uses *steps* (or *strides*) to compute the position of a pixel. Due to this +compatibility, it is possible to make a Mat header for user-allocated data and process it in-place +using OpenCV functions. + +There are many different ways to create a Mat object. The most popular options are listed below: + +- Use the create(nrows, ncols, type) method or the similar Mat(nrows, ncols, type[, fillValue]) +constructor. A new array of the specified size and type is allocated. type has the same meaning as +in the cvCreateMat method. For example, CV_8UC1 means a 8-bit single-channel array, CV_32FC2 +means a 2-channel (complex) floating-point array, and so on. +@code + // make a 7x7 complex matrix filled with 1+3j. + Mat M(7,7,CV_32FC2,Scalar(1,3)); + // and now turn M to a 100x60 15-channel 8-bit matrix. + // The old content will be deallocated + M.create(100,60,CV_8UC(15)); +@endcode +As noted in the introduction to this chapter, create() allocates only a new array when the shape +or type of the current array are different from the specified ones. + +- Create a multi-dimensional array: +@code + // create a 100x100x100 8-bit array + int sz[] = {100, 100, 100}; + Mat bigCube(3, sz, CV_8U, Scalar::all(0)); +@endcode +It passes the number of dimensions =1 to the Mat constructor but the created array will be +2-dimensional with the number of columns set to 1. So, Mat::dims is always \>= 2 (can also be 0 +when the array is empty). + +- Use a copy constructor or assignment operator where there can be an array or expression on the +right side (see below). As noted in the introduction, the array assignment is an O(1) operation +because it only copies the header and increases the reference counter. The Mat::clone() method can +be used to get a full (deep) copy of the array when you need it. + +- Construct a header for a part of another array. It can be a single row, single column, several +rows, several columns, rectangular region in the array (called a *minor* in algebra) or a +diagonal. Such operations are also O(1) because the new header references the same data. You can +actually modify a part of the array using this feature, for example: +@code + // add the 5-th row, multiplied by 3 to the 3rd row + M.row(3) = M.row(3) + M.row(5)*3; + // now copy the 7-th column to the 1-st column + // M.col(1) = M.col(7); // this will not work + Mat M1 = M.col(1); + M.col(7).copyTo(M1); + // create a new 320x240 image + Mat img(Size(320,240),CV_8UC3); + // select a ROI + Mat roi(img, Rect(10,10,100,100)); + // fill the ROI with (0,255,0) (which is green in RGB space); + // the original 320x240 image will be modified + roi = Scalar(0,255,0); +@endcode +Due to the additional datastart and dataend members, it is possible to compute a relative +sub-array position in the main *container* array using locateROI(): +@code + Mat A = Mat::eye(10, 10, CV_32S); + // extracts A columns, 1 (inclusive) to 3 (exclusive). + Mat B = A(Range::all(), Range(1, 3)); + // extracts B rows, 5 (inclusive) to 9 (exclusive). + // that is, C \~ A(Range(5, 9), Range(1, 3)) + Mat C = B(Range(5, 9), Range::all()); + Size size; Point ofs; + C.locateROI(size, ofs); + // size will be (width=10,height=10) and the ofs will be (x=1, y=5) +@endcode +As in case of whole matrices, if you need a deep copy, use the `clone()` method of the extracted +sub-matrices. + +- Make a header for user-allocated data. It can be useful to do the following: + -# Process "foreign" data using OpenCV (for example, when you implement a DirectShow\* filter or + a processing module for gstreamer, and so on). For example: + @code + void process_video_frame(const unsigned char* pixels, + int width, int height, int step) + { + Mat img(height, width, CV_8UC3, pixels, step); + GaussianBlur(img, img, Size(7,7), 1.5, 1.5); + } + @endcode + -# Quickly initialize small matrices and/or get a super-fast element access. + @code + double m[3][3] = {{a, b, c}, {d, e, f}, {g, h, i}}; + Mat M = Mat(3, 3, CV_64F, m).inv(); + @endcode + . +Partial yet very common cases of this *user-allocated data* case are conversions from CvMat and +IplImage to Mat. For this purpose, there are special constructors taking pointers to CvMat or +IplImage and the optional flag indicating whether to copy the data or not. Backward conversion from +Mat to CvMat or IplImage is provided via cast operators Mat::operator CvMat() const and +Mat::operator IplImage(). The operators do NOT copy the data. +@code + IplImage* img = cvLoadImage("greatwave.jpg", 1); + Mat mtx(img); // convert IplImage* -> Mat + CvMat oldmat = mtx; // convert Mat -> CvMat + CV_Assert(oldmat.cols == img->width && oldmat.rows == img->height && + oldmat.data.ptr == (uchar*)img->imageData && oldmat.step == img->widthStep); +@endcode + +- Use MATLAB-style array initializers, zeros(), ones(), eye(), for example: +@code + // create a double-precision identity martix and add it to M. + M += Mat::eye(M.rows, M.cols, CV_64F); +@endcode + +- Use a comma-separated initializer: +@code + // create a 3x3 double-precision identity matrix + Mat M = (Mat_(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1); +@endcode +With this approach, you first call a constructor of the Mat class with the proper parameters, and +then you just put `<< operator` followed by comma-separated values that can be constants, +variables, expressions, and so on. Also, note the extra parentheses required to avoid compilation +errors. + +Once the array is created, it is automatically managed via a reference-counting mechanism. If the +array header is built on top of user-allocated data, you should handle the data by yourself. The +array data is deallocated when no one points to it. If you want to release the data pointed by a +array header before the array destructor is called, use Mat::release(). + +The next important thing to learn about the array class is element access. This manual already +described how to compute an address of each array element. Normally, you are not required to use the +formula directly in the code. If you know the array element type (which can be retrieved using the +method Mat::type() ), you can access the element \f$M_{ij}\f$ of a 2-dimensional array as: +@code + M.at(i,j) += 1.f; +@endcode +assuming that `M` is a double-precision floating-point array. There are several variants of the method +at for a different number of dimensions. + +If you need to process a whole row of a 2D array, the most efficient way is to get the pointer to +the row first, and then just use the plain C operator [] : +@code + // compute sum of positive matrix elements + // (assuming that M isa double-precision matrix) + double sum=0; + for(int i = 0; i < M.rows; i++) + { + const double* Mi = M.ptr(i); + for(int j = 0; j < M.cols; j++) + sum += std::max(Mi[j], 0.); + } +@endcode +Some operations, like the one above, do not actually depend on the array shape. They just process +elements of an array one by one (or elements from multiple arrays that have the same coordinates, +for example, array addition). Such operations are called *element-wise*. It makes sense to check +whether all the input/output arrays are continuous, namely, have no gaps at the end of each row. If +yes, process them as a long single row: +@code + // compute the sum of positive matrix elements, optimized variant + double sum=0; + int cols = M.cols, rows = M.rows; + if(M.isContinuous()) + { + cols *= rows; + rows = 1; + } + for(int i = 0; i < rows; i++) + { + const double* Mi = M.ptr(i); + for(int j = 0; j < cols; j++) + sum += std::max(Mi[j], 0.); + } +@endcode +In case of the continuous matrix, the outer loop body is executed just once. So, the overhead is +smaller, which is especially noticeable in case of small matrices. + +Finally, there are STL-style iterators that are smart enough to skip gaps between successive rows: +@code + // compute sum of positive matrix elements, iterator-based variant + double sum=0; + MatConstIterator_ it = M.begin(), it_end = M.end(); + for(; it != it_end; ++it) + sum += std::max(*it, 0.); +@endcode +The matrix iterators are random-access iterators, so they can be passed to any STL algorithm, +including std::sort(). */ class CV_EXPORTS Mat { public: - //! default constructor + /** + These are various constructors that form a matrix. As noted in the AutomaticAllocation, often + the default constructor is enough, and the proper matrix will be allocated by an OpenCV function. + The constructed matrix can further be assigned to another matrix or matrix expression or can be + allocated with Mat::create . In the former case, the old content is de-referenced. + */ Mat(); - //! constructs 2D matrix of the specified size and type - // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.) + + /** @overload + @param rows Number of rows in a 2D array. + @param cols Number of columns in a 2D array. + @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or + CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. + */ Mat(int rows, int cols, int type); + + /** @overload + @param size 2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the + number of columns go in the reverse order. + @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or + CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. + */ Mat(Size size, int type); - //! constucts 2D matrix and fills it with the specified value _s. + + /** @overload + @param rows Number of rows in a 2D array. + @param cols Number of columns in a 2D array. + @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or + CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. + @param s An optional value to initialize each matrix element with. To set all the matrix elements to + the particular value after the construction, use the assignment operator + Mat::operator=(const Scalar& value) . + */ Mat(int rows, int cols, int type, const Scalar& s); + + /** @overload + @param size 2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the + number of columns go in the reverse order. + @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or + CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. + @param s An optional value to initialize each matrix element with. To set all the matrix elements to + the particular value after the construction, use the assignment operator + Mat::operator=(const Scalar& value) . + */ Mat(Size size, int type, const Scalar& s); - //! constructs n-dimensional matrix + /** @overload + @param ndims Array dimensionality. + @param sizes Array of integers specifying an n-dimensional array shape. + @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or + CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. + */ Mat(int ndims, const int* sizes, int type); + + /** @overload + @param ndims Array dimensionality. + @param sizes Array of integers specifying an n-dimensional array shape. + @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or + CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. + @param s An optional value to initialize each matrix element with. To set all the matrix elements to + the particular value after the construction, use the assignment operator + Mat::operator=(const Scalar& value) . + */ Mat(int ndims, const int* sizes, int type, const Scalar& s); - //! copy constructor + /** @overload + @param m Array that (as a whole or partly) is assigned to the constructed matrix. No data is copied + by these constructors. Instead, the header pointing to m data or its sub-array is constructed and + associated with it. The reference counter, if any, is incremented. So, when you modify the matrix + formed using such a constructor, you also modify the corresponding elements of m . If you want to + have an independent copy of the sub-array, use Mat::clone() . + */ Mat(const Mat& m); - //! constructor for matrix headers pointing to user-allocated data + + /** @overload + @param rows Number of rows in a 2D array. + @param cols Number of columns in a 2D array. + @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or + CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. + @param data Pointer to the user data. Matrix constructors that take data and step parameters do not + allocate matrix data. Instead, they just initialize the matrix header that points to the specified + data, which means that no data is copied. This operation is very efficient and can be used to + process external data using OpenCV functions. The external data is not automatically deallocated, so + you should take care of it. + @param step Number of bytes each matrix row occupies. The value should include the padding bytes at + the end of each row, if any. If the parameter is missing (set to AUTO_STEP ), no padding is assumed + and the actual step is calculated as cols*elemSize(). See Mat::elemSize. + */ Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP); + + /** @overload + @param size 2D array size: Size(cols, rows) . In the Size() constructor, the number of rows and the + number of columns go in the reverse order. + @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or + CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. + @param data Pointer to the user data. Matrix constructors that take data and step parameters do not + allocate matrix data. Instead, they just initialize the matrix header that points to the specified + data, which means that no data is copied. This operation is very efficient and can be used to + process external data using OpenCV functions. The external data is not automatically deallocated, so + you should take care of it. + @param step Number of bytes each matrix row occupies. The value should include the padding bytes at + the end of each row, if any. If the parameter is missing (set to AUTO_STEP ), no padding is assumed + and the actual step is calculated as cols*elemSize(). See Mat::elemSize. + */ Mat(Size size, int type, void* data, size_t step=AUTO_STEP); + + /** @overload + @param ndims Array dimensionality. + @param sizes Array of integers specifying an n-dimensional array shape. + @param type Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or + CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. + @param data Pointer to the user data. Matrix constructors that take data and step parameters do not + allocate matrix data. Instead, they just initialize the matrix header that points to the specified + data, which means that no data is copied. This operation is very efficient and can be used to + process external data using OpenCV functions. The external data is not automatically deallocated, so + you should take care of it. + @param steps Array of ndims-1 steps in case of a multi-dimensional array (the last step is always + set to the element size). If not specified, the matrix is assumed to be continuous. + */ Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0); - //! creates a matrix header for a part of the bigger matrix + /** @overload + @param m Array that (as a whole or partly) is assigned to the constructed matrix. No data is copied + by these constructors. Instead, the header pointing to m data or its sub-array is constructed and + associated with it. The reference counter, if any, is incremented. So, when you modify the matrix + formed using such a constructor, you also modify the corresponding elements of m . If you want to + have an independent copy of the sub-array, use Mat::clone() . + @param rowRange Range of the m rows to take. As usual, the range start is inclusive and the range + end is exclusive. Use Range::all() to take all the rows. + @param colRange Range of the m columns to take. Use Range::all() to take all the columns. + */ Mat(const Mat& m, const Range& rowRange, const Range& colRange=Range::all()); + + /** @overload + @param m Array that (as a whole or partly) is assigned to the constructed matrix. No data is copied + by these constructors. Instead, the header pointing to m data or its sub-array is constructed and + associated with it. The reference counter, if any, is incremented. So, when you modify the matrix + formed using such a constructor, you also modify the corresponding elements of m . If you want to + have an independent copy of the sub-array, use Mat::clone() . + @param roi Region of interest. + */ Mat(const Mat& m, const Rect& roi); + + /** @overload + @param m Array that (as a whole or partly) is assigned to the constructed matrix. No data is copied + by these constructors. Instead, the header pointing to m data or its sub-array is constructed and + associated with it. The reference counter, if any, is incremented. So, when you modify the matrix + formed using such a constructor, you also modify the corresponding elements of m . If you want to + have an independent copy of the sub-array, use Mat::clone() . + @param ranges Array of selected ranges of m along each dimensionality. + */ Mat(const Mat& m, const Range* ranges); - //! builds matrix from std::vector with or without copying the data + + /** @overload + @param vec STL vector whose elements form the matrix. The matrix has a single column and the number + of rows equal to the number of vector elements. Type of the matrix matches the type of vector + elements. The constructor can handle arbitrary types, for which there is a properly declared + DataType . This means that the vector elements must be primitive numbers or uni-type numerical + tuples of numbers. Mixed-type structures are not supported. The corresponding constructor is + explicit. Since STL vectors are not automatically converted to Mat instances, you should write + Mat(vec) explicitly. Unless you copy the data into the matrix ( copyData=true ), no new elements + will be added to the vector because it can potentially yield vector data reallocation, and, thus, + the matrix data pointer will be invalid. + @param copyData Flag to specify whether the underlying data of the STL vector should be copied + to (true) or shared with (false) the newly constructed matrix. When the data is copied, the + allocated buffer is managed using Mat reference counting mechanism. While the data is shared, + the reference counter is NULL, and you should not deallocate the data until the matrix is not + destructed. + */ template explicit Mat(const std::vector<_Tp>& vec, bool copyData=false); - //! builds matrix from cv::Vec; the data is copied by default + + /** @overload + */ template explicit Mat(const Vec<_Tp, n>& vec, bool copyData=true); - //! builds matrix from cv::Matx; the data is copied by default + + /** @overload + */ template explicit Mat(const Matx<_Tp, m, n>& mtx, bool copyData=true); - //! builds matrix from a 2D point + + /** @overload + */ template explicit Mat(const Point_<_Tp>& pt, bool copyData=true); - //! builds matrix from a 3D point + + /** @overload + */ template explicit Mat(const Point3_<_Tp>& pt, bool copyData=true); - //! builds matrix from comma initializer + + /** @overload + */ template explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer); //! download data from GpuMat @@ -685,84 +925,422 @@ public: //! destructor - calls release() ~Mat(); - //! assignment operators + + /** @brief assignment operators + + These are available assignment operators. Since they all are very different, make sure to read the + operator parameters description. + @param m Assigned, right-hand-side matrix. Matrix assignment is an O(1) operation. This means that + no data is copied but the data is shared and the reference counter, if any, is incremented. Before + assigning new data, the old data is de-referenced via Mat::release . + */ Mat& operator = (const Mat& m); + + /** @overload + @param expr Assigned matrix expression object. As opposite to the first form of the assignment + operation, the second form can reuse already allocated matrix if it has the right size and type to + fit the matrix expression result. It is automatically handled by the real function that the matrix + expressions is expanded to. For example, C=A+B is expanded to add(A, B, C), and add takes care of + automatic C reallocation. + */ Mat& operator = (const MatExpr& expr); //! retrieve UMat from Mat UMat getUMat(int accessFlags, UMatUsageFlags usageFlags = USAGE_DEFAULT) const; - //! returns a new matrix header for the specified row + /** @brief Creates a matrix header for the specified matrix row. + + The method makes a new header for the specified matrix row and returns it. This is an O(1) + operation, regardless of the matrix size. The underlying data of the new matrix is shared with the + original matrix. Here is the example of one of the classical basic matrix processing operations, + axpy, used by LU and many other algorithms: + @code + inline void matrix_axpy(Mat& A, int i, int j, double alpha) + { + A.row(i) += A.row(j)*alpha; + } + @endcode + @note In the current implementation, the following code does not work as expected: + @code + Mat A; + ... + A.row(i) = A.row(j); // will not work + @endcode + This happens because A.row(i) forms a temporary header that is further assigned to another header. + Remember that each of these operations is O(1), that is, no data is copied. Thus, the above + assignment is not true if you may have expected the j-th row to be copied to the i-th row. To + achieve that, you should either turn this simple assignment into an expression or use the + Mat::copyTo method: + @code + Mat A; + ... + // works, but looks a bit obscure. + A.row(i) = A.row(j) + 0; + // this is a bit longer, but the recommended method. + A.row(j).copyTo(A.row(i)); + @endcode + @param y A 0-based row index. + */ Mat row(int y) const; - //! returns a new matrix header for the specified column + + /** @brief Creates a matrix header for the specified matrix column. + + The method makes a new header for the specified matrix column and returns it. This is an O(1) + operation, regardless of the matrix size. The underlying data of the new matrix is shared with the + original matrix. See also the Mat::row description. + @param x A 0-based column index. + */ Mat col(int x) const; - //! ... for the specified row span + + /** @brief Creates a matrix header for the specified row span. + + The method makes a new header for the specified row span of the matrix. Similarly to Mat::row and + Mat::col , this is an O(1) operation. + @param startrow An inclusive 0-based start index of the row span. + @param endrow An exclusive 0-based ending index of the row span. + */ Mat rowRange(int startrow, int endrow) const; + + /** @overload + @param r Range structure containing both the start and the end indices. + */ Mat rowRange(const Range& r) const; - //! ... for the specified column span + + /** @brief Creates a matrix header for the specified column span. + + The method makes a new header for the specified column span of the matrix. Similarly to Mat::row and + Mat::col , this is an O(1) operation. + @param startcol An inclusive 0-based start index of the column span. + @param endcol An exclusive 0-based ending index of the column span. + */ Mat colRange(int startcol, int endcol) const; + + /** @overload + @param r Range structure containing both the start and the end indices. + */ Mat colRange(const Range& r) const; - //! ... for the specified diagonal - // (d=0 - the main diagonal, - // >0 - a diagonal from the lower half, - // <0 - a diagonal from the upper half) + + /** @brief Extracts a diagonal from a matrix + + The method makes a new header for the specified matrix diagonal. The new matrix is represented as a + single-column matrix. Similarly to Mat::row and Mat::col, this is an O(1) operation. + @param d index of the diagonal, with the following values: + - `d=0` is the main diagonal. + - `d>0` is a diagonal from the lower half. For example, d=1 means the diagonal is set + immediately below the main one. + - `d<0` is a diagonal from the upper half. For example, d=-1 means the diagonal is set + immediately above the main one. + */ Mat diag(int d=0) const; - //! constructs a square diagonal matrix which main diagonal is vector "d" + + /** @brief creates a diagonal matrix + + The method makes a new header for the specified matrix diagonal. The new matrix is represented as a + single-column matrix. Similarly to Mat::row and Mat::col, this is an O(1) operation. + @param d Single-column matrix that forms a diagonal matrix + */ static Mat diag(const Mat& d); - //! returns deep copy of the matrix, i.e. the data is copied + /** @brief Creates a full copy of the array and the underlying data. + + The method creates a full copy of the array. The original step[] is not taken into account. So, the + array copy is a continuous array occupying total()*elemSize() bytes. + */ Mat clone() const; - //! copies the matrix content to "m". - // It calls m.create(this->size(), this->type()). + + /** @brief Copies the matrix to another one. + + The method copies the matrix data to another matrix. Before copying the data, the method invokes : + @code + m.create(this->size(), this->type()); + @endcode + so that the destination matrix is reallocated if needed. While m.copyTo(m); works flawlessly, the + function does not handle the case of a partial overlap between the source and the destination + matrices. + + When the operation mask is specified, if the Mat::create call shown above reallocates the matrix, + the newly allocated matrix is initialized with all zeros before copying the data. + @param m Destination matrix. If it does not have a proper size or type before the operation, it is + reallocated. + */ void copyTo( OutputArray m ) const; - //! copies those matrix elements to "m" that are marked with non-zero mask elements. + + /** @overload + @param m Destination matrix. If it does not have a proper size or type before the operation, it is + reallocated. + @param mask Operation mask. Its non-zero elements indicate which matrix elements need to be copied. + */ void copyTo( OutputArray m, InputArray mask ) const; - //! converts matrix to another datatype with optional scalng. See cvConvertScale. + + /** @brief Converts an array to another data type with optional scaling. + + The method converts source pixel values to the target data type. saturate_cast\<\> is applied at + the end to avoid possible overflows: + + \f[m(x,y) = saturate \_ cast( \alpha (*this)(x,y) + \beta )\f] + @param m output matrix; if it does not have a proper size or type before the operation, it is + reallocated. + @param rtype desired output matrix type or, rather, the depth since the number of channels are the + same as the input has; if rtype is negative, the output matrix will have the same type as the input. + @param alpha optional scale factor. + @param beta optional delta added to the scaled values. + */ void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const; + /** @brief Provides a functional form of convertTo. + + This is an internally used method called by the @ref MatrixExpressions engine. + @param m Destination array. + @param type Desired destination array depth (or -1 if it should be the same as the source type). + */ void assignTo( Mat& m, int type=-1 ) const; - //! sets every matrix element to s + /** @brief Sets all or some of the array elements to the specified value. + @param s Assigned scalar converted to the actual array type. + */ Mat& operator = (const Scalar& s); - //! sets some of the matrix elements to s, according to the mask + + /** @brief Sets all or some of the array elements to the specified value. + + This is an advanced variant of the Mat::operator=(const Scalar& s) operator. + @param value Assigned scalar converted to the actual array type. + @param mask Operation mask of the same size as \*this. + */ Mat& setTo(InputArray value, InputArray mask=noArray()); - //! creates alternative matrix header for the same data, with different - // number of channels and/or different number of rows. see cvReshape. + + /** @brief Changes the shape and/or the number of channels of a 2D matrix without copying the data. + + The method makes a new matrix header for \*this elements. The new matrix may have a different size + and/or different number of channels. Any combination is possible if: + - No extra elements are included into the new matrix and no elements are excluded. Consequently, + the product rows\*cols\*channels() must stay the same after the transformation. + - No data is copied. That is, this is an O(1) operation. Consequently, if you change the number of + rows, or the operation changes the indices of elements row in some other way, the matrix must be + continuous. See Mat::isContinuous . + + For example, if there is a set of 3D points stored as an STL vector, and you want to represent the + points as a 3xN matrix, do the following: + @code + std::vector vec; + ... + Mat pointMat = Mat(vec). // convert vector to Mat, O(1) operation + reshape(1). // make Nx3 1-channel matrix out of Nx1 3-channel. + // Also, an O(1) operation + t(); // finally, transpose the Nx3 matrix. + // This involves copying all the elements + @endcode + @param cn New number of channels. If the parameter is 0, the number of channels remains the same. + @param rows New number of rows. If the parameter is 0, the number of rows remains the same. + */ Mat reshape(int cn, int rows=0) const; + + /** @overload */ Mat reshape(int cn, int newndims, const int* newsz) const; - //! matrix transposition by means of matrix expressions + /** @brief Transposes a matrix. + + The method performs matrix transposition by means of matrix expressions. It does not perform the + actual transposition but returns a temporary matrix transposition object that can be further used as + a part of more complex matrix expressions or can be assigned to a matrix: + @code + Mat A1 = A + Mat::eye(A.size(), A.type())*lambda; + Mat C = A1.t()*A1; // compute (A + lambda*I)^t * (A + lamda*I) + @endcode + */ MatExpr t() const; - //! matrix inversion by means of matrix expressions + + /** @brief Inverses a matrix. + + The method performs a matrix inversion by means of matrix expressions. This means that a temporary + matrix inversion object is returned by the method and can be used further as a part of more complex + matrix expressions or can be assigned to a matrix. + @param method Matrix inversion method. One of cv::DecompTypes + */ MatExpr inv(int method=DECOMP_LU) const; - //! per-element matrix multiplication by means of matrix expressions + + /** @brief Performs an element-wise multiplication or division of the two matrices. + + The method returns a temporary object encoding per-element array multiplication, with optional + scale. Note that this is not a matrix multiplication that corresponds to a simpler "\*" operator. + + Example: + @code + Mat C = A.mul(5/B); // equivalent to divide(A, B, C, 5) + @endcode + @param m Another array of the same type and the same size as \*this, or a matrix expression. + @param scale Optional scale factor. + */ MatExpr mul(InputArray m, double scale=1) const; - //! computes cross-product of 2 3D vectors + /** @brief Computes a cross-product of two 3-element vectors. + + The method computes a cross-product of two 3-element vectors. The vectors must be 3-element + floating-point vectors of the same shape and size. The result is another 3-element vector of the + same shape and type as operands. + @param m Another cross-product operand. + */ Mat cross(InputArray m) const; - //! computes dot-product + + /** @brief Computes a dot-product of two vectors. + + The method computes a dot-product of two matrices. If the matrices are not single-column or + single-row vectors, the top-to-bottom left-to-right scan ordering is used to treat them as 1D + vectors. The vectors must have the same size and type. If the matrices have more than one channel, + the dot products from all the channels are summed together. + @param m another dot-product operand. + */ double dot(InputArray m) const; - //! Matlab-style matrix initialization + /** @brief Returns a zero array of the specified size and type. + + The method returns a Matlab-style zero array initializer. It can be used to quickly form a constant + array as a function parameter, part of a matrix expression, or as a matrix initializer. : + @code + Mat A; + A = Mat::zeros(3, 3, CV_32F); + @endcode + In the example above, a new matrix is allocated only if A is not a 3x3 floating-point matrix. + Otherwise, the existing matrix A is filled with zeros. + @param rows Number of rows. + @param cols Number of columns. + @param type Created matrix type. + */ static MatExpr zeros(int rows, int cols, int type); + + /** @overload + @param size Alternative to the matrix size specification Size(cols, rows) . + @param type Created matrix type. + */ static MatExpr zeros(Size size, int type); + + /** @overload + @param ndims Array dimensionality. + @param sz Array of integers specifying the array shape. + @param type Created matrix type. + */ static MatExpr zeros(int ndims, const int* sz, int type); + + /** @brief Returns an array of all 1's of the specified size and type. + + The method returns a Matlab-style 1's array initializer, similarly to Mat::zeros. Note that using + this method you can initialize an array with an arbitrary value, using the following Matlab idiom: + @code + Mat A = Mat::ones(100, 100, CV_8U)*3; // make 100x100 matrix filled with 3. + @endcode + The above operation does not form a 100x100 matrix of 1's and then multiply it by 3. Instead, it + just remembers the scale factor (3 in this case) and use it when actually invoking the matrix + initializer. + @param rows Number of rows. + @param cols Number of columns. + @param type Created matrix type. + */ static MatExpr ones(int rows, int cols, int type); + + /** @overload + @param size Alternative to the matrix size specification Size(cols, rows) . + @param type Created matrix type. + */ static MatExpr ones(Size size, int type); + + /** @overload + @param ndims Array dimensionality. + @param sz Array of integers specifying the array shape. + @param type Created matrix type. + */ static MatExpr ones(int ndims, const int* sz, int type); + + /** @brief Returns an identity matrix of the specified size and type. + + The method returns a Matlab-style identity matrix initializer, similarly to Mat::zeros. Similarly to + Mat::ones, you can use a scale operation to create a scaled identity matrix efficiently: + @code + // make a 4x4 diagonal matrix with 0.1's on the diagonal. + Mat A = Mat::eye(4, 4, CV_32F)*0.1; + @endcode + @param rows Number of rows. + @param cols Number of columns. + @param type Created matrix type. + */ static MatExpr eye(int rows, int cols, int type); + + /** @overload + @param size Alternative matrix size specification as Size(cols, rows) . + @param type Created matrix type. + */ static MatExpr eye(Size size, int type); - //! allocates new matrix data unless the matrix already has specified size and type. - // previous data is unreferenced if needed. + /** @brief Allocates new array data if needed. + + This is one of the key Mat methods. Most new-style OpenCV functions and methods that produce arrays + call this method for each output array. The method uses the following algorithm: + + -# If the current array shape and the type match the new ones, return immediately. Otherwise, + de-reference the previous data by calling Mat::release. + -# Initialize the new header. + -# Allocate the new data of total()\*elemSize() bytes. + -# Allocate the new, associated with the data, reference counter and set it to 1. + + Such a scheme makes the memory management robust and efficient at the same time and helps avoid + extra typing for you. This means that usually there is no need to explicitly allocate output arrays. + That is, instead of writing: + @code + Mat color; + ... + Mat gray(color.rows, color.cols, color.depth()); + cvtColor(color, gray, COLOR_BGR2GRAY); + @endcode + you can simply write: + @code + Mat color; + ... + Mat gray; + cvtColor(color, gray, COLOR_BGR2GRAY); + @endcode + because cvtColor, as well as the most of OpenCV functions, calls Mat::create() for the output array + internally. + @param rows New number of rows. + @param cols New number of columns. + @param type New matrix type. + */ void create(int rows, int cols, int type); + + /** @overload + @param size Alternative new matrix size specification: Size(cols, rows) + @param type New matrix type. + */ void create(Size size, int type); + + /** @overload + @param ndims New array dimensionality. + @param sizes Array of integers specifying a new array shape. + @param type New matrix type. + */ void create(int ndims, const int* sizes, int type); - //! increases the reference counter; use with care to avoid memleaks + /** @brief Increments the reference counter. + + The method increments the reference counter associated with the matrix data. If the matrix header + points to an external data set (see Mat::Mat ), the reference counter is NULL, and the method has no + effect in this case. Normally, to avoid memory leaks, the method should not be called explicitly. It + is called implicitly by the matrix assignment operator. The reference counter increment is an atomic + operation on the platforms that support it. Thus, it is safe to operate on the same matrices + asynchronously in different threads. + */ void addref(); - //! decreases reference counter; - // deallocates the data when reference counter reaches 0. + + /** @brief Decrements the reference counter and deallocates the matrix if needed. + + The method decrements the reference counter associated with the matrix data. When the reference + counter reaches 0, the matrix data is deallocated and the data and the reference counter pointers + are set to NULL's. If the matrix header points to an external data set (see Mat::Mat ), the + reference counter is NULL, and the method has no effect in this case. + + This method can be called manually to force the matrix data deallocation. But since this method is + automatically called in the destructor, or by any other method that changes the data pointer, it is + usually not needed. The reference counter decrement and check for 0 is an atomic operation on the + platforms that support it. Thus, it is safe to operate on the same matrices asynchronously in + different threads. + */ void release(); //! deallocates the matrix data @@ -770,29 +1348,123 @@ public: //! internal use function; properly re-allocates _size, _step arrays void copySize(const Mat& m); - //! reserves enough space to fit sz hyper-planes + /** @brief Reserves space for the certain number of rows. + + The method reserves space for sz rows. If the matrix already has enough space to store sz rows, + nothing happens. If the matrix is reallocated, the first Mat::rows rows are preserved. The method + emulates the corresponding method of the STL vector class. + @param sz Number of rows. + */ void reserve(size_t sz); - //! resizes matrix to the specified number of hyper-planes + + /** @brief Changes the number of matrix rows. + + The methods change the number of matrix rows. If the matrix is reallocated, the first + min(Mat::rows, sz) rows are preserved. The methods emulate the corresponding methods of the STL + vector class. + @param sz New number of rows. + */ void resize(size_t sz); - //! resizes matrix to the specified number of hyper-planes; initializes the newly added elements + + /** @overload + @param sz New number of rows. + @param s Value assigned to the newly added elements. + */ void resize(size_t sz, const Scalar& s); + //! internal function void push_back_(const void* elem); - //! adds element to the end of 1d matrix (or possibly multiple elements when _Tp=Mat) + + /** @brief Adds elements to the bottom of the matrix. + + The methods add one or more elements to the bottom of the matrix. They emulate the corresponding + method of the STL vector class. When elem is Mat , its type and the number of columns must be the + same as in the container matrix. + @param elem Added element(s). + */ template void push_back(const _Tp& elem); + + /** @overload + @param elem Added element(s). + */ template void push_back(const Mat_<_Tp>& elem); + + /** @overload + @param m Added line(s). + */ void push_back(const Mat& m); - //! removes several hyper-planes from bottom of the matrix + + /** @brief Removes elements from the bottom of the matrix. + + The method removes one or more rows from the bottom of the matrix. + @param nelems Number of removed rows. If it is greater than the total number of rows, an exception + is thrown. + */ void pop_back(size_t nelems=1); - //! locates matrix header within a parent matrix. See below + /** @brief Locates the matrix header within a parent matrix. + + After you extracted a submatrix from a matrix using Mat::row, Mat::col, Mat::rowRange, + Mat::colRange, and others, the resultant submatrix points just to the part of the original big + matrix. However, each submatrix contains information (represented by datastart and dataend + fields) that helps reconstruct the original matrix size and the position of the extracted + submatrix within the original matrix. The method locateROI does exactly that. + @param wholeSize Output parameter that contains the size of the whole matrix containing *this* + as a part. + @param ofs Output parameter that contains an offset of *this* inside the whole matrix. + */ void locateROI( Size& wholeSize, Point& ofs ) const; - //! moves/resizes the current matrix ROI inside the parent matrix. + + /** @brief Adjusts a submatrix size and position within the parent matrix. + + The method is complimentary to Mat::locateROI . The typical use of these functions is to determine + the submatrix position within the parent matrix and then shift the position somehow. Typically, it + can be required for filtering operations when pixels outside of the ROI should be taken into + account. When all the method parameters are positive, the ROI needs to grow in all directions by the + specified amount, for example: + @code + A.adjustROI(2, 2, 2, 2); + @endcode + In this example, the matrix size is increased by 4 elements in each direction. The matrix is shifted + by 2 elements to the left and 2 elements up, which brings in all the necessary pixels for the + filtering with the 5x5 kernel. + + adjustROI forces the adjusted ROI to be inside of the parent matrix that is boundaries of the + adjusted ROI are constrained by boundaries of the parent matrix. For example, if the submatrix A is + located in the first row of a parent matrix and you called A.adjustROI(2, 2, 2, 2) then A will not + be increased in the upward direction. + + The function is used internally by the OpenCV filtering functions, like filter2D , morphological + operations, and so on. + @param dtop Shift of the top submatrix boundary upwards. + @param dbottom Shift of the bottom submatrix boundary downwards. + @param dleft Shift of the left submatrix boundary to the left. + @param dright Shift of the right submatrix boundary to the right. + @sa copyMakeBorder + */ Mat& adjustROI( int dtop, int dbottom, int dleft, int dright ); - //! extracts a rectangular sub-matrix - // (this is a generalized form of row, rowRange etc.) + + /** @brief Extracts a rectangular submatrix. + + The operators make a new header for the specified sub-array of \*this . They are the most + generalized forms of Mat::row, Mat::col, Mat::rowRange, and Mat::colRange . For example, + `A(Range(0, 10), Range::all())` is equivalent to `A.rowRange(0, 10)`. Similarly to all of the above, + the operators are O(1) operations, that is, no matrix data is copied. + @param rowRange Start and end row of the extracted submatrix. The upper boundary is not included. To + select all the rows, use Range::all(). + @param colRange Start and end column of the extracted submatrix. The upper boundary is not included. + To select all the columns, use Range::all(). + */ Mat operator()( Range rowRange, Range colRange ) const; + + /** @overload + @param roi Extracted submatrix specified as a rectangle. + */ Mat operator()( const Rect& roi ) const; + + /** @overload + @param ranges Array of selected ranges along each array dimension. + */ Mat operator()( const Range* ranges ) const; // //! converts header to CvMat; no data is copied @@ -806,101 +1478,378 @@ public: template operator Vec<_Tp, n>() const; template operator Matx<_Tp, m, n>() const; - //! returns true iff the matrix data is continuous - // (i.e. when there are no gaps between successive rows). - // similar to CV_IS_MAT_CONT(cvmat->type) + /** @brief Reports whether the matrix is continuous or not. + + The method returns true if the matrix elements are stored continuously without gaps at the end of + each row. Otherwise, it returns false. Obviously, 1x1 or 1xN matrices are always continuous. + Matrices created with Mat::create are always continuous. But if you extract a part of the matrix + using Mat::col, Mat::diag, and so on, or constructed a matrix header for externally allocated data, + such matrices may no longer have this property. + + The continuity flag is stored as a bit in the Mat::flags field and is computed automatically when + you construct a matrix header. Thus, the continuity check is a very fast operation, though + theoretically it could be done as follows: + @code + // alternative implementation of Mat::isContinuous() + bool myCheckMatContinuity(const Mat& m) + { + //return (m.flags & Mat::CONTINUOUS_FLAG) != 0; + return m.rows == 1 || m.step == m.cols*m.elemSize(); + } + @endcode + The method is used in quite a few of OpenCV functions. The point is that element-wise operations + (such as arithmetic and logical operations, math functions, alpha blending, color space + transformations, and others) do not depend on the image geometry. Thus, if all the input and output + arrays are continuous, the functions can process them as very long single-row vectors. The example + below illustrates how an alpha-blending function can be implemented: + @code + template + void alphaBlendRGBA(const Mat& src1, const Mat& src2, Mat& dst) + { + const float alpha_scale = (float)std::numeric_limits::max(), + inv_scale = 1.f/alpha_scale; + + CV_Assert( src1.type() == src2.type() && + src1.type() == CV_MAKETYPE(DataType::depth, 4) && + src1.size() == src2.size()); + Size size = src1.size(); + dst.create(size, src1.type()); + + // here is the idiom: check the arrays for continuity and, + // if this is the case, + // treat the arrays as 1D vectors + if( src1.isContinuous() && src2.isContinuous() && dst.isContinuous() ) + { + size.width *= size.height; + size.height = 1; + } + size.width *= 4; + + for( int i = 0; i < size.height; i++ ) + { + // when the arrays are continuous, + // the outer loop is executed only once + const T* ptr1 = src1.ptr(i); + const T* ptr2 = src2.ptr(i); + T* dptr = dst.ptr(i); + + for( int j = 0; j < size.width; j += 4 ) + { + float alpha = ptr1[j+3]*inv_scale, beta = ptr2[j+3]*inv_scale; + dptr[j] = saturate_cast(ptr1[j]*alpha + ptr2[j]*beta); + dptr[j+1] = saturate_cast(ptr1[j+1]*alpha + ptr2[j+1]*beta); + dptr[j+2] = saturate_cast(ptr1[j+2]*alpha + ptr2[j+2]*beta); + dptr[j+3] = saturate_cast((1 - (1-alpha)*(1-beta))*alpha_scale); + } + } + } + @endcode + This approach, while being very simple, can boost the performance of a simple element-operation by + 10-20 percents, especially if the image is rather small and the operation is quite simple. + + Another OpenCV idiom in this function, a call of Mat::create for the destination array, that + allocates the destination array unless it already has the proper size and type. And while the newly + allocated arrays are always continuous, you still need to check the destination array because + Mat::create does not always allocate a new matrix. + */ bool isContinuous() const; //! returns true if the matrix is a submatrix of another matrix bool isSubmatrix() const; - //! returns element size in bytes, - // similar to CV_ELEM_SIZE(cvmat->type) + /** @brief Returns the matrix element size in bytes. + + The method returns the matrix element size in bytes. For example, if the matrix type is CV_16SC3 , + the method returns 3\*sizeof(short) or 6. + */ size_t elemSize() const; - //! returns the size of element channel in bytes. + + /** @brief Returns the size of each matrix element channel in bytes. + + The method returns the matrix element channel size in bytes, that is, it ignores the number of + channels. For example, if the matrix type is CV_16SC3 , the method returns sizeof(short) or 2. + */ size_t elemSize1() const; - //! returns element type, similar to CV_MAT_TYPE(cvmat->type) + + /** @brief Returns the type of a matrix element. + + The method returns a matrix element type. This is an identifier compatible with the CvMat type + system, like CV_16SC3 or 16-bit signed 3-channel array, and so on. + */ int type() const; - //! returns element type, similar to CV_MAT_DEPTH(cvmat->type) + + /** @brief Returns the depth of a matrix element. + + The method returns the identifier of the matrix element depth (the type of each individual channel). + For example, for a 16-bit signed element array, the method returns CV_16S . A complete list of + matrix types contains the following values: + - CV_8U - 8-bit unsigned integers ( 0..255 ) + - CV_8S - 8-bit signed integers ( -128..127 ) + - CV_16U - 16-bit unsigned integers ( 0..65535 ) + - CV_16S - 16-bit signed integers ( -32768..32767 ) + - CV_32S - 32-bit signed integers ( -2147483648..2147483647 ) + - CV_32F - 32-bit floating-point numbers ( -FLT_MAX..FLT_MAX, INF, NAN ) + - CV_64F - 64-bit floating-point numbers ( -DBL_MAX..DBL_MAX, INF, NAN ) + */ int depth() const; - //! returns element type, similar to CV_MAT_CN(cvmat->type) + + /** @brief Returns the number of matrix channels. + + The method returns the number of matrix channels. + */ int channels() const; - //! returns step/elemSize1() + + /** @brief Returns a normalized step. + + The method returns a matrix step divided by Mat::elemSize1() . It can be useful to quickly access an + arbitrary matrix element. + */ size_t step1(int i=0) const; - //! returns true if matrix data is NULL + + /** @brief Returns true if the array has no elements. + + The method returns true if Mat::total() is 0 or if Mat::data is NULL. Because of pop_back() and + resize() methods `M.total() == 0` does not imply that `M.data == NULL`. + */ bool empty() const; - //! returns the total number of matrix elements + + /** @brief Returns the total number of array elements. + + The method returns the number of array elements (a number of pixels if the array represents an + image). + */ size_t total() const; //! returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel (1 x N) or (N x 1); negative number otherwise int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const; - //! returns pointer to i0-th submatrix along the dimension #0 + /** @brief Returns a pointer to the specified matrix row. + + The methods return `uchar*` or typed pointer to the specified matrix row. See the sample in + Mat::isContinuous to know how to use these methods. + @param i0 A 0-based row index. + */ uchar* ptr(int i0=0); + /** @overload */ const uchar* ptr(int i0=0) const; - //! returns pointer to (i0,i1) submatrix along the dimensions #0 and #1 + /** @overload */ uchar* ptr(int i0, int i1); + /** @overload */ const uchar* ptr(int i0, int i1) const; - //! returns pointer to (i0,i1,i3) submatrix along the dimensions #0, #1, #2 + /** @overload */ uchar* ptr(int i0, int i1, int i2); + /** @overload */ const uchar* ptr(int i0, int i1, int i2) const; - //! returns pointer to the matrix element + /** @overload */ uchar* ptr(const int* idx); - //! returns read-only pointer to the matrix element + /** @overload */ const uchar* ptr(const int* idx) const; - + /** @overload */ template uchar* ptr(const Vec& idx); + /** @overload */ template const uchar* ptr(const Vec& idx) const; - //! template version of the above method + /** @overload */ template _Tp* ptr(int i0=0); + /** @overload */ template const _Tp* ptr(int i0=0) const; - + /** @overload */ template _Tp* ptr(int i0, int i1); + /** @overload */ template const _Tp* ptr(int i0, int i1) const; - + /** @overload */ template _Tp* ptr(int i0, int i1, int i2); + /** @overload */ template const _Tp* ptr(int i0, int i1, int i2) const; - + /** @overload */ template _Tp* ptr(const int* idx); + /** @overload */ template const _Tp* ptr(const int* idx) const; - + /** @overload */ template _Tp* ptr(const Vec& idx); + /** @overload */ template const _Tp* ptr(const Vec& idx) const; - //! the same as above, with the pointer dereferencing + /** @brief Returns a reference to the specified array element. + + The template methods return a reference to the specified array element. For the sake of higher + performance, the index range checks are only performed in the Debug configuration. + + Note that the variants with a single index (i) can be used to access elements of single-row or + single-column 2-dimensional arrays. That is, if, for example, A is a 1 x N floating-point matrix and + B is an M x 1 integer matrix, you can simply write `A.at(k+4)` and `B.at(2*i+1)` + instead of `A.at(0,k+4)` and `B.at(2*i+1,0)`, respectively. + + The example below initializes a Hilbert matrix: + @code + Mat H(100, 100, CV_64F); + for(int i = 0; i < H.rows; i++) + for(int j = 0; j < H.cols; j++) + H.at(i,j)=1./(i+j+1); + @endcode + @param i0 Index along the dimension 0 + */ template _Tp& at(int i0=0); + /** @overload + @param i0 Index along the dimension 0 + */ template const _Tp& at(int i0=0) const; - + /** @overload + @param i0 Index along the dimension 0 + @param i1 Index along the dimension 1 + */ template _Tp& at(int i0, int i1); + /** @overload + @param i0 Index along the dimension 0 + @param i1 Index along the dimension 1 + */ template const _Tp& at(int i0, int i1) const; + /** @overload + @param i0 Index along the dimension 0 + @param i1 Index along the dimension 1 + @param i2 Index along the dimension 2 + */ template _Tp& at(int i0, int i1, int i2); + /** @overload + @param i0 Index along the dimension 0 + @param i1 Index along the dimension 1 + @param i2 Index along the dimension 2 + */ template const _Tp& at(int i0, int i1, int i2) const; + /** @overload + @param idx Array of Mat::dims indices. + */ template _Tp& at(const int* idx); + /** @overload + @param idx Array of Mat::dims indices. + */ template const _Tp& at(const int* idx) const; + /** @overload */ template _Tp& at(const Vec& idx); + /** @overload */ template const _Tp& at(const Vec& idx) const; - //! special versions for 2D arrays (especially convenient for referencing image pixels) + /** @overload + special versions for 2D arrays (especially convenient for referencing image pixels) + @param pt Element position specified as Point(j,i) . + */ template _Tp& at(Point pt); + /** @overload + special versions for 2D arrays (especially convenient for referencing image pixels) + @param pt Element position specified as Point(j,i) . + */ template const _Tp& at(Point pt) const; - //! template methods for iteration over matrix elements. - // the iterators take care of skipping gaps in the end of rows (if any) + /** @brief Returns the matrix iterator and sets it to the first matrix element. + + The methods return the matrix read-only or read-write iterators. The use of matrix iterators is very + similar to the use of bi-directional STL iterators. In the example below, the alpha blending + function is rewritten using the matrix iterators: + @code + template + void alphaBlendRGBA(const Mat& src1, const Mat& src2, Mat& dst) + { + typedef Vec VT; + + const float alpha_scale = (float)std::numeric_limits::max(), + inv_scale = 1.f/alpha_scale; + + CV_Assert( src1.type() == src2.type() && + src1.type() == DataType::type && + src1.size() == src2.size()); + Size size = src1.size(); + dst.create(size, src1.type()); + + MatConstIterator_ it1 = src1.begin(), it1_end = src1.end(); + MatConstIterator_ it2 = src2.begin(); + MatIterator_ dst_it = dst.begin(); + + for( ; it1 != it1_end; ++it1, ++it2, ++dst_it ) + { + VT pix1 = *it1, pix2 = *it2; + float alpha = pix1[3]*inv_scale, beta = pix2[3]*inv_scale; + *dst_it = VT(saturate_cast(pix1[0]*alpha + pix2[0]*beta), + saturate_cast(pix1[1]*alpha + pix2[1]*beta), + saturate_cast(pix1[2]*alpha + pix2[2]*beta), + saturate_cast((1 - (1-alpha)*(1-beta))*alpha_scale)); + } + } + @endcode + */ template MatIterator_<_Tp> begin(); - template MatIterator_<_Tp> end(); template MatConstIterator_<_Tp> begin() const; + + /** @brief Returns the matrix iterator and sets it to the after-last matrix element. + + The methods return the matrix read-only or read-write iterators, set to the point following the last + matrix element. + */ + template MatIterator_<_Tp> end(); template MatConstIterator_<_Tp> end() const; - //! template methods for for operation over all matrix elements. - // the operations take care of skipping gaps in the end of rows (if any) + /** @brief Invoke with arguments functor, and runs the functor over all matrix element. + + The methos runs operation in parallel. Operation is passed by arguments. Operation have to be a + function pointer, a function object or a lambda(C++11). + + All of below operation is equal. Put 0xFF to first channel of all matrix elements: + @code + Mat image(1920, 1080, CV_8UC3); + typedef cv::Point3_ Pixel; + + // first. raw pointer access. + for (int r = 0; r < image.rows; ++r) { + Pixel* ptr = image.ptr(0, r); + const Pixel* ptr_end = ptr + image.cols; + for (; ptr != ptr_end; ++ptr) { + ptr->x = 255; + } + } + + // Using MatIterator. (Simple but there are a Iterator's overhead) + for (Pixel &p : cv::Mat_(image)) { + p.x = 255; + } + + // Parallel execution with function object. + struct Operator { + void operator ()(Pixel &pixel, const int * position) { + pixel.x = 255; + } + }; + image.forEach(Operator()); + + // Parallel execution using C++11 lambda. + image.forEach([](Pixel &p, const int * position) -> void { + p.x = 255; + }); + @endcode + position parameter is index of current pixel: + @code + // Creating 3D matrix (255 x 255 x 255) typed uint8_t, + // and initialize all elements by the value which equals elements position. + // i.e. pixels (x,y,z) = (1,2,3) is (b,g,r) = (1,2,3). + + int sizes[] = { 255, 255, 255 }; + typedef cv::Point3_ Pixel; + + Mat_ image = Mat::zeros(3, sizes, CV_8UC3); + + image.forEachWithPosition([&](Pixel& pixel, const int position[]) -> void{ + pixel.x = position[0]; + pixel.y = position[1]; + pixel.z = position[2]; + }); + @endcode + */ template void forEach(const Functor& operation); + /** @overload */ template void forEach(const Functor& operation) const; enum { MAGIC_VAL = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG }; @@ -943,50 +1892,54 @@ protected: ///////////////////////////////// Mat_<_Tp> //////////////////////////////////// -/*! - Template matrix class derived from Mat - - The class Mat_ is a "thin" template wrapper on top of cv::Mat. It does not have any extra data fields, - nor it or cv::Mat have any virtual methods and thus references or pointers to these two classes - can be safely converted one to another. But do it with care, for example: - - \code - // create 100x100 8-bit matrix - Mat M(100,100,CV_8U); - // this will compile fine. no any data conversion will be done. - Mat_& M1 = (Mat_&)M; - // the program will likely crash at the statement below - M1(99,99) = 1.f; - \endcode - - While cv::Mat is sufficient in most cases, cv::Mat_ can be more convenient if you use a lot of element - access operations and if you know matrix type at compile time. Note that cv::Mat::at and - cv::Mat::operator() do absolutely the same thing and run at the same speed, but the latter is certainly shorter: +/** @brief Template matrix class derived from Mat - \code - Mat_ M(20,20); - for(int i = 0; i < M.rows; i++) - for(int j = 0; j < M.cols; j++) - M(i,j) = 1./(i+j+1); - Mat E, V; - eigen(M,E,V); - cout << E.at(0,0)/E.at(M.rows-1,0); - \endcode - - It is easy to use Mat_ for multi-channel images/matrices - just pass cv::Vec as cv::Mat_ template parameter: - - \code - // allocate 320x240 color image and fill it with green (in RGB space) - Mat_ img(240, 320, Vec3b(0,255,0)); - // now draw a diagonal white line - for(int i = 0; i < 100; i++) - img(i,i)=Vec3b(255,255,255); - // and now modify the 2nd (red) channel of each pixel - for(int i = 0; i < img.rows; i++) - for(int j = 0; j < img.cols; j++) - img(i,j)[2] ^= (uchar)(i ^ j); // img(y,x)[c] accesses c-th channel of the pixel (x,y) - \endcode -*/ +@code + template class Mat_ : public Mat + { + public: + // ... some specific methods + // and + // no new extra fields + }; +@endcode +The class `Mat_<_Tp>` is a *thin* template wrapper on top of the Mat class. It does not have any +extra data fields. Nor this class nor Mat has any virtual methods. Thus, references or pointers to +these two classes can be freely but carefully converted one to another. For example: +@code + // create a 100x100 8-bit matrix + Mat M(100,100,CV_8U); + // this will be compiled fine. no any data conversion will be done. + Mat_& M1 = (Mat_&)M; + // the program is likely to crash at the statement below + M1(99,99) = 1.f; +@endcode +While Mat is sufficient in most cases, Mat_ can be more convenient if you use a lot of element +access operations and if you know matrix type at the compilation time. Note that +`Mat::at(int y,int x)` and `Mat_::operator()(int y,int x)` do absolutely the same +and run at the same speed, but the latter is certainly shorter: +@code + Mat_ M(20,20); + for(int i = 0; i < M.rows; i++) + for(int j = 0; j < M.cols; j++) + M(i,j) = 1./(i+j+1); + Mat E, V; + eigen(M,E,V); + cout << E.at(0,0)/E.at(M.rows-1,0); +@endcode +To use Mat_ for multi-channel images/matrices, pass Vec as a Mat_ parameter: +@code + // allocate a 320x240 color image and fill it with green (in RGB space) + Mat_ img(240, 320, Vec3b(0,255,0)); + // now draw a diagonal white line + for(int i = 0; i < 100; i++) + img(i,i)=Vec3b(255,255,255); + // and now scramble the 2nd (red) channel of each pixel + for(int i = 0; i < img.rows; i++) + for(int j = 0; j < img.cols; j++) + img(i,j)[2] ^= (uchar)(i ^ j); +@endcode + */ template class Mat_ : public Mat { public: @@ -1161,6 +2114,7 @@ typedef Mat_ Mat2d; typedef Mat_ Mat3d; typedef Mat_ Mat4d; +/** @todo document */ class CV_EXPORTS UMat { public: @@ -1359,91 +2313,84 @@ protected: /////////////////////////// multi-dimensional sparse matrix ////////////////////////// -/*! - Sparse matrix class. - - The class represents multi-dimensional sparse numerical arrays. Such a sparse array can store elements - of any type that cv::Mat is able to store. "Sparse" means that only non-zero elements - are stored (though, as a result of some operations on a sparse matrix, some of its stored elements - can actually become 0. It's user responsibility to detect such elements and delete them using cv::SparseMat::erase(). - The non-zero elements are stored in a hash table that grows when it's filled enough, - so that the search time remains O(1) in average. Elements can be accessed using the following methods: - -
    -
  1. Query operations: cv::SparseMat::ptr() and the higher-level cv::SparseMat::ref(), - cv::SparseMat::value() and cv::SparseMat::find, for example: - \code - const int dims = 5; - int size[] = {10, 10, 10, 10, 10}; - SparseMat sparse_mat(dims, size, CV_32F); - for(int i = 0; i < 1000; i++) - { - int idx[dims]; - for(int k = 0; k < dims; k++) - idx[k] = rand()%sparse_mat.size(k); - sparse_mat.ref(idx) += 1.f; - } - \endcode - -
  2. Sparse matrix iterators. Like cv::Mat iterators and unlike cv::Mat iterators, the sparse matrix iterators are STL-style, - that is, the iteration is done as following: - \code - // prints elements of a sparse floating-point matrix and the sum of elements. - SparseMatConstIterator_ - it = sparse_mat.begin(), - it_end = sparse_mat.end(); - double s = 0; - int dims = sparse_mat.dims(); - for(; it != it_end; ++it) - { - // print element indices and the element value - const Node* n = it.node(); - printf("(") - for(int i = 0; i < dims; i++) - printf("%3d%c", n->idx[i], i < dims-1 ? ',' : ')'); - printf(": %f\n", *it); - s += *it; - } - printf("Element sum is %g\n", s); - \endcode - If you run this loop, you will notice that elements are enumerated - in no any logical order (lexicographical etc.), - they come in the same order as they stored in the hash table, i.e. semi-randomly. - - You may collect pointers to the nodes and sort them to get the proper ordering. - Note, however, that pointers to the nodes may become invalid when you add more - elements to the matrix; this is because of possible buffer reallocation. - -
  3. A combination of the above 2 methods when you need to process 2 or more sparse - matrices simultaneously, e.g. this is how you can compute unnormalized - cross-correlation of the 2 floating-point sparse matrices: - \code - double crossCorr(const SparseMat& a, const SparseMat& b) - { - const SparseMat *_a = &a, *_b = &b; - // if b contains less elements than a, - // it's faster to iterate through b - if(_a->nzcount() > _b->nzcount()) - std::swap(_a, _b); - SparseMatConstIterator_ it = _a->begin(), - it_end = _a->end(); - double ccorr = 0; - for(; it != it_end; ++it) - { - // take the next element from the first matrix - float avalue = *it; - const Node* anode = it.node(); - // and try to find element with the same index in the second matrix. - // since the hash value depends only on the element index, - // we reuse hashvalue stored in the node - float bvalue = _b->value(anode->idx,&anode->hashval); - ccorr += avalue*bvalue; - } - return ccorr; - } - \endcode -
-*/ +/** @brief The class SparseMat represents multi-dimensional sparse numerical arrays. + +Such a sparse array can store elements of any type that Mat can store. *Sparse* means that only +non-zero elements are stored (though, as a result of operations on a sparse matrix, some of its +stored elements can actually become 0. It is up to you to detect such elements and delete them +using SparseMat::erase ). The non-zero elements are stored in a hash table that grows when it is +filled so that the search time is O(1) in average (regardless of whether element is there or not). +Elements can be accessed using the following methods: +- Query operations (SparseMat::ptr and the higher-level SparseMat::ref, SparseMat::value and + SparseMat::find), for example: + @code + const int dims = 5; + int size[] = {10, 10, 10, 10, 10}; + SparseMat sparse_mat(dims, size, CV_32F); + for(int i = 0; i < 1000; i++) + { + int idx[dims]; + for(int k = 0; k < dims; k++) + idx[k] = rand() + sparse_mat.ref(idx) += 1.f; + } + @endcode +- Sparse matrix iterators. They are similar to MatIterator but different from NAryMatIterator. + That is, the iteration loop is familiar to STL users: + @code + // prints elements of a sparse floating-point matrix + // and the sum of elements. + SparseMatConstIterator_ + it = sparse_mat.begin(), + it_end = sparse_mat.end(); + double s = 0; + int dims = sparse_mat.dims(); + for(; it != it_end; ++it) + { + // print element indices and the element value + const SparseMat::Node* n = it.node(); + printf("("); + for(int i = 0; i < dims; i++) + printf("%d%s", n->idx[i], i < dims-1 ? ", " : ")"); + printf(": %g\n", it.value()); + s += *it; + } + printf("Element sum is %g\n", s); + @endcode + If you run this loop, you will notice that elements are not enumerated in a logical order + (lexicographical, and so on). They come in the same order as they are stored in the hash table + (semi-randomly). You may collect pointers to the nodes and sort them to get the proper ordering. + Note, however, that pointers to the nodes may become invalid when you add more elements to the + matrix. This may happen due to possible buffer reallocation. +- Combination of the above 2 methods when you need to process 2 or more sparse matrices + simultaneously. For example, this is how you can compute unnormalized cross-correlation of the 2 + floating-point sparse matrices: + @code + double cross_corr(const SparseMat& a, const SparseMat& b) + { + const SparseMat *_a = &a, *_b = &b; + // if b contains less elements than a, + // it is faster to iterate through b + if(_a->nzcount() > _b->nzcount()) + std::swap(_a, _b); + SparseMatConstIterator_ it = _a->begin(), + it_end = _a->end(); + double ccorr = 0; + for(; it != it_end; ++it) + { + // take the next element from the first matrix + float avalue = *it; + const Node* anode = it.node(); + // and try to find an element with the same index in the second matrix. + // since the hash value depends only on the element index, + // reuse the hash value stored in the node + float bvalue = _b->value(anode->idx,&anode->hashval); + ccorr += avalue*bvalue; + } + return ccorr; + } + @endcode + */ class CV_EXPORTS SparseMat { public: @@ -1479,19 +2426,29 @@ public: int idx[MAX_DIM]; }; - //! default constructor + /** @brief Various SparseMat constructors. + */ SparseMat(); - //! creates matrix of the specified size and type + + /** @overload + @param dims Array dimensionality. + @param _sizes Sparce matrix size on all dementions. + @param _type Sparse matrix data type. + */ SparseMat(int dims, const int* _sizes, int _type); - //! copy constructor + + /** @overload + @param m Source matrix for copy constructor. If m is dense matrix (ocvMat) then it will be converted + to sparse representation. + */ SparseMat(const SparseMat& m); - //! converts dense 2d matrix to the sparse form - /*! - \param m the input matrix + + /** @overload + @param m Source matrix for copy constructor. If m is dense matrix (ocvMat) then it will be converted + to sparse representation. */ explicit SparseMat(const Mat& m); - //! converts old-style sparse matrix to the new-style. All the data is copied - //SparseMat(const CvSparseMat* m); + //! the destructor ~SparseMat(); @@ -1570,19 +2527,16 @@ public: //! computes the element hash value (nD case) size_t hash(const int* idx) const; - //@{ + //!@{ /*! specialized variants for 1D, 2D, 3D cases and the generic_type one for n-D case. - return pointer to the matrix element. -
    -
  • if the element is there (it's non-zero), the pointer to it is returned -
  • if it's not there and createMissing=false, NULL pointer is returned -
  • if it's not there and createMissing=true, then the new element + - if the element is there (it's non-zero), the pointer to it is returned + - if it's not there and createMissing=false, NULL pointer is returned + - if it's not there and createMissing=true, then the new element is created and initialized with 0. Pointer to it is returned -
  • if the optional hashval pointer is not NULL, the element hash value is - not computed, but *hashval is taken instead. -
+ - if the optional hashval pointer is not NULL, the element hash value is + not computed, but *hashval is taken instead. */ //! returns pointer to the specified element (1D case) uchar* ptr(int i0, bool createMissing, size_t* hashval=0); @@ -1592,13 +2546,13 @@ public: uchar* ptr(int i0, int i1, int i2, bool createMissing, size_t* hashval=0); //! returns pointer to the specified element (nD case) uchar* ptr(const int* idx, bool createMissing, size_t* hashval=0); - //@} + //!@} - //@{ + //!@{ /*! return read-write reference to the specified sparse matrix element. - ref<_Tp>(i0,...[,hashval]) is equivalent to *(_Tp*)ptr(i0,...,true[,hashval]). + `ref<_Tp>(i0,...[,hashval])` is equivalent to `*(_Tp*)ptr(i0,...,true[,hashval])`. The methods always return a valid reference. If the element did not exist, it is created and initialiazed with 0. */ @@ -1610,17 +2564,16 @@ public: template _Tp& ref(int i0, int i1, int i2, size_t* hashval=0); //! returns reference to the specified element (nD case) template _Tp& ref(const int* idx, size_t* hashval=0); - //@} + //!@} - //@{ + //!@{ /*! return value of the specified sparse matrix element. - value<_Tp>(i0,...[,hashval]) is equivalent - - \code + `value<_Tp>(i0,...[,hashval])` is equivalent to + @code { const _Tp* p = find<_Tp>(i0,...[,hashval]); return p ? *p : _Tp(); } - \endcode + @endcode That is, if the element did not exist, the methods return 0. */ @@ -1632,13 +2585,13 @@ public: template _Tp value(int i0, int i1, int i2, size_t* hashval=0) const; //! returns value of the specified element (nD case) template _Tp value(const int* idx, size_t* hashval=0) const; - //@} + //!@} - //@{ + //!@{ /*! Return pointer to the specified sparse matrix element if it exists - find<_Tp>(i0,...[,hashval]) is equivalent to (_const Tp*)ptr(i0,...false[,hashval]). + `find<_Tp>(i0,...[,hashval])` is equivalent to `(_const Tp*)ptr(i0,...false[,hashval])`. If the specified element does not exist, the methods return NULL. */ @@ -1650,6 +2603,7 @@ public: template const _Tp* find(int i0, int i1, int i2, size_t* hashval=0) const; //! returns pointer to the specified element (nD case) template const _Tp* find(const int* idx, size_t* hashval=0) const; + //!@} //! erases the specified element (2D case) void erase(int i0, int i1, size_t* hashval=0); @@ -1658,7 +2612,7 @@ public: //! erases the specified element (nD case) void erase(const int* idx, size_t* hashval=0); - //@{ + //!@{ /*! return the sparse matrix iterator pointing to the first sparse matrix element */ @@ -1670,7 +2624,7 @@ public: SparseMatConstIterator begin() const; //! returns the read-only sparse matrix iterator at the matrix beginning template SparseMatConstIterator_<_Tp> begin() const; - //@} + //!@} /*! return the sparse matrix iterator pointing to the element following the last sparse matrix element */ @@ -1704,19 +2658,17 @@ public: ///////////////////////////////// SparseMat_<_Tp> //////////////////////////////////// -/*! - The Template Sparse Matrix class derived from cv::SparseMat +/** @brief Template sparse n-dimensional array class derived from SparseMat - The class provides slightly more convenient operations for accessing elements. - - \code - SparseMat m; - ... - SparseMat_ m_ = (SparseMat_&)m; - m_.ref(1)++; // equivalent to m.ref(1)++; - m_.ref(2) += m_(3); // equivalent to m.ref(2) += m.value(3); - \endcode -*/ +SparseMat_ is a thin wrapper on top of SparseMat created in the same way as Mat_ . It simplifies +notation of some operations: +@code + int sz[] = {10, 20, 30}; + SparseMat_ M(3, sz); + ... + M.ref(1, 2, 3) = M(4, 5, 6) + M(7, 8, 9); +@endcode + */ template class SparseMat_ : public SparseMat { public: @@ -1852,8 +2804,7 @@ public: ////////////////////////////////// MatConstIterator_ ///////////////////////////////// -/*! - Matrix read-only iterator +/** @brief Matrix read-only iterator */ template class MatConstIterator_ : public MatConstIterator @@ -1908,8 +2859,7 @@ public: //////////////////////////////////// MatIterator_ //////////////////////////////////// -/*! - Matrix read-write iterator +/** @brief Matrix read-write iterator */ template class MatIterator_ : public MatConstIterator_<_Tp> @@ -1960,8 +2910,8 @@ public: /////////////////////////////// SparseMatConstIterator /////////////////////////////// -/*! - Read-Only Sparse Matrix Iterator. +/** @brief Read-Only Sparse Matrix Iterator. + Here is how to use the iterator to compute the sum of floating-point sparse matrix elements: \code @@ -2011,8 +2961,7 @@ public: ////////////////////////////////// SparseMatIterator ///////////////////////////////// -/*! - Read-write Sparse Matrix Iterator +/** @brief Read-write Sparse Matrix Iterator The class is similar to cv::SparseMatConstIterator, but can be used for in-place modification of the matrix elements. @@ -2046,8 +2995,7 @@ public: /////////////////////////////// SparseMatConstIterator_ ////////////////////////////// -/*! - Template Read-Only Sparse Matrix Iterator Class. +/** @brief Template Read-Only Sparse Matrix Iterator Class. This is the derived from SparseMatConstIterator class that introduces more convenient operator *() for accessing the current element. @@ -2083,8 +3031,7 @@ public: ///////////////////////////////// SparseMatIterator_ ///////////////////////////////// -/*! - Template Read-Write Sparse Matrix Iterator Class. +/** @brief Template Read-Write Sparse Matrix Iterator Class. This is the derived from cv::SparseMatConstIterator_ class that introduces more convenient operator *() for accessing the current element. @@ -2120,56 +3067,58 @@ public: /////////////////////////////////// NAryMatIterator ////////////////////////////////// -/*! - n-Dimensional Dense Matrix Iterator Class. - - The class cv::NAryMatIterator is used for iterating over one or more n-dimensional dense arrays (cv::Mat's). - - The iterator is completely different from cv::Mat_ and cv::SparseMat_ iterators. - It iterates through the slices (or planes), not the elements, where "slice" is a continuous part of the arrays. +/** @brief n-ary multi-dimensional array iterator. - Here is the example on how the iterator can be used to normalize 3D histogram: - - \code - void normalizeColorHist(Mat& hist) - { - #if 1 - // intialize iterator (the style is different from STL). - // after initialization the iterator will contain - // the number of slices or planes - // the iterator will go through - Mat* arrays[] = { &hist, 0 }; - Mat planes[1]; - NAryMatIterator it(arrays, planes); - double s = 0; - // iterate through the matrix. on each iteration - // it.planes[i] (of type Mat) will be set to the current plane of - // i-th n-dim matrix passed to the iterator constructor. - for(int p = 0; p < it.nplanes; p++, ++it) - s += sum(it.planes[0])[0]; - it = NAryMatIterator(hist); - s = 1./s; - for(int p = 0; p < it.nplanes; p++, ++it) - it.planes[0] *= s; - #elif 1 - // this is a shorter implementation of the above - // using built-in operations on Mat - double s = sum(hist)[0]; - hist.convertTo(hist, hist.type(), 1./s, 0); - #else - // and this is even shorter one - // (assuming that the histogram elements are non-negative) - normalize(hist, hist, 1, 0, NORM_L1); - #endif - } - \endcode +Use the class to implement unary, binary, and, generally, n-ary element-wise operations on +multi-dimensional arrays. Some of the arguments of an n-ary function may be continuous arrays, some +may be not. It is possible to use conventional MatIterator 's for each array but incrementing all of +the iterators after each small operations may be a big overhead. In this case consider using +NAryMatIterator to iterate through several matrices simultaneously as long as they have the same +geometry (dimensionality and all the dimension sizes are the same). On each iteration `it.planes[0]`, +`it.planes[1]`,... will be the slices of the corresponding matrices. - You can iterate through several matrices simultaneously as long as they have the same geometry - (dimensionality and all the dimension sizes are the same), which is useful for binary - and n-ary operations on such matrices. Just pass those matrices to cv::MatNDIterator. - Then, during the iteration it.planes[0], it.planes[1], ... will - be the slices of the corresponding matrices -*/ +The example below illustrates how you can compute a normalized and threshold 3D color histogram: +@code + void computeNormalizedColorHist(const Mat& image, Mat& hist, int N, double minProb) + { + const int histSize[] = {N, N, N}; + + // make sure that the histogram has a proper size and type + hist.create(3, histSize, CV_32F); + + // and clear it + hist = Scalar(0); + + // the loop below assumes that the image + // is a 8-bit 3-channel. check it. + CV_Assert(image.type() == CV_8UC3); + MatConstIterator_ it = image.begin(), + it_end = image.end(); + for( ; it != it_end; ++it ) + { + const Vec3b& pix = *it; + hist.at(pix[0]*N/256, pix[1]*N/256, pix[2]*N/256) += 1.f; + } + + minProb *= image.rows*image.cols; + Mat plane; + NAryMatIterator it(&hist, &plane, 1); + double s = 0; + // iterate through the matrix. on each iteration + // it.planes[*] (of type Mat) will be set to the current plane. + for(int p = 0; p < it.nplanes; p++, ++it) + { + threshold(it.planes[0], it.planes[0], minProb, 0, THRESH_TOZERO); + s += sum(it.planes[0])[0]; + } + + s = 1./s; + it = NAryMatIterator(&hist, &plane, 1); + for(int p = 0; p < it.nplanes; p++, ++it) + it.planes[0] *= s; + } +@endcode + */ class CV_EXPORTS NAryMatIterator { public: @@ -2249,7 +3198,52 @@ public: virtual int type(const MatExpr& expr) const; }; - +/** @brief Matrix expression representation +@anchor MatrixExpressions +This is a list of implemented matrix operations that can be combined in arbitrary complex +expressions (here A, B stand for matrices ( Mat ), s for a scalar ( Scalar ), alpha for a +real-valued scalar ( double )): +- Addition, subtraction, negation: `A+B`, `A-B`, `A+s`, `A-s`, `s+A`, `s-A`, `-A` +- Scaling: `A*alpha` +- Per-element multiplication and division: `A.mul(B)`, `A/B`, `alpha/A` +- Matrix multiplication: `A*B` +- Transposition: `A.t()` (means AT) +- Matrix inversion and pseudo-inversion, solving linear systems and least-squares problems: + `A.inv([method]) (~ A-1)`, `A.inv([method])*B (~ X: AX=B)` +- Comparison: `A cmpop B`, `A cmpop alpha`, `alpha cmpop A`, where *cmpop* is one of + `>`, `>=`, `==`, `!=`, `<=`, `<`. The result of comparison is an 8-bit single channel mask whose + elements are set to 255 (if the particular element or pair of elements satisfy the condition) or + 0. +- Bitwise logical operations: `A logicop B`, `A logicop s`, `s logicop A`, `~A`, where *logicop* is one of + `&`, `|`, `^`. +- Element-wise minimum and maximum: `min(A, B)`, `min(A, alpha)`, `max(A, B)`, `max(A, alpha)` +- Element-wise absolute value: `abs(A)` +- Cross-product, dot-product: `A.cross(B)`, `A.dot(B)` +- Any function of matrix or matrices and scalars that returns a matrix or a scalar, such as norm, + mean, sum, countNonZero, trace, determinant, repeat, and others. +- Matrix initializers ( Mat::eye(), Mat::zeros(), Mat::ones() ), matrix comma-separated + initializers, matrix constructors and operators that extract sub-matrices (see Mat description). +- Mat_() constructors to cast the result to the proper type. +@note Comma-separated initializers and probably some other operations may require additional +explicit Mat() or Mat_() constructor calls to resolve a possible ambiguity. + +Here are examples of matrix expressions: +@code + // compute pseudo-inverse of A, equivalent to A.inv(DECOMP_SVD) + SVD svd(A); + Mat pinvA = svd.vt.t()*Mat::diag(1./svd.w)*svd.u.t(); + + // compute the new vector of parameters in the Levenberg-Marquardt algorithm + x -= (A.t()*A + lambda*Mat::eye(A.cols,A.cols,A.type())).inv(DECOMP_CHOLESKY)*(A.t()*err); + + // sharpen image using "unsharp mask" algorithm + Mat blurred; double sigma = 1, threshold = 5, amount = 1; + GaussianBlur(img, blurred, Size(), sigma, sigma); + Mat lowConstrastMask = abs(img - blurred) < threshold; + Mat sharpened = img*(1+amount) + blurred*(-amount); + img.copyTo(sharpened, lowContrastMask); +@endcode +*/ class CV_EXPORTS MatExpr { public: @@ -2287,7 +3281,10 @@ public: Scalar s; }; +//! @} core_basic +//! @relates cv::MatExpr +//! @{ CV_EXPORTS MatExpr operator + (const Mat& a, const Mat& b); CV_EXPORTS MatExpr operator + (const Mat& a, const Scalar& s); CV_EXPORTS MatExpr operator + (const Scalar& s, const Mat& a); @@ -2373,8 +3370,25 @@ CV_EXPORTS MatExpr max(const Mat& a, const Mat& b); CV_EXPORTS MatExpr max(const Mat& a, double s); CV_EXPORTS MatExpr max(double s, const Mat& a); +/** @brief Calculates an absolute value of each matrix element. + +abs is a meta-function that is expanded to one of absdiff or convertScaleAbs forms: +- C = abs(A-B) is equivalent to `absdiff(A, B, C)` +- C = abs(A) is equivalent to `absdiff(A, Scalar::all(0), C)` +- C = `Mat_ >(abs(A*alpha + beta))` is equivalent to `convertScaleAbs(A, C, alpha, +beta)` + +The output matrix has the same size and the same type as the input one except for the last case, +where C is depth=CV_8U . +@param m matrix. +@sa @ref MatrixExpressions, absdiff, convertScaleAbs + */ CV_EXPORTS MatExpr abs(const Mat& m); +/** @overload +@param e matrix expression. +*/ CV_EXPORTS MatExpr abs(const MatExpr& e); +//! @} relates cv::MatExpr } // cv diff --git a/modules/core/include/opencv2/core/mat.inl.hpp b/modules/core/include/opencv2/core/mat.inl.hpp index 4f383686f6..24c6b453c1 100644 --- a/modules/core/include/opencv2/core/mat.inl.hpp +++ b/modules/core/include/opencv2/core/mat.inl.hpp @@ -50,6 +50,8 @@ namespace cv { +//! @cond IGNORED + //////////////////////// Input/Output Arrays //////////////////////// inline void _InputArray::init(int _flags, const void* _obj) @@ -3402,6 +3404,8 @@ inline void UMatData::markDeviceCopyObsolete(bool flag) inline UMatDataAutoLock::UMatDataAutoLock(UMatData* _u) : u(_u) { u->lock(); } inline UMatDataAutoLock::~UMatDataAutoLock() { u->unlock(); } +//! @endcond + } //cv #endif diff --git a/modules/core/include/opencv2/core/matx.hpp b/modules/core/include/opencv2/core/matx.hpp index a35d47be01..5f94cccccf 100644 --- a/modules/core/include/opencv2/core/matx.hpp +++ b/modules/core/include/opencv2/core/matx.hpp @@ -55,24 +55,12 @@ namespace cv { -////////////////////////////// Small Matrix /////////////////////////// - -/*! - A short numerical vector. +//! @addtogroup core_basic +//! @{ - This template class represents short numerical vectors (of 1, 2, 3, 4 ... elements) - on which you can perform basic arithmetical operations, access individual elements using [] operator etc. - The vectors are allocated on stack, as opposite to std::valarray, std::vector, cv::Mat etc., - which elements are dynamically allocated in the heap. - - The template takes 2 parameters: - -# _Tp element type - -# cn the number of elements - - In addition to the universal notation like Vec, you can use shorter aliases - for the most popular specialized variants of Vec, e.g. Vec3f ~ Vec. - */ +////////////////////////////// Small Matrix /////////////////////////// +//! @cond IGNORED struct CV_EXPORTS Matx_AddOp {}; struct CV_EXPORTS Matx_SubOp {}; struct CV_EXPORTS Matx_ScaleOp {}; @@ -80,7 +68,21 @@ struct CV_EXPORTS Matx_MulOp {}; struct CV_EXPORTS Matx_DivOp {}; struct CV_EXPORTS Matx_MatMulOp {}; struct CV_EXPORTS Matx_TOp {}; - +//! @endcond + +/** @brief Template class for small matrices whose type and size are known at compilation time + +If you need a more flexible type, use Mat . The elements of the matrix M are accessible using the +M(i,j) notation. Most of the common matrix operations (see also @ref MatrixExpressions ) are +available. To do an operation on Matx that is not implemented, you can easily convert the matrix to +Mat and backwards: +@code + Matx33f m(1, 2, 3, + 4, 5, 6, + 7, 8, 9); + cout << sum(Mat(m*m.t())) << endl; + @endcode + */ template class Matx { public: @@ -242,8 +244,7 @@ public: }; }; -/*! - Comma-separated Matrix Initializer +/** @brief Comma-separated Matrix Initializer */ template class MatxCommaInitializer { @@ -256,7 +257,7 @@ public: int idx; }; -/*! +/* Utility methods */ template static double determinant(const Matx<_Tp, m, m>& a); @@ -268,20 +269,33 @@ template static double norm(const Matx<_Tp, m, n>& M /////////////////////// Vec (used as element of multi-channel images ///////////////////// -/*! - A short numerical vector. - - This template class represents short numerical vectors (of 1, 2, 3, 4 ... elements) - on which you can perform basic arithmetical operations, access individual elements using [] operator etc. - The vectors are allocated on stack, as opposite to std::valarray, std::vector, cv::Mat etc., - which elements are dynamically allocated in the heap. - - The template takes 2 parameters: - -# _Tp element type - -# cn the number of elements - - In addition to the universal notation like Vec, you can use shorter aliases - for the most popular specialized variants of Vec, e.g. Vec3f ~ Vec. +/** @brief Template class for short numerical vectors, a partial case of Matx + +This template class represents short numerical vectors (of 1, 2, 3, 4 ... elements) on which you +can perform basic arithmetical operations, access individual elements using [] operator etc. The +vectors are allocated on stack, as opposite to std::valarray, std::vector, cv::Mat etc., which +elements are dynamically allocated in the heap. + +The template takes 2 parameters: +@tparam _Tp element type +@tparam cn the number of elements + +In addition to the universal notation like Vec, you can use shorter aliases +for the most popular specialized variants of Vec, e.g. Vec3f ~ Vec. + +It is possible to convert Vec\ to/from Point_, Vec\ to/from Point3_ , and Vec\ +to CvScalar or Scalar_. Use operator[] to access the elements of Vec. + +All the expected vector operations are also implemented: +- v1 = v2 + v3 +- v1 = v2 - v3 +- v1 = v2 \* scale +- v1 = scale \* v2 +- v1 = -v2 +- v1 += v2 and other augmenting operations +- v1 == v2, v1 != v2 +- norm(v1) (euclidean norm) +The Vec class is commonly used to describe pixel types of multi-channel arrays. See Mat for details. */ template class Vec : public Matx<_Tp, cn, 1> { @@ -337,8 +351,8 @@ public: template Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp); }; -/* \typedef - Shorter aliases for the most popular specializations of Vec +/** @name Shorter aliases for the most popular specializations of Vec + @{ */ typedef Vec Vec2b; typedef Vec Vec3b; @@ -367,6 +381,7 @@ typedef Vec Vec2d; typedef Vec Vec3d; typedef Vec Vec4d; typedef Vec Vec6d; +/** @} */ /*! traits @@ -387,8 +402,7 @@ public: }; }; -/*! - Comma-separated Vec Initializer +/** @brief Comma-separated Vec Initializer */ template class VecCommaInitializer : public MatxCommaInitializer<_Tp, m, 1> { @@ -398,12 +412,11 @@ public: Vec<_Tp, m> operator *() const; }; -/*! - Utility methods -*/ template static Vec<_Tp, cn> normalize(const Vec<_Tp, cn>& v); +//! @} core_basic +//! @cond IGNORED ///////////////////////////////////// helper classes ///////////////////////////////////// namespace internal @@ -628,7 +641,6 @@ double Matx<_Tp, m, n>::ddot(const Matx<_Tp, m, n>& M) const return s; } -/** @cond IGNORED */ template inline Matx<_Tp,m,n> Matx<_Tp,m,n>::diag(const typename Matx<_Tp,m,n>::diag_type& d) { @@ -637,7 +649,6 @@ Matx<_Tp,m,n> Matx<_Tp,m,n>::diag(const typename Matx<_Tp,m,n>::diag_type& d) M(i,i) = d(i, 0); return M; } -/** @endcond */ template template inline Matx<_Tp, m, n>::operator Matx() const @@ -1068,10 +1079,13 @@ Vec<_Tp, cn> VecCommaInitializer<_Tp, cn>::operator *() const return *this->dst; } - +//! @endcond ///////////////////////////// Matx out-of-class operators //////////////////////////////// +//! @relates cv::Matx +//! @{ + template static inline Matx<_Tp1, m, n>& operator += (Matx<_Tp1, m, n>& a, const Matx<_Tp2, m, n>& b) { @@ -1193,10 +1207,13 @@ bool operator != (const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b) return !(a == b); } - +//! @} ////////////////////////////// Vec out-of-class operators //////////////////////////////// +//! @relates cv::Vec +//! @{ + template static inline Vec<_Tp1, cn>& operator += (Vec<_Tp1, cn>& a, const Vec<_Tp2, cn>& b) { @@ -1352,6 +1369,8 @@ template inline Vec<_Tp, 4>& operator *= (Vec<_Tp, 4>& v1, const V return v1; } +//! @} + } // cv #endif // __OPENCV_CORE_MATX_HPP__ diff --git a/modules/core/include/opencv2/core/ocl.hpp b/modules/core/include/opencv2/core/ocl.hpp index 0ee492e097..3b023fb09e 100644 --- a/modules/core/include/opencv2/core/ocl.hpp +++ b/modules/core/include/opencv2/core/ocl.hpp @@ -46,6 +46,9 @@ namespace cv { namespace ocl { +//! @addtogroup core_opencl +//! @{ + CV_EXPORTS_W bool haveOpenCL(); CV_EXPORTS_W bool useOpenCL(); CV_EXPORTS_W bool haveAmdBlas(); @@ -666,6 +669,8 @@ CV_EXPORTS MatAllocator* getOpenCLAllocator(); CV_EXPORTS_W bool isPerformanceCheckBypassed(); #define OCL_PERFORMANCE_CHECK(condition) (cv::ocl::isPerformanceCheckBypassed() || (condition)) +//! @} + }} #endif diff --git a/modules/core/include/opencv2/core/ocl_genbase.hpp b/modules/core/include/opencv2/core/ocl_genbase.hpp index 4bf58693b6..d53bc1abb7 100644 --- a/modules/core/include/opencv2/core/ocl_genbase.hpp +++ b/modules/core/include/opencv2/core/ocl_genbase.hpp @@ -47,6 +47,8 @@ namespace cv namespace ocl { +//! @cond IGNORED + struct ProgramEntry { const char* name; @@ -54,6 +56,8 @@ struct ProgramEntry const char* programHash; }; +//! @endcond + } } diff --git a/modules/core/include/opencv2/core/opengl.hpp b/modules/core/include/opencv2/core/opengl.hpp index 19e5a629e5..15c635c880 100644 --- a/modules/core/include/opencv2/core/opengl.hpp +++ b/modules/core/include/opencv2/core/opengl.hpp @@ -51,12 +51,35 @@ namespace cv { namespace ogl { +/** @addtogroup core_opengl +This section describes OpenGL interoperability. + +To enable OpenGL support, configure OpenCV using CMake with WITH_OPENGL=ON . Currently OpenGL is +supported only with WIN32, GTK and Qt backends on Windows and Linux (MacOS and Android are not +supported). For GTK backend gtkglext-1.0 library is required. + +To use OpenGL functionality you should first create OpenGL context (window or frame buffer). You can +do this with namedWindow function or with other OpenGL toolkit (GLUT, for example). +*/ +//! @{ + /////////////////// OpenGL Objects /////////////////// -//! Smart pointer for OpenGL buffer memory with reference counting. +/** @brief Smart pointer for OpenGL buffer object with reference counting. + +Buffer Objects are OpenGL objects that store an array of unformatted memory allocated by the OpenGL +context. These can be used to store vertex data, pixel data retrieved from images or the +framebuffer, and a variety of other things. + +ogl::Buffer has interface similar with Mat interface and represents 2D array memory. + +ogl::Buffer supports memory transfers between host and device and also can be mapped to CUDA memory. + */ class CV_EXPORTS Buffer { public: + /** @brief The target defines how you intend to use the buffer object. + */ enum Target { ARRAY_BUFFER = 0x8892, //!< The buffer will be used as a source for vertex data @@ -72,59 +95,163 @@ public: READ_WRITE = 0x88BA }; - //! create empty buffer + /** @brief The constructors. + + Creates empty ogl::Buffer object, creates ogl::Buffer object from existed buffer ( abufId + parameter), allocates memory for ogl::Buffer object or copies from host/device memory. + */ Buffer(); - //! create buffer from existed buffer id + /** @overload + @param arows Number of rows in a 2D array. + @param acols Number of columns in a 2D array. + @param atype Array type ( CV_8UC1, ..., CV_64FC4 ). See Mat for details. + @param abufId Buffer object name. + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ Buffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease = false); + + /** @overload + @param asize 2D array size. + @param atype Array type ( CV_8UC1, ..., CV_64FC4 ). See Mat for details. + @param abufId Buffer object name. + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ Buffer(Size asize, int atype, unsigned int abufId, bool autoRelease = false); - //! create buffer + /** @overload + @param arows Number of rows in a 2D array. + @param acols Number of columns in a 2D array. + @param atype Array type ( CV_8UC1, ..., CV_64FC4 ). See Mat for details. + @param target Buffer usage. See cv::ogl::Buffer::Target . + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ Buffer(int arows, int acols, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false); + + /** @overload + @param asize 2D array size. + @param atype Array type ( CV_8UC1, ..., CV_64FC4 ). See Mat for details. + @param target Buffer usage. See cv::ogl::Buffer::Target . + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ Buffer(Size asize, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false); - //! copy from host/device memory + /** @overload + @param arr Input array (host or device memory, it can be Mat , cuda::GpuMat or std::vector ). + @param target Buffer usage. See cv::ogl::Buffer::Target . + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ explicit Buffer(InputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false); - //! create buffer + /** @brief Allocates memory for ogl::Buffer object. + + @param arows Number of rows in a 2D array. + @param acols Number of columns in a 2D array. + @param atype Array type ( CV_8UC1, ..., CV_64FC4 ). See Mat for details. + @param target Buffer usage. See cv::ogl::Buffer::Target . + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ void create(int arows, int acols, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false); + + /** @overload + @param asize 2D array size. + @param atype Array type ( CV_8UC1, ..., CV_64FC4 ). See Mat for details. + @param target Buffer usage. See cv::ogl::Buffer::Target . + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ void create(Size asize, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false); - //! release memory and delete buffer object + /** @brief Decrements the reference counter and destroys the buffer object if needed. + + The function will call setAutoRelease(true) . + */ void release(); - //! set auto release mode (if true, release will be called in object's destructor) + /** @brief Sets auto release mode. + + The lifetime of the OpenGL object is tied to the lifetime of the context. If OpenGL context was + bound to a window it could be released at any time (user can close a window). If object's destructor + is called after destruction of the context it will cause an error. Thus ogl::Buffer doesn't destroy + OpenGL object in destructor by default (all OpenGL resources will be released with OpenGL context). + This function can force ogl::Buffer destructor to destroy OpenGL object. + @param flag Auto release mode (if true, release will be called in object's destructor). + */ void setAutoRelease(bool flag); - //! copy from host/device memory (blocking) + /** @brief Copies from host/device memory to OpenGL buffer. + @param arr Input array (host or device memory, it can be Mat , cuda::GpuMat or std::vector ). + @param target Buffer usage. See cv::ogl::Buffer::Target . + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ void copyFrom(InputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false); - //! copy from device memory (non blocking) + + /** @overload */ void copyFrom(InputArray arr, cuda::Stream& stream, Target target = ARRAY_BUFFER, bool autoRelease = false); - //! copy to host/device memory (blocking) + /** @brief Copies from OpenGL buffer to host/device memory or another OpenGL buffer object. + + @param arr Destination array (host or device memory, can be Mat , cuda::GpuMat , std::vector or + ogl::Buffer ). + */ void copyTo(OutputArray arr) const; - //! copy to device memory (non blocking) + + /** @overload */ void copyTo(OutputArray arr, cuda::Stream& stream) const; - //! create copy of current buffer + /** @brief Creates a full copy of the buffer object and the underlying data. + + @param target Buffer usage for destination buffer. + @param autoRelease Auto release mode for destination buffer. + */ Buffer clone(Target target = ARRAY_BUFFER, bool autoRelease = false) const; - //! bind buffer for specified target + /** @brief Binds OpenGL buffer to the specified buffer binding point. + + @param target Binding point. See cv::ogl::Buffer::Target . + */ void bind(Target target) const; - //! unbind any buffers from specified target + /** @brief Unbind any buffers from the specified binding point. + + @param target Binding point. See cv::ogl::Buffer::Target . + */ static void unbind(Target target); - //! map to host memory + /** @brief Maps OpenGL buffer to host memory. + + mapHost maps to the client's address space the entire data store of the buffer object. The data can + then be directly read and/or written relative to the returned pointer, depending on the specified + access policy. + + A mapped data store must be unmapped with ogl::Buffer::unmapHost before its buffer object is used. + + This operation can lead to memory transfers between host and device. + + Only one buffer object can be mapped at a time. + @param access Access policy, indicating whether it will be possible to read from, write to, or both + read from and write to the buffer object's mapped data store. The symbolic constant must be + ogl::Buffer::READ_ONLY , ogl::Buffer::WRITE_ONLY or ogl::Buffer::READ_WRITE . + */ Mat mapHost(Access access); + + /** @brief Unmaps OpenGL buffer. + */ void unmapHost(); //! map to device memory (blocking) cuda::GpuMat mapDevice(); void unmapDevice(); - //! map to device memory (non blocking) + /** @brief Maps OpenGL buffer to CUDA device memory. + + This operatation doesn't copy data. Several buffer objects can be mapped to CUDA memory at a time. + + A mapped data store must be unmapped with ogl::Buffer::unmapDevice before its buffer object is used. + */ cuda::GpuMat mapDevice(cuda::Stream& stream); + + /** @brief Unmaps OpenGL buffer. + */ void unmapDevice(cuda::Stream& stream); int rows() const; @@ -150,10 +277,13 @@ private: int type_; }; -//! Smart pointer for OpenGL 2D texture memory with reference counting. +/** @brief Smart pointer for OpenGL 2D texture memory with reference counting. + */ class CV_EXPORTS Texture2D { public: + /** @brief An Image Format describes the way that the images in Textures store their data. + */ enum Format { NONE = 0, @@ -162,37 +292,91 @@ public: RGBA = 0x1908 //!< Red, Green, Blue, Alpha }; - //! create empty texture + /** @brief The constructors. + + Creates empty ogl::Texture2D object, allocates memory for ogl::Texture2D object or copies from + host/device memory. + */ Texture2D(); - //! create texture from existed texture id + /** @overload */ Texture2D(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease = false); + + /** @overload */ Texture2D(Size asize, Format aformat, unsigned int atexId, bool autoRelease = false); - //! create texture + /** @overload + @param arows Number of rows. + @param acols Number of columns. + @param aformat Image format. See cv::ogl::Texture2D::Format . + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ Texture2D(int arows, int acols, Format aformat, bool autoRelease = false); + + /** @overload + @param asize 2D array size. + @param aformat Image format. See cv::ogl::Texture2D::Format . + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ Texture2D(Size asize, Format aformat, bool autoRelease = false); - //! copy from host/device memory + /** @overload + @param arr Input array (host or device memory, it can be Mat , cuda::GpuMat or ogl::Buffer ). + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ explicit Texture2D(InputArray arr, bool autoRelease = false); - //! create texture + /** @brief Allocates memory for ogl::Texture2D object. + + @param arows Number of rows. + @param acols Number of columns. + @param aformat Image format. See cv::ogl::Texture2D::Format . + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ void create(int arows, int acols, Format aformat, bool autoRelease = false); + /** @overload + @param asize 2D array size. + @param aformat Image format. See cv::ogl::Texture2D::Format . + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ void create(Size asize, Format aformat, bool autoRelease = false); - //! release memory and delete texture object + /** @brief Decrements the reference counter and destroys the texture object if needed. + + The function will call setAutoRelease(true) . + */ void release(); - //! set auto release mode (if true, release will be called in object's destructor) + /** @brief Sets auto release mode. + + @param flag Auto release mode (if true, release will be called in object's destructor). + + The lifetime of the OpenGL object is tied to the lifetime of the context. If OpenGL context was + bound to a window it could be released at any time (user can close a window). If object's destructor + is called after destruction of the context it will cause an error. Thus ogl::Texture2D doesn't + destroy OpenGL object in destructor by default (all OpenGL resources will be released with OpenGL + context). This function can force ogl::Texture2D destructor to destroy OpenGL object. + */ void setAutoRelease(bool flag); - //! copy from host/device memory + /** @brief Copies from host/device memory to OpenGL texture. + + @param arr Input array (host or device memory, it can be Mat , cuda::GpuMat or ogl::Buffer ). + @param autoRelease Auto release mode (if true, release will be called in object's destructor). + */ void copyFrom(InputArray arr, bool autoRelease = false); - //! copy to host/device memory + /** @brief Copies from OpenGL texture to host/device memory or another OpenGL texture object. + + @param arr Destination array (host or device memory, can be Mat , cuda::GpuMat , ogl::Buffer or + ogl::Texture2D ). + @param ddepth Destination depth. + @param autoRelease Auto release mode for destination buffer (if arr is OpenGL buffer or texture). + */ void copyTo(OutputArray arr, int ddepth = CV_32F, bool autoRelease = false) const; - //! bind texture to current active texture unit for GL_TEXTURE_2D target + /** @brief Binds texture to current active texture unit for GL_TEXTURE_2D target. + */ void bind() const; int rows() const; @@ -214,30 +398,68 @@ private: Format format_; }; -//! OpenGL Arrays +/** @brief Wrapper for OpenGL Client-Side Vertex arrays. + +ogl::Arrays stores vertex data in ogl::Buffer objects. + */ class CV_EXPORTS Arrays { public: + /** @brief Default constructor + */ Arrays(); + /** @brief Sets an array of vertex coordinates. + @param vertex array with vertex coordinates, can be both host and device memory. + */ void setVertexArray(InputArray vertex); + + /** @brief Resets vertex coordinates. + */ void resetVertexArray(); + /** @brief Sets an array of vertex colors. + @param color array with vertex colors, can be both host and device memory. + */ void setColorArray(InputArray color); + + /** @brief Resets vertex colors. + */ void resetColorArray(); + /** @brief Sets an array of vertex normals. + @param normal array with vertex normals, can be both host and device memory. + */ void setNormalArray(InputArray normal); + + /** @brief Resets vertex normals. + */ void resetNormalArray(); + /** @brief Sets an array of vertex texture coordinates. + @param texCoord array with vertex texture coordinates, can be both host and device memory. + */ void setTexCoordArray(InputArray texCoord); + + /** @brief Resets vertex texture coordinates. + */ void resetTexCoordArray(); + /** @brief Releases all inner buffers. + */ void release(); + /** @brief Sets auto release mode all inner buffers. + @param flag Auto release mode. + */ void setAutoRelease(bool flag); + /** @brief Binds all vertex arrays. + */ void bind() const; + /** @brief Returns the vertex count. + */ int size() const; bool empty() const; @@ -251,13 +473,8 @@ private: /////////////////// Render Functions /////////////////// -//! render texture rectangle in window -CV_EXPORTS void render(const Texture2D& tex, - Rect_ wndRect = Rect_(0.0, 0.0, 1.0, 1.0), - Rect_ texRect = Rect_(0.0, 0.0, 1.0, 1.0)); - //! render mode -enum { +enum RenderModes { POINTS = 0x0000, LINES = 0x0001, LINE_LOOP = 0x0002, @@ -270,19 +487,52 @@ enum { POLYGON = 0x0009 }; -//! render OpenGL arrays +/** @brief Render OpenGL texture or primitives. +@param tex Texture to draw. +@param wndRect Region of window, where to draw a texture (normalized coordinates). +@param texRect Region of texture to draw (normalized coordinates). + */ +CV_EXPORTS void render(const Texture2D& tex, + Rect_ wndRect = Rect_(0.0, 0.0, 1.0, 1.0), + Rect_ texRect = Rect_(0.0, 0.0, 1.0, 1.0)); + +/** @overload +@param arr Array of privitives vertices. +@param mode Render mode. One of cv::ogl::RenderModes +@param color Color for all vertices. Will be used if arr doesn't contain color array. +*/ CV_EXPORTS void render(const Arrays& arr, int mode = POINTS, Scalar color = Scalar::all(255)); + +/** @overload +@param arr Array of privitives vertices. +@param indices Array of vertices indices (host or device memory). +@param mode Render mode. One of cv::ogl::RenderModes +@param color Color for all vertices. Will be used if arr doesn't contain color array. +*/ CV_EXPORTS void render(const Arrays& arr, InputArray indices, int mode = POINTS, Scalar color = Scalar::all(255)); +//! @} core_opengl + }} // namespace cv::ogl namespace cv { namespace cuda { -//! set a CUDA device to use OpenGL interoperability +//! @addtogroup cuda +//! @{ + +/** @brief Sets a CUDA device and initializes it for the current thread with OpenGL interoperability. + +This function should be explicitly called after OpenGL context creation and before any CUDA calls. +@param device System index of a CUDA device starting with 0. +@ingroup core_opengl + */ CV_EXPORTS void setGlDevice(int device = 0); +//! @} + }} +//! @cond IGNORED //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// @@ -429,4 +679,6 @@ bool cv::ogl::Arrays::empty() const return size_ == 0; } +//! @endcond + #endif /* __OPENCV_CORE_OPENGL_HPP__ */ diff --git a/modules/core/include/opencv2/core/operations.hpp b/modules/core/include/opencv2/core/operations.hpp index d2f49d7ee1..c572d4eef3 100644 --- a/modules/core/include/opencv2/core/operations.hpp +++ b/modules/core/include/opencv2/core/operations.hpp @@ -49,6 +49,8 @@ #include +//! @cond IGNORED + namespace cv { @@ -525,7 +527,116 @@ void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter, Ptr<_Tp>& v (Algorithm::Getter)getter, (Algorithm::Setter)setter, help); } +//! @endcond + +/****************************************************************************************\ +* Auxiliary algorithms * +\****************************************************************************************/ + +/** @brief Splits an element set into equivalency classes. + +The generic function partition implements an \f$O(N^2)\f$ algorithm for splitting a set of \f$N\f$ elements +into one or more equivalency classes, as described in + . The function returns the number of +equivalency classes. +@param _vec Set of elements stored as a vector. +@param labels Output vector of labels. It contains as many elements as vec. Each label labels[i] is +a 0-based cluster index of `vec[i]`. +@param predicate Equivalence predicate (pointer to a boolean function of two arguments or an +instance of the class that has the method bool operator()(const _Tp& a, const _Tp& b) ). The +predicate returns true when the elements are certainly in the same class, and returns false if they +may or may not be in the same class. +@ingroup core_cluster +*/ +template int +partition( const std::vector<_Tp>& _vec, std::vector& labels, + _EqPredicate predicate=_EqPredicate()) +{ + int i, j, N = (int)_vec.size(); + const _Tp* vec = &_vec[0]; + + const int PARENT=0; + const int RANK=1; + + std::vector _nodes(N*2); + int (*nodes)[2] = (int(*)[2])&_nodes[0]; + + // The first O(N) pass: create N single-vertex trees + for(i = 0; i < N; i++) + { + nodes[i][PARENT]=-1; + nodes[i][RANK] = 0; + } + + // The main O(N^2) pass: merge connected components + for( i = 0; i < N; i++ ) + { + int root = i; + + // find root + while( nodes[root][PARENT] >= 0 ) + root = nodes[root][PARENT]; + + for( j = 0; j < N; j++ ) + { + if( i == j || !predicate(vec[i], vec[j])) + continue; + int root2 = j; + + while( nodes[root2][PARENT] >= 0 ) + root2 = nodes[root2][PARENT]; + + if( root2 != root ) + { + // unite both trees + int rank = nodes[root][RANK], rank2 = nodes[root2][RANK]; + if( rank > rank2 ) + nodes[root2][PARENT] = root; + else + { + nodes[root][PARENT] = root2; + nodes[root2][RANK] += rank == rank2; + root = root2; + } + CV_Assert( nodes[root][PARENT] < 0 ); + + int k = j, parent; + + // compress the path from node2 to root + while( (parent = nodes[k][PARENT]) >= 0 ) + { + nodes[k][PARENT] = root; + k = parent; + } + + // compress the path from node to root + k = i; + while( (parent = nodes[k][PARENT]) >= 0 ) + { + nodes[k][PARENT] = root; + k = parent; + } + } + } + } + // Final O(N) pass: enumerate classes + labels.resize(N); + int nclasses = 0; + + for( i = 0; i < N; i++ ) + { + int root = i; + while( nodes[root][PARENT] >= 0 ) + root = nodes[root][PARENT]; + // re-use the rank as the class label + if( nodes[root][RANK] >= 0 ) + nodes[root][RANK] = ~nclasses++; + labels[i] = ~nodes[root][RANK]; + } + + return nclasses; +} } // cv diff --git a/modules/core/include/opencv2/core/optim.hpp b/modules/core/include/opencv2/core/optim.hpp index 87377aafe0..4f1749ec97 100644 --- a/modules/core/include/opencv2/core/optim.hpp +++ b/modules/core/include/opencv2/core/optim.hpp @@ -47,9 +47,19 @@ namespace cv { +/** @addtogroup core_optim +The algorithms in this section minimize or maximize function value within specified constraints or +without any constraints. +@{ +*/ + +/** @brief Basic interface for all solvers + */ class CV_EXPORTS MinProblemSolver : public Algorithm { public: + /** @brief Represents function being optimized + */ class CV_EXPORTS Function { public: @@ -58,54 +68,233 @@ public: virtual void getGradient(const double* /*x*/,double* /*grad*/) {} }; + /** @brief Getter for the optimized function. + + The optimized function is represented by Function interface, which requires derivatives to + implement the sole method calc(double*) to evaluate the function. + + @return Smart-pointer to an object that implements Function interface - it represents the + function that is being optimized. It can be empty, if no function was given so far. + */ virtual Ptr getFunction() const = 0; + + /** @brief Setter for the optimized function. + + *It should be called at least once before the call to* minimize(), as default value is not usable. + + @param f The new function to optimize. + */ virtual void setFunction(const Ptr& f) = 0; + /** @brief Getter for the previously set terminal criteria for this algorithm. + + @return Deep copy of the terminal criteria used at the moment. + */ virtual TermCriteria getTermCriteria() const = 0; + + /** @brief Set terminal criteria for solver. + + This method *is not necessary* to be called before the first call to minimize(), as the default + value is sensible. + + Algorithm stops when the number of function evaluations done exceeds termcrit.maxCount, when + the function values at the vertices of simplex are within termcrit.epsilon range or simplex + becomes so small that it can enclosed in a box with termcrit.epsilon sides, whatever comes + first. + @param termcrit Terminal criteria to be used, represented as cv::TermCriteria structure. + */ virtual void setTermCriteria(const TermCriteria& termcrit) = 0; - // x contain the initial point before the call and the minima position (if algorithm converged) after. x is assumed to be (something that - // after getMat() will return) row-vector or column-vector. *It's size and should - // be consisted with previous dimensionality data given, if any (otherwise, it determines dimensionality)* + /** @brief actually runs the algorithm and performs the minimization. + + The sole input parameter determines the centroid of the starting simplex (roughly, it tells + where to start), all the others (terminal criteria, initial step, function to be minimized) are + supposed to be set via the setters before the call to this method or the default values (not + always sensible) will be used. + + @param x The initial point, that will become a centroid of an initial simplex. After the algorithm + will terminate, it will be setted to the point where the algorithm stops, the point of possible + minimum. + @return The value of a function at the point found. + */ virtual double minimize(InputOutputArray x) = 0; }; -//! downhill simplex class +/** @brief This class is used to perform the non-linear non-constrained minimization of a function, + +defined on an `n`-dimensional Euclidean space, using the **Nelder-Mead method**, also known as +**downhill simplex method**. The basic idea about the method can be obtained from +. + +It should be noted, that this method, although deterministic, is rather a heuristic and therefore +may converge to a local minima, not necessary a global one. It is iterative optimization technique, +which at each step uses an information about the values of a function evaluated only at `n+1` +points, arranged as a *simplex* in `n`-dimensional space (hence the second name of the method). At +each step new point is chosen to evaluate function at, obtained value is compared with previous +ones and based on this information simplex changes it's shape , slowly moving to the local minimum. +Thus this method is using *only* function values to make decision, on contrary to, say, Nonlinear +Conjugate Gradient method (which is also implemented in optim). + +Algorithm stops when the number of function evaluations done exceeds termcrit.maxCount, when the +function values at the vertices of simplex are within termcrit.epsilon range or simplex becomes so +small that it can enclosed in a box with termcrit.epsilon sides, whatever comes first, for some +defined by user positive integer termcrit.maxCount and positive non-integer termcrit.epsilon. + +@note DownhillSolver is a derivative of the abstract interface +cv::MinProblemSolver, which in turn is derived from the Algorithm interface and is used to +encapsulate the functionality, common to all non-linear optimization algorithms in the optim +module. + +@note term criteria should meet following condition: +@code + termcrit.type == (TermCriteria::MAX_ITER + TermCriteria::EPS) && termcrit.epsilon > 0 && termcrit.maxCount > 0 +@endcode + */ class CV_EXPORTS DownhillSolver : public MinProblemSolver { public: - //! returns row-vector, even if the column-vector was given + /** @brief Returns the initial step that will be used in downhill simplex algorithm. + + @param step Initial step that will be used in algorithm. Note, that although corresponding setter + accepts column-vectors as well as row-vectors, this method will return a row-vector. + @see DownhillSolver::setInitStep + */ virtual void getInitStep(OutputArray step) const=0; - //!This should be called at least once before the first call to minimize() and step is assumed to be (something that - //! after getMat() will return) row-vector or column-vector. *It's dimensionality determines the dimensionality of a problem.* + + /** @brief Sets the initial step that will be used in downhill simplex algorithm. + + Step, together with initial point (givin in DownhillSolver::minimize) are two `n`-dimensional + vectors that are used to determine the shape of initial simplex. Roughly said, initial point + determines the position of a simplex (it will become simplex's centroid), while step determines the + spread (size in each dimension) of a simplex. To be more precise, if \f$s,x_0\in\mathbb{R}^n\f$ are + the initial step and initial point respectively, the vertices of a simplex will be: + \f$v_0:=x_0-\frac{1}{2} s\f$ and \f$v_i:=x_0+s_i\f$ for \f$i=1,2,\dots,n\f$ where \f$s_i\f$ denotes + projections of the initial step of *n*-th coordinate (the result of projection is treated to be + vector given by \f$s_i:=e_i\cdot\left\f$, where \f$e_i\f$ form canonical basis) + + @param step Initial step that will be used in algorithm. Roughly said, it determines the spread + (size in each dimension) of an initial simplex. + */ virtual void setInitStep(InputArray step)=0; - // both minRange & minError are specified by termcrit.epsilon; - // In addition, user may specify the number of iterations that the algorithm does. + /** @brief This function returns the reference to the ready-to-use DownhillSolver object. + + All the parameters are optional, so this procedure can be called even without parameters at + all. In this case, the default values will be used. As default value for terminal criteria are + the only sensible ones, MinProblemSolver::setFunction() and DownhillSolver::setInitStep() + should be called upon the obtained object, if the respective parameters were not given to + create(). Otherwise, the two ways (give parameters to createDownhillSolver() or miss them out + and call the MinProblemSolver::setFunction() and DownhillSolver::setInitStep()) are absolutely + equivalent (and will drop the same errors in the same way, should invalid input be detected). + @param f Pointer to the function that will be minimized, similarly to the one you submit via + MinProblemSolver::setFunction. + @param initStep Initial step, that will be used to construct the initial simplex, similarly to the one + you submit via MinProblemSolver::setInitStep. + @param termcrit Terminal criteria to the algorithm, similarly to the one you submit via + MinProblemSolver::setTermCriteria. + */ static Ptr create(const Ptr& f=Ptr(), InputArray initStep=Mat_(1,1,0.0), TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5000,0.000001)); }; -//! conjugate gradient method +/** @brief This class is used to perform the non-linear non-constrained minimization of a function +with known gradient, + +defined on an *n*-dimensional Euclidean space, using the **Nonlinear Conjugate Gradient method**. +The implementation was done based on the beautifully clear explanatory article [An Introduction to +the Conjugate Gradient Method Without the Agonizing +Pain](http://www.cs.cmu.edu/~quake-papers/painless-conjugate-gradient.pdf) by Jonathan Richard +Shewchuk. The method can be seen as an adaptation of a standard Conjugate Gradient method (see, for +example ) for numerically solving the +systems of linear equations. + +It should be noted, that this method, although deterministic, is rather a heuristic method and +therefore may converge to a local minima, not necessary a global one. What is even more disastrous, +most of its behaviour is ruled by gradient, therefore it essentially cannot distinguish between +local minima and maxima. Therefore, if it starts sufficiently near to the local maximum, it may +converge to it. Another obvious restriction is that it should be possible to compute the gradient of +a function at any point, thus it is preferable to have analytic expression for gradient and +computational burden should be born by the user. + +The latter responsibility is accompilished via the getGradient method of a +MinProblemSolver::Function interface (which represents function being optimized). This method takes +point a point in *n*-dimensional space (first argument represents the array of coordinates of that +point) and comput its gradient (it should be stored in the second argument as an array). + +@note class ConjGradSolver thus does not add any new methods to the basic MinProblemSolver interface. + +@note term criteria should meet following condition: +@code + termcrit.type == (TermCriteria::MAX_ITER + TermCriteria::EPS) && termcrit.epsilon > 0 && termcrit.maxCount > 0 + // or + termcrit.type == TermCriteria::MAX_ITER) && termcrit.maxCount > 0 +@endcode + */ class CV_EXPORTS ConjGradSolver : public MinProblemSolver { public: + /** @brief This function returns the reference to the ready-to-use ConjGradSolver object. + + All the parameters are optional, so this procedure can be called even without parameters at + all. In this case, the default values will be used. As default value for terminal criteria are + the only sensible ones, MinProblemSolver::setFunction() should be called upon the obtained + object, if the function was not given to create(). Otherwise, the two ways (submit it to + create() or miss it out and call the MinProblemSolver::setFunction()) are absolutely equivalent + (and will drop the same errors in the same way, should invalid input be detected). + @param f Pointer to the function that will be minimized, similarly to the one you submit via + MinProblemSolver::setFunction. + @param termcrit Terminal criteria to the algorithm, similarly to the one you submit via + MinProblemSolver::setTermCriteria. + */ static Ptr create(const Ptr& f=Ptr(), TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER+TermCriteria::EPS,5000,0.000001)); }; -//!the return codes for solveLP() function -enum +//! return codes for cv::solveLP() function +enum SolveLPResult { - SOLVELP_UNBOUNDED = -2, //problem is unbounded (target function can achieve arbitrary high values) - SOLVELP_UNFEASIBLE = -1, //problem is unfeasible (there are no points that satisfy all the constraints imposed) - SOLVELP_SINGLE = 0, //there is only one maximum for target function - SOLVELP_MULTI = 1 //there are multiple maxima for target function - the arbitrary one is returned + SOLVELP_UNBOUNDED = -2, //!< problem is unbounded (target function can achieve arbitrary high values) + SOLVELP_UNFEASIBLE = -1, //!< problem is unfeasible (there are no points that satisfy all the constraints imposed) + SOLVELP_SINGLE = 0, //!< there is only one maximum for target function + SOLVELP_MULTI = 1 //!< there are multiple maxima for target function - the arbitrary one is returned }; +/** @brief Solve given (non-integer) linear programming problem using the Simplex Algorithm (Simplex Method). + +What we mean here by "linear programming problem" (or LP problem, for short) can be formulated as: + +\f[\mbox{Maximize } c\cdot x\\ + \mbox{Subject to:}\\ + Ax\leq b\\ + x\geq 0\f] + +Where \f$c\f$ is fixed `1`-by-`n` row-vector, \f$A\f$ is fixed `m`-by-`n` matrix, \f$b\f$ is fixed `m`-by-`1` +column vector and \f$x\f$ is an arbitrary `n`-by-`1` column vector, which satisfies the constraints. + +Simplex algorithm is one of many algorithms that are designed to handle this sort of problems +efficiently. Although it is not optimal in theoretical sense (there exist algorithms that can solve +any problem written as above in polynomial type, while simplex method degenerates to exponential +time for some special cases), it is well-studied, easy to implement and is shown to work well for +real-life purposes. + +The particular implementation is taken almost verbatim from **Introduction to Algorithms, third +edition** by T. H. Cormen, C. E. Leiserson, R. L. Rivest and Clifford Stein. In particular, the +Bland's rule is used to prevent cycling. + +@param Func This row-vector corresponds to \f$c\f$ in the LP problem formulation (see above). It should +contain 32- or 64-bit floating point numbers. As a convenience, column-vector may be also submitted, +in the latter case it is understood to correspond to \f$c^T\f$. +@param Constr `m`-by-`n+1` matrix, whose rightmost column corresponds to \f$b\f$ in formulation above +and the remaining to \f$A\f$. It should containt 32- or 64-bit floating point numbers. +@param z The solution will be returned here as a column-vector - it corresponds to \f$c\f$ in the +formulation above. It will contain 64-bit floating point numbers. +@return One of cv::SolveLPResult + */ CV_EXPORTS_W int solveLP(const Mat& Func, const Mat& Constr, Mat& z); +//! @} + }// cv #endif diff --git a/modules/core/include/opencv2/core/persistence.hpp b/modules/core/include/opencv2/core/persistence.hpp index 8f515c54dd..cc98e86c5d 100644 --- a/modules/core/include/opencv2/core/persistence.hpp +++ b/modules/core/include/opencv2/core/persistence.hpp @@ -48,131 +48,268 @@ # error persistence.hpp header must be compiled as C++ #endif -// black-box structures used by FileStorage +//! @addtogroup core_c +//! @{ + +/** @brief "black box" representation of the file storage associated with a file on disk. + +Several functions that are described below take CvFileStorage\* as inputs and allow the user to +save or to load hierarchical collections that consist of scalar values, standard CXCore objects +(such as matrices, sequences, graphs), and user-defined objects. + +OpenCV can read and write data in XML () or YAML () +formats. Below is an example of 3x3 floating-point identity matrix A, stored in XML and YAML files +using CXCore functions: +XML: +@code{.xml} + + + + 3 + 3 +
f
+ 1. 0. 0. 0. 1. 0. 0. 0. 1. + + +@endcode +YAML: +@code{.yaml} + %YAML:1.0 + A: !!opencv-matrix + rows: 3 + cols: 3 + dt: f + data: [ 1., 0., 0., 0., 1., 0., 0., 0., 1.] +@endcode +As it can be seen from the examples, XML uses nested tags to represent hierarchy, while YAML uses +indentation for that purpose (similar to the Python programming language). + +The same functions can read and write data in both formats; the particular format is determined by +the extension of the opened file, ".xml" for XML files and ".yml" or ".yaml" for YAML. + */ typedef struct CvFileStorage CvFileStorage; typedef struct CvFileNode CvFileNode; +//! @} core_c + #include "opencv2/core/types.hpp" #include "opencv2/core/mat.hpp" namespace cv { +/** @addtogroup core_xml + +XML/YAML file storages. {#xml_storage} +======================= +Writing to a file storage. +-------------------------- +You can store and then restore various OpenCV data structures to/from XML () +or YAML () formats. Also, it is possible store and load arbitrarily complex +data structures, which include OpenCV data structures, as well as primitive data types (integer and +floating-point numbers and text strings) as their elements. + +Use the following procedure to write something to XML or YAML: +-# Create new FileStorage and open it for writing. It can be done with a single call to +FileStorage::FileStorage constructor that takes a filename, or you can use the default constructor +and then call FileStorage::open. Format of the file (XML or YAML) is determined from the filename +extension (".xml" and ".yml"/".yaml", respectively) +-# Write all the data you want using the streaming operator `<<`, just like in the case of STL +streams. +-# Close the file using FileStorage::release. FileStorage destructor also closes the file. + +Here is an example: +@code + #include "opencv2/opencv.hpp" + #include + + using namespace cv; + + int main(int, char** argv) + { + FileStorage fs("test.yml", FileStorage::WRITE); + + fs << "frameCount" << 5; + time_t rawtime; time(&rawtime); + fs << "calibrationDate" << asctime(localtime(&rawtime)); + Mat cameraMatrix = (Mat_(3,3) << 1000, 0, 320, 0, 1000, 240, 0, 0, 1); + Mat distCoeffs = (Mat_(5,1) << 0.1, 0.01, -0.001, 0, 0); + fs << "cameraMatrix" << cameraMatrix << "distCoeffs" << distCoeffs; + fs << "features" << "["; + for( int i = 0; i < 3; i++ ) + { + int x = rand() % 640; + int y = rand() % 480; + uchar lbp = rand() % 256; + + fs << "{:" << "x" << x << "y" << y << "lbp" << "[:"; + for( int j = 0; j < 8; j++ ) + fs << ((lbp >> j) & 1); + fs << "]" << "}"; + } + fs << "]"; + fs.release(); + return 0; + } +@endcode +The sample above stores to XML and integer, text string (calibration date), 2 matrices, and a custom +structure "feature", which includes feature coordinates and LBP (local binary pattern) value. Here +is output of the sample: +@code{.yaml} +%YAML:1.0 +frameCount: 5 +calibrationDate: "Fri Jun 17 14:09:29 2011\n" +cameraMatrix: !!opencv-matrix + rows: 3 + cols: 3 + dt: d + data: [ 1000., 0., 320., 0., 1000., 240., 0., 0., 1. ] +distCoeffs: !!opencv-matrix + rows: 5 + cols: 1 + dt: d + data: [ 1.0000000000000001e-01, 1.0000000000000000e-02, + -1.0000000000000000e-03, 0., 0. ] +features: + - { x:167, y:49, lbp:[ 1, 0, 0, 1, 1, 0, 1, 1 ] } + - { x:298, y:130, lbp:[ 0, 0, 0, 1, 0, 0, 1, 1 ] } + - { x:344, y:158, lbp:[ 1, 1, 0, 0, 0, 0, 1, 0 ] } +@endcode + +As an exercise, you can replace ".yml" with ".xml" in the sample above and see, how the +corresponding XML file will look like. + +Several things can be noted by looking at the sample code and the output: + +- The produced YAML (and XML) consists of heterogeneous collections that can be nested. There are 2 + types of collections: named collections (mappings) and unnamed collections (sequences). In mappings + each element has a name and is accessed by name. This is similar to structures and std::map in + C/C++ and dictionaries in Python. In sequences elements do not have names, they are accessed by + indices. This is similar to arrays and std::vector in C/C++ and lists, tuples in Python. + "Heterogeneous" means that elements of each single collection can have different types. + + Top-level collection in YAML/XML is a mapping. Each matrix is stored as a mapping, and the matrix + elements are stored as a sequence. Then, there is a sequence of features, where each feature is + represented a mapping, and lbp value in a nested sequence. + +- When you write to a mapping (a structure), you write element name followed by its value. When you + write to a sequence, you simply write the elements one by one. OpenCV data structures (such as + cv::Mat) are written in absolutely the same way as simple C data structures - using `<<` + operator. + +- To write a mapping, you first write the special string `{` to the storage, then write the + elements as pairs (`fs << << `) and then write the closing + `}`. + +- To write a sequence, you first write the special string `[`, then write the elements, then + write the closing `]`. + +- In YAML (but not XML), mappings and sequences can be written in a compact Python-like inline + form. In the sample above matrix elements, as well as each feature, including its lbp value, is + stored in such inline form. To store a mapping/sequence in a compact form, put `:` after the + opening character, e.g. use `{:` instead of `{` and `[:` instead of `[`. When the + data is written to XML, those extra `:` are ignored. + +Reading data from a file storage. +--------------------------------- +To read the previously written XML or YAML file, do the following: +-# Open the file storage using FileStorage::FileStorage constructor or FileStorage::open method. + In the current implementation the whole file is parsed and the whole representation of file + storage is built in memory as a hierarchy of file nodes (see FileNode) + +-# Read the data you are interested in. Use FileStorage::operator [], FileNode::operator [] + and/or FileNodeIterator. + +-# Close the storage using FileStorage::release. + +Here is how to read the file created by the code sample above: +@code + FileStorage fs2("test.yml", FileStorage::READ); + + // first method: use (type) operator on FileNode. + int frameCount = (int)fs2["frameCount"]; + + String date; + // second method: use FileNode::operator >> + fs2["calibrationDate"] >> date; + + Mat cameraMatrix2, distCoeffs2; + fs2["cameraMatrix"] >> cameraMatrix2; + fs2["distCoeffs"] >> distCoeffs2; + + cout << "frameCount: " << frameCount << endl + << "calibration date: " << date << endl + << "camera matrix: " << cameraMatrix2 << endl + << "distortion coeffs: " << distCoeffs2 << endl; + + FileNode features = fs2["features"]; + FileNodeIterator it = features.begin(), it_end = features.end(); + int idx = 0; + std::vector lbpval; + + // iterate through a sequence using FileNodeIterator + for( ; it != it_end; ++it, idx++ ) + { + cout << "feature #" << idx << ": "; + cout << "x=" << (int)(*it)["x"] << ", y=" << (int)(*it)["y"] << ", lbp: ("; + // you can also easily read numerical arrays using FileNode >> std::vector operator. + (*it)["lbp"] >> lbpval; + for( int i = 0; i < (int)lbpval.size(); i++ ) + cout << " " << (int)lbpval[i]; + cout << ")" << endl; + } + fs.release(); +@endcode + +Format specification {#format_spec} +-------------------- +`([count]{u|c|w|s|i|f|d})`... where the characters correspond to fundamental C++ types: +- `u` 8-bit unsigned number +- `c` 8-bit signed number +- `w` 16-bit unsigned number +- `s` 16-bit signed number +- `i` 32-bit signed number +- `f` single precision floating-point number +- `d` double precision floating-point number +- `r` pointer, 32 lower bits of which are written as a signed integer. The type can be used to + store structures with links between the elements. + +`count` is the optional counter of values of a given type. For example, `2if` means that each array +element is a structure of 2 integers, followed by a single-precision floating-point number. The +equivalent notations of the above specification are `iif`, `2i1f` and so forth. Other examples: `u` +means that the array consists of bytes, and `2d` means the array consists of pairs of doubles. + +@see @ref filestorage.cpp +*/ + +//! @{ + +/** @example filestorage.cpp +A complete example using the FileStorage interface +*/ + ////////////////////////// XML & YAML I/O ////////////////////////// class CV_EXPORTS FileNode; class CV_EXPORTS FileNodeIterator; -/*! - XML/YAML File Storage Class. - - The class describes an object associated with XML or YAML file. - It can be used to store data to such a file or read and decode the data. - - The storage is organized as a tree of nested sequences (or lists) and mappings. - Sequence is a heterogenious array, which elements are accessed by indices or sequentially using an iterator. - Mapping is analogue of std::map or C structure, which elements are accessed by names. - The most top level structure is a mapping. - Leaves of the file storage tree are integers, floating-point numbers and text strings. - - For example, the following code: - - \code - // open file storage for writing. Type of the file is determined from the extension - FileStorage fs("test.yml", FileStorage::WRITE); - fs << "test_int" << 5 << "test_real" << 3.1 << "test_string" << "ABCDEFGH"; - fs << "test_mat" << Mat::eye(3,3,CV_32F); - - fs << "test_list" << "[" << 0.0000000000001 << 2 << CV_PI << -3435345 << "2-502 2-029 3egegeg" << - "{:" << "month" << 12 << "day" << 31 << "year" << 1969 << "}" << "]"; - fs << "test_map" << "{" << "x" << 1 << "y" << 2 << "width" << 100 << "height" << 200 << "lbp" << "[:"; - - const uchar arr[] = {0, 1, 1, 0, 1, 1, 0, 1}; - fs.writeRaw("u", arr, (int)(sizeof(arr)/sizeof(arr[0]))); - - fs << "]" << "}"; - \endcode - - will produce the following file: - - \verbatim - %YAML:1.0 - test_int: 5 - test_real: 3.1000000000000001e+00 - test_string: ABCDEFGH - test_mat: !!opencv-matrix - rows: 3 - cols: 3 - dt: f - data: [ 1., 0., 0., 0., 1., 0., 0., 0., 1. ] - test_list: - - 1.0000000000000000e-13 - - 2 - - 3.1415926535897931e+00 - - -3435345 - - "2-502 2-029 3egegeg" - - { month:12, day:31, year:1969 } - test_map: - x: 1 - y: 2 - width: 100 - height: 200 - lbp: [ 0, 1, 1, 0, 1, 1, 0, 1 ] - \endverbatim - - and to read the file above, the following code can be used: - - \code - // open file storage for reading. - // Type of the file is determined from the content, not the extension - FileStorage fs("test.yml", FileStorage::READ); - int test_int = (int)fs["test_int"]; - double test_real = (double)fs["test_real"]; - String test_string = (String)fs["test_string"]; - - Mat M; - fs["test_mat"] >> M; - - FileNode tl = fs["test_list"]; - CV_Assert(tl.type() == FileNode::SEQ && tl.size() == 6); - double tl0 = (double)tl[0]; - int tl1 = (int)tl[1]; - double tl2 = (double)tl[2]; - int tl3 = (int)tl[3]; - String tl4 = (String)tl[4]; - CV_Assert(tl[5].type() == FileNode::MAP && tl[5].size() == 3); - - int month = (int)tl[5]["month"]; - int day = (int)tl[5]["day"]; - int year = (int)tl[5]["year"]; - - FileNode tm = fs["test_map"]; - - int x = (int)tm["x"]; - int y = (int)tm["y"]; - int width = (int)tm["width"]; - int height = (int)tm["height"]; - - int lbp_val = 0; - FileNodeIterator it = tm["lbp"].begin(); - - for(int k = 0; k < 8; k++, ++it) - lbp_val |= ((int)*it) << k; - \endcode -*/ +/** @brief XML/YAML file storage class that encapsulates all the information necessary for writing or reading +data to/from a file. + */ class CV_EXPORTS_W FileStorage { public: //! file storage mode - enum + enum Mode { - READ = 0, //! read mode - WRITE = 1, //! write mode - APPEND = 2, //! append mode - MEMORY = 4, - FORMAT_MASK = (7<<3), - FORMAT_AUTO = 0, - FORMAT_XML = (1<<3), - FORMAT_YAML = (2<<3) + READ = 0, //!< value, open the file for reading + WRITE = 1, //!< value, open the file for writing + APPEND = 2, //!< value, open the file for appending + MEMORY = 4, //!< flag, read data from source or write data to the internal buffer (which is + //!< returned by FileStorage::release) + FORMAT_MASK = (7<<3), //!< mask for format flags + FORMAT_AUTO = 0, //!< flag, auto format + FORMAT_XML = (1<<3), //!< flag, XML format + FORMAT_YAML = (2<<3) //!< flag, YAML format }; enum { @@ -181,43 +318,117 @@ public: NAME_EXPECTED = 2, INSIDE_MAP = 4 }; - //! the default constructor + + /** @brief The constructors. + + The full constructor opens the file. Alternatively you can use the default constructor and then + call FileStorage::open. + */ CV_WRAP FileStorage(); - //! the full constructor that opens file storage for reading or writing + + /** @overload + @param source Name of the file to open or the text string to read the data from. Extension of the + file (.xml or .yml/.yaml) determines its format (XML or YAML respectively). Also you can append .gz + to work with compressed files, for example myHugeMatrix.xml.gz. If both FileStorage::WRITE and + FileStorage::MEMORY flags are specified, source is used just to specify the output file format (e.g. + mydata.xml, .yml etc.). + @param flags Mode of operation. See FileStorage::Mode + @param encoding Encoding of the file. Note that UTF-16 XML encoding is not supported currently and + you should use 8-bit encoding instead of it. + */ CV_WRAP FileStorage(const String& source, int flags, const String& encoding=String()); - //! the constructor that takes pointer to the C FileStorage structure + + /** @overload */ FileStorage(CvFileStorage* fs, bool owning=true); + //! the destructor. calls release() virtual ~FileStorage(); - //! opens file storage for reading or writing. The previous storage is closed with release() + /** @brief Opens a file. + + See description of parameters in FileStorage::FileStorage. The method calls FileStorage::release + before opening the file. + @param filename Name of the file to open or the text string to read the data from. + Extension of the file (.xml or .yml/.yaml) determines its format (XML or YAML respectively). + Also you can append .gz to work with compressed files, for example myHugeMatrix.xml.gz. If both + FileStorage::WRITE and FileStorage::MEMORY flags are specified, source is used just to specify + the output file format (e.g. mydata.xml, .yml etc.). + @param flags Mode of operation. One of FileStorage::Mode + @param encoding Encoding of the file. Note that UTF-16 XML encoding is not supported currently and + you should use 8-bit encoding instead of it. + */ CV_WRAP virtual bool open(const String& filename, int flags, const String& encoding=String()); - //! returns true if the object is associated with currently opened file. + + /** @brief Checks whether the file is opened. + + @returns true if the object is associated with the current file and false otherwise. It is a + good practice to call this method after you tried to open a file. + */ CV_WRAP virtual bool isOpened() const; - //! closes the file and releases all the memory buffers + + /** @brief Closes the file and releases all the memory buffers. + + Call this method after all I/O operations with the storage are finished. + */ CV_WRAP virtual void release(); - //! closes the file, releases all the memory buffers and returns the text string + + /** @brief Closes the file and releases all the memory buffers. + + Call this method after all I/O operations with the storage are finished. If the storage was + opened for writing data and FileStorage::WRITE was specified + */ CV_WRAP virtual String releaseAndGetString(); - //! returns the first element of the top-level mapping + /** @brief Returns the first element of the top-level mapping. + @returns The first element of the top-level mapping. + */ CV_WRAP FileNode getFirstTopLevelNode() const; - //! returns the top-level mapping. YAML supports multiple streams + + /** @brief Returns the top-level mapping + @param streamidx Zero-based index of the stream. In most cases there is only one stream in the file. + However, YAML supports multiple streams and so there can be several. + @returns The top-level mapping. + */ CV_WRAP FileNode root(int streamidx=0) const; - //! returns the specified element of the top-level mapping + + /** @brief Returns the specified element of the top-level mapping. + @param nodename Name of the file node. + @returns Node with the given name. + */ FileNode operator[](const String& nodename) const; - //! returns the specified element of the top-level mapping + + /** @overload */ CV_WRAP FileNode operator[](const char* nodename) const; - //! returns pointer to the underlying C FileStorage structure + /** @brief Returns the obsolete C FileStorage structure. + @returns Pointer to the underlying C FileStorage structure + */ CvFileStorage* operator *() { return fs.get(); } - //! returns pointer to the underlying C FileStorage structure + + /** @overload */ const CvFileStorage* operator *() const { return fs.get(); } - //! writes one or more numbers of the specified format to the currently written structure + + /** @brief Writes multiple numbers. + + Writes one or more numbers of the specified format to the currently written structure. Usually it is + more convenient to use operator `<<` instead of this method. + @param fmt Specification of each array element, see @ref format_spec "format specification" + @param vec Pointer to the written array. + @param len Number of the uchar elements to write. + */ void writeRaw( const String& fmt, const uchar* vec, size_t len ); - //! writes the registered C structure (CvMat, CvMatND, CvSeq). See cvWrite() + + /** @brief Writes the registered C structure (CvMat, CvMatND, CvSeq). + @param name Name of the written object. + @param obj Pointer to the object. + @see ocvWrite for details. + */ void writeObj( const String& name, const void* obj ); - //! returns the normalized object name for the specified file name + /** @brief Returns the normalized object name for the specified name of a file. + @param filename Name of a file + @returns The normalized object name. + */ static String getDefaultObjectName(const String& filename); Ptr fs; //!< the underlying C FileStorage structure @@ -228,21 +439,23 @@ public: template<> CV_EXPORTS void DefaultDeleter::operator ()(CvFileStorage* obj) const; -/*! - File Storage Node class +/** @brief File Storage Node class. - The node is used to store each and every element of the file storage opened for reading - - from the primitive objects, such as numbers and text strings, to the complex nodes: - sequences, mappings and the registered objects. +The node is used to store each and every element of the file storage opened for reading. When +XML/YAML file is read, it is first parsed and stored in the memory as a hierarchical collection of +nodes. Each node can be a “leaf” that is contain a single number or a string, or be a collection of +other nodes. There can be named collections (mappings) where each element has a name and it is +accessed by a name, and ordered collections (sequences) where elements do not have names but rather +accessed by index. Type of the file node can be determined using FileNode::type method. - Note that file nodes are only used for navigating file storages opened for reading. - When a file storage is opened for writing, no data is stored in memory after it is written. -*/ +Note that file nodes are only used for navigating file storages opened for reading. When a file +storage is opened for writing, no data is stored in memory after it is written. + */ class CV_EXPORTS_W_SIMPLE FileNode { public: //! type of the file storage node - enum + enum Type { NONE = 0, //!< empty node INT = 1, //!< an integer @@ -259,19 +472,43 @@ public: EMPTY = 32, //!< empty structure (sequence or mapping) NAMED = 64 //!< the node has a name (i.e. it is element of a mapping) }; - //! the default constructor + /** @brief The constructors. + + These constructors are used to create a default file node, construct it from obsolete structures or + from the another file node. + */ CV_WRAP FileNode(); - //! the full constructor wrapping CvFileNode structure. + + /** @overload + @param fs Pointer to the obsolete file storage structure. + @param node File node to be used as initialization for the created file node. + */ FileNode(const CvFileStorage* fs, const CvFileNode* node); - //! the copy constructor + + /** @overload + @param node File node to be used as initialization for the created file node. + */ FileNode(const FileNode& node); - //! returns element of a mapping node + + /** @brief Returns element of a mapping node or a sequence node. + @param nodename Name of an element in the mapping node. + @returns Returns the element with the given identifier. + */ FileNode operator[](const String& nodename) const; - //! returns element of a mapping node + + /** @overload + @param nodename Name of an element in the mapping node. + */ CV_WRAP FileNode operator[](const char* nodename) const; - //! returns element of a sequence node + + /** @overload + @param i Index of an element in the sequence node. + */ CV_WRAP FileNode operator[](int i) const; - //! returns type of the node + + /** @brief Returns type of the node. + @returns Type of the node. See FileNode::Type + */ CV_WRAP int type() const; //! returns true if the node is empty @@ -316,8 +553,16 @@ public: //! returns iterator pointing to the element following the last node element FileNodeIterator end() const; - //! reads node elements to the buffer with the specified format + /** @brief Reads node elements to the buffer with the specified format. + + Usually it is more convenient to use operator `>>` instead of this method. + @param fmt Specification of each array element. See @ref format_spec "format specification" + @param vec Pointer to the destination array. + @param len Number of elements to read. If it is greater than number of remaining elements then all + of them will be read. + */ void readRaw( const String& fmt, uchar* vec, size_t len ) const; + //! reads the registered object and returns pointer to it void* readObj() const; @@ -327,20 +572,33 @@ public: }; -/*! - File Node Iterator +/** @brief used to iterate through sequences and mappings. - The class is used for iterating sequences (usually) and mappings. +A standard STL notation, with node.begin(), node.end() denoting the beginning and the end of a +sequence, stored in node. See the data reading sample in the beginning of the section. */ class CV_EXPORTS FileNodeIterator { public: - //! the default constructor + /** @brief The constructors. + + These constructors are used to create a default iterator, set it to specific element in a file node + or construct it from another iterator. + */ FileNodeIterator(); - //! the full constructor set to the ofs-th element of the node + + /** @overload + @param fs File storage for the iterator. + @param node File node for the iterator. + @param ofs Index of the element in the node. The created iterator will point to this element. + */ FileNodeIterator(const CvFileStorage* fs, const CvFileNode* node, size_t ofs=0); - //! the copy constructor + + /** @overload + @param it Iterator to be used as initialization for the created iterator. + */ FileNodeIterator(const FileNodeIterator& it); + //! returns the currently observed element FileNode operator *() const; //! accesses the currently observed element methods @@ -359,7 +617,14 @@ public: //! moves iterator backward by the specified offset (possibly negative) FileNodeIterator& operator -= (int ofs); - //! reads the next maxCount elements (or less, if the sequence/mapping last element occurs earlier) to the buffer with the specified format + /** @brief Reads node elements to the buffer with the specified format. + + Usually it is more convenient to use operator `>>` instead of this method. + @param fmt Specification of each array element. See @ref format_spec "format specification" + @param vec Pointer to the destination array. + @param maxCount Number of elements to read. If it is greater than number of remaining elements then + all of them will be read. + */ FileNodeIterator& readRaw( const String& fmt, uchar* vec, size_t maxCount=(size_t)INT_MAX ); @@ -381,10 +646,13 @@ public: size_t remaining; }; - +//! @} core_xml /////////////////// XML & YAML I/O implementation ////////////////// +//! @relates cv::FileStorage +//! @{ + CV_EXPORTS void write( FileStorage& fs, const String& name, int value ); CV_EXPORTS void write( FileStorage& fs, const String& name, float value ); CV_EXPORTS void write( FileStorage& fs, const String& name, double value ); @@ -398,6 +666,11 @@ CV_EXPORTS void writeScalar( FileStorage& fs, float value ); CV_EXPORTS void writeScalar( FileStorage& fs, double value ); CV_EXPORTS void writeScalar( FileStorage& fs, const String& value ); +//! @} + +//! @relates cv::FileNode +//! @{ + CV_EXPORTS void read(const FileNode& node, int& value, int default_value); CV_EXPORTS void read(const FileNode& node, float& value, float default_value); CV_EXPORTS void read(const FileNode& node, double& value, double default_value); @@ -458,9 +731,14 @@ static inline void read(const FileNode& node, Range& value, const Range& default value.start = temp.x; value.end = temp.y; } +//! @} +/** @brief Writes string to a file storage. +@relates cv::FileStorage + */ CV_EXPORTS FileStorage& operator << (FileStorage& fs, const String& str); +//! @cond IGNORED namespace internal { @@ -537,7 +815,10 @@ namespace internal } // internal +//! @endcond +//! @relates cv::FileStorage +//! @{ template static inline void write(FileStorage& fs, const _Tp& value) @@ -701,6 +982,10 @@ void write( FileStorage& fs, const String& name, const std::vector<_Tp>& vec ) write(fs, vec); } +//! @} FileStorage + +//! @relates cv::FileNode +//! @{ static inline void read(const FileNode& node, bool& value, bool default_value) @@ -761,7 +1046,13 @@ void read( const FileNode& node, std::vector<_Tp>& vec, const std::vector<_Tp>& } } +//! @} FileNode + +//! @relates cv::FileStorage +//! @{ +/** @brief Writes data to a file storage. + */ template static inline FileStorage& operator << (FileStorage& fs, const _Tp& value) { @@ -775,18 +1066,29 @@ FileStorage& operator << (FileStorage& fs, const _Tp& value) return fs; } +/** @brief Writes data to a file storage. + */ static inline FileStorage& operator << (FileStorage& fs, const char* str) { return (fs << String(str)); } +/** @brief Writes data to a file storage. + */ static inline FileStorage& operator << (FileStorage& fs, char* value) { return (fs << String(value)); } +//! @} FileStorage + +//! @relates cv::FileNodeIterator +//! @{ + +/** @brief Reads data from a file storage. + */ template static inline FileNodeIterator& operator >> (FileNodeIterator& it, _Tp& value) { @@ -794,6 +1096,8 @@ FileNodeIterator& operator >> (FileNodeIterator& it, _Tp& value) return ++it; } +/** @brief Reads data from a file storage. + */ template static inline FileNodeIterator& operator >> (FileNodeIterator& it, std::vector<_Tp>& vec) { @@ -802,12 +1106,21 @@ FileNodeIterator& operator >> (FileNodeIterator& it, std::vector<_Tp>& vec) return it; } +//! @} FileNodeIterator + +//! @relates cv::FileNode +//! @{ + +/** @brief Reads data from a file storage. + */ template static inline void operator >> (const FileNode& n, _Tp& value) { read( n, value, _Tp()); } +/** @brief Reads data from a file storage. + */ template static inline void operator >> (const FileNode& n, std::vector<_Tp>& vec) { @@ -815,6 +1128,10 @@ void operator >> (const FileNode& n, std::vector<_Tp>& vec) it >> vec; } +//! @} FileNode + +//! @relates cv::FileNodeIterator +//! @{ static inline bool operator == (const FileNodeIterator& it1, const FileNodeIterator& it2) @@ -841,6 +1158,10 @@ bool operator < (const FileNodeIterator& it1, const FileNodeIterator& it2) return it1.remaining > it2.remaining; } +//! @} FileNodeIterator + +//! @cond IGNORED + inline FileNode FileStorage::getFirstTopLevelNode() const { FileNode r = root(); FileNodeIterator it = r.begin(); return it != r.end() ? *it : FileNode(); } inline FileNode::FileNode() : fs(0), node(0) {} inline FileNode::FileNode(const CvFileStorage* _fs, const CvFileNode* _node) : fs(_fs), node(_node) {} @@ -865,6 +1186,8 @@ inline FileNode FileNodeIterator::operator *() const { return FileNode(fs, (con inline FileNode FileNodeIterator::operator ->() const { return FileNode(fs, (const CvFileNode*)(const void*)reader.ptr); } inline String::String(const FileNode& fn): cstr_(0), len_(0) { read(fn, *this, *this); } +//! @endcond + } // cv #endif // __OPENCV_CORE_PERSISTENCE_HPP__ diff --git a/modules/core/include/opencv2/core/private.cuda.hpp b/modules/core/include/opencv2/core/private.cuda.hpp index 6f0d90e955..d97b4511b4 100644 --- a/modules/core/include/opencv2/core/private.cuda.hpp +++ b/modules/core/include/opencv2/core/private.cuda.hpp @@ -75,6 +75,8 @@ # endif #endif +//! @cond IGNORED + namespace cv { namespace cuda { CV_EXPORTS cv::String getNppErrorMessage(int code); CV_EXPORTS cv::String getCudaDriverApiErrorMessage(int code); @@ -167,4 +169,6 @@ namespace cv { namespace cuda #endif // HAVE_CUDA +//! @endcond + #endif // __OPENCV_CORE_CUDA_PRIVATE_HPP__ diff --git a/modules/core/include/opencv2/core/private.hpp b/modules/core/include/opencv2/core/private.hpp index e4a232a1df..c9b2bf66d9 100644 --- a/modules/core/include/opencv2/core/private.hpp +++ b/modules/core/include/opencv2/core/private.hpp @@ -71,6 +71,8 @@ # endif #endif +//! @cond IGNORED + namespace cv { #ifdef HAVE_TBB @@ -301,111 +303,6 @@ typedef enum CvStatus } CvStatus; - - -/****************************************************************************************\ -* Auxiliary algorithms * -\****************************************************************************************/ - -namespace cv -{ - -// This function splits the input sequence or set into one or more equivalence classes and -// returns the vector of labels - 0-based class indexes for each element. -// predicate(a,b) returns true if the two sequence elements certainly belong to the same class. -// -// The algorithm is described in "Introduction to Algorithms" -// by Cormen, Leiserson and Rivest, the chapter "Data structures for disjoint sets" -template int -partition( const std::vector<_Tp>& _vec, std::vector& labels, - _EqPredicate predicate=_EqPredicate()) -{ - int i, j, N = (int)_vec.size(); - const _Tp* vec = &_vec[0]; - - const int PARENT=0; - const int RANK=1; - - std::vector _nodes(N*2); - int (*nodes)[2] = (int(*)[2])&_nodes[0]; - - // The first O(N) pass: create N single-vertex trees - for(i = 0; i < N; i++) - { - nodes[i][PARENT]=-1; - nodes[i][RANK] = 0; - } - - // The main O(N^2) pass: merge connected components - for( i = 0; i < N; i++ ) - { - int root = i; - - // find root - while( nodes[root][PARENT] >= 0 ) - root = nodes[root][PARENT]; - - for( j = 0; j < N; j++ ) - { - if( i == j || !predicate(vec[i], vec[j])) - continue; - int root2 = j; - - while( nodes[root2][PARENT] >= 0 ) - root2 = nodes[root2][PARENT]; - - if( root2 != root ) - { - // unite both trees - int rank = nodes[root][RANK], rank2 = nodes[root2][RANK]; - if( rank > rank2 ) - nodes[root2][PARENT] = root; - else - { - nodes[root][PARENT] = root2; - nodes[root2][RANK] += rank == rank2; - root = root2; - } - CV_Assert( nodes[root][PARENT] < 0 ); - - int k = j, parent; - - // compress the path from node2 to root - while( (parent = nodes[k][PARENT]) >= 0 ) - { - nodes[k][PARENT] = root; - k = parent; - } - - // compress the path from node to root - k = i; - while( (parent = nodes[k][PARENT]) >= 0 ) - { - nodes[k][PARENT] = root; - k = parent; - } - } - } - } - - // Final O(N) pass: enumerate classes - labels.resize(N); - int nclasses = 0; - - for( i = 0; i < N; i++ ) - { - int root = i; - while( nodes[root][PARENT] >= 0 ) - root = nodes[root][PARENT]; - // re-use the rank as the class label - if( nodes[root][RANK] >= 0 ) - nodes[root][RANK] = ~nclasses++; - labels[i] = ~nodes[root][RANK]; - } - - return nclasses; -} - -} // namespace cv +//! @endcond #endif // __OPENCV_CORE_PRIVATE_HPP__ diff --git a/modules/core/include/opencv2/core/ptr.inl.hpp b/modules/core/include/opencv2/core/ptr.inl.hpp index 989724281f..65c09d1cb4 100644 --- a/modules/core/include/opencv2/core/ptr.inl.hpp +++ b/modules/core/include/opencv2/core/ptr.inl.hpp @@ -44,6 +44,8 @@ #include +//! @cond IGNORED + namespace cv { template @@ -335,4 +337,6 @@ Ptr makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& } // namespace cv +//! @endcond + #endif // __OPENCV_CORE_PTR_INL_HPP__ diff --git a/modules/core/include/opencv2/core/traits.hpp b/modules/core/include/opencv2/core/traits.hpp index 85a5132f0e..49bc8440dd 100644 --- a/modules/core/include/opencv2/core/traits.hpp +++ b/modules/core/include/opencv2/core/traits.hpp @@ -49,16 +49,59 @@ namespace cv { -/*! - Informative template class for OpenCV "scalars". - - The class is specialized for each primitive numerical type supported by OpenCV (such as unsigned char or float), - as well as for more complex types, like cv::Complex<>, std::complex<>, cv::Vec<> etc. - The common property of all such types (called "scalars", do not confuse it with cv::Scalar_) - is that each of them is basically a tuple of numbers of the same type. Each "scalar" can be represented - by the depth id (CV_8U ... CV_64F) and the number of channels. - OpenCV matrices, 2D or nD, dense or sparse, can store "scalars", - as long as the number of channels does not exceed CV_CN_MAX. +//! @addtogroup core_basic +//! @{ + +/** @brief Template "trait" class for OpenCV primitive data types. + +A primitive OpenCV data type is one of unsigned char, bool, signed char, unsigned short, signed +short, int, float, double, or a tuple of values of one of these types, where all the values in the +tuple have the same type. Any primitive type from the list can be defined by an identifier in the +form CV_\{U|S|F}C(\), for example: uchar \~ CV_8UC1, 3-element +floating-point tuple \~ CV_32FC3, and so on. A universal OpenCV structure that is able to store a +single instance of such a primitive data type is Vec. Multiple instances of such a type can be +stored in a std::vector, Mat, Mat_, SparseMat, SparseMat_, or any other container that is able to +store Vec instances. + +The DataType class is basically used to provide a description of such primitive data types without +adding any fields or methods to the corresponding classes (and it is actually impossible to add +anything to primitive C/C++ data types). This technique is known in C++ as class traits. It is not +DataType itself that is used but its specialized versions, such as: +@code + template<> class DataType + { + typedef uchar value_type; + typedef int work_type; + typedef uchar channel_type; + enum { channel_type = CV_8U, channels = 1, fmt='u', type = CV_8U }; + }; + ... + template DataType > + { + typedef std::complex<_Tp> value_type; + typedef std::complex<_Tp> work_type; + typedef _Tp channel_type; + // DataDepth is another helper trait class + enum { depth = DataDepth<_Tp>::value, channels=2, + fmt=(channels-1)*256+DataDepth<_Tp>::fmt, + type=CV_MAKETYPE(depth, channels) }; + }; + ... +@endcode +The main purpose of this class is to convert compilation-time type information to an +OpenCV-compatible data type identifier, for example: +@code + // allocates a 30x40 floating-point matrix + Mat A(30, 40, DataType::type); + + Mat B = Mat_ >(3, 3); + // the statement below will print 6, 2 , that is depth == CV_64F, channels == 2 + cout << B.depth() << ", " << B.channels() << endl; +@endcode +So, such traits are used to tell OpenCV which data type you are working with, even if such a type is +not native to OpenCV. For example, the matrix B initialization above is compiled because OpenCV +defines the proper specialized template class DataType\ \> . This mechanism is also +useful (and used in OpenCV this way) for generic algorithms implementations. */ template class DataType { @@ -211,11 +254,10 @@ public: }; -/*! - A helper class for cv::DataType +/** @brief A helper class for cv::DataType - The class is specialized for each fundamental numerical data type supported by OpenCV. - It provides DataDepth::value constant. +The class is specialized for each fundamental numerical data type supported by OpenCV. It provides +DataDepth::value constant. */ template class DataDepth { @@ -277,6 +319,8 @@ template<> class TypeDepth typedef double value_type; }; +//! @} + } // cv #endif // __OPENCV_CORE_TRAITS_HPP__ diff --git a/modules/core/include/opencv2/core/types.hpp b/modules/core/include/opencv2/core/types.hpp index 419c047368..74bd61e5c6 100644 --- a/modules/core/include/opencv2/core/types.hpp +++ b/modules/core/include/opencv2/core/types.hpp @@ -59,10 +59,12 @@ namespace cv { +//! @addtogroup core_basic +//! @{ + //////////////////////////////// Complex ////////////////////////////// -/*! - A complex number class. +/** @brief A complex number class. The template class is similar and compatible with std::complex, however it provides slightly more convenient access to the real and imaginary parts using through the simple field access, as opposite @@ -107,12 +109,40 @@ public: //////////////////////////////// Point_ //////////////////////////////// -/*! - template 2D point class. - - The class defines a point in 2D space. Data type of the point coordinates is specified - as a template parameter. There are a few shorter aliases available for user convenience. - See cv::Point, cv::Point2i, cv::Point2f and cv::Point2d. +/** @brief Template class for 2D points specified by its coordinates `x` and `y`. + +An instance of the class is interchangeable with C structures, CvPoint and CvPoint2D32f . There is +also a cast operator to convert point coordinates to the specified type. The conversion from +floating-point coordinates to integer coordinates is done by rounding. Commonly, the conversion +uses this operation for each of the coordinates. Besides the class members listed in the +declaration above, the following operations on points are implemented: +@code + pt1 = pt2 + pt3; + pt1 = pt2 - pt3; + pt1 = pt2 * a; + pt1 = a * pt2; + pt1 = pt2 / a; + pt1 += pt2; + pt1 -= pt2; + pt1 *= a; + pt1 /= a; + double value = norm(pt); // L2 norm + pt1 == pt2; + pt1 != pt2; +@endcode +For your convenience, the following type aliases are defined: +@code + typedef Point_ Point2i; + typedef Point2i Point; + typedef Point_ Point2f; + typedef Point_ Point2d; +@endcode +Example: +@code + Point2f a(0.3f, 0.f), b(0.f, 0.4f); + Point pt = (a + b)*10.f; + cout << pt.x << ", " << pt.y << endl; +@endcode */ template class Point_ { @@ -171,13 +201,19 @@ public: //////////////////////////////// Point3_ //////////////////////////////// -/*! - template 3D point class. +/** @brief Template class for 3D points specified by its coordinates `x`, `y` and `z`. - The class defines a point in 3D space. Data type of the point coordinates is specified - as a template parameter. +An instance of the class is interchangeable with the C structure CvPoint2D32f . Similarly to +Point_ , the coordinates of 3D points can be converted to another type. The vector arithmetic and +comparison operations are also supported. - \see cv::Point3i, cv::Point3f and cv::Point3d +The following Point3_\<\> aliases are available: +@code + typedef Point3_ Point3i; + typedef Point3_ Point3f; + typedef Point3_ Point3d; +@endcode +@see cv::Point3i, cv::Point3f and cv::Point3d */ template class Point3_ { @@ -232,11 +268,18 @@ public: //////////////////////////////// Size_ //////////////////////////////// -/*! - The 2D size class +/** @brief Template class for specifying the size of an image or rectangle. - The class represents the size of a 2D rectangle, image size, matrix size etc. - Normally, cv::Size ~ cv::Size_ is used. +The class includes two members called width and height. The structure can be converted to and from +the old OpenCV structures CvSize and CvSize2D32f . The same set of arithmetic and comparison +operations as for Point_ is available. + +OpenCV defines the following Size_\<\> aliases: +@code + typedef Size_ Size2i; + typedef Size2i Size; + typedef Size_ Size2f; +@endcode */ template class Size_ { @@ -285,11 +328,48 @@ public: //////////////////////////////// Rect_ //////////////////////////////// -/*! - The 2D up-right rectangle class - - The class represents a 2D rectangle with coordinates of the specified data type. - Normally, cv::Rect ~ cv::Rect_ is used. +/** @brief Template class for 2D rectangles + +described by the following parameters: +- Coordinates of the top-left corner. This is a default interpretation of Rect_::x and Rect_::y + in OpenCV. Though, in your algorithms you may count x and y from the bottom-left corner. +- Rectangle width and height. + +OpenCV typically assumes that the top and left boundary of the rectangle are inclusive, while the +right and bottom boundaries are not. For example, the method Rect_::contains returns true if + +\f[x \leq pt.x < x+width, + y \leq pt.y < y+height\f] + +Virtually every loop over an image ROI in OpenCV (where ROI is specified by Rect_\ ) is +implemented as: +@code + for(int y = roi.y; y < roi.y + roi.height; y++) + for(int x = roi.x; x < roi.x + roi.width; x++) + { + // ... + } +@endcode +In addition to the class members, the following operations on rectangles are implemented: +- \f$\texttt{rect} = \texttt{rect} \pm \texttt{point}\f$ (shifting a rectangle by a certain offset) +- \f$\texttt{rect} = \texttt{rect} \pm \texttt{size}\f$ (expanding or shrinking a rectangle by a + certain amount) +- rect += point, rect -= point, rect += size, rect -= size (augmenting operations) +- rect = rect1 & rect2 (rectangle intersection) +- rect = rect1 | rect2 (minimum area rectangle containing rect2 and rect3 ) +- rect &= rect1, rect |= rect1 (and the corresponding augmenting operations) +- rect == rect1, rect != rect1 (rectangle comparison) + +This is an example how the partial ordering on rectangles can be established (rect1 \f$\subseteq\f$ +rect2): +@code + template inline bool + operator <= (const Rect_<_Tp>& r1, const Rect_<_Tp>& r2) + { + return (r1 & r2) == r1; + } +@endcode +For your convenience, the Rect_\<\> alias is available: cv::Rect */ template class Rect_ { @@ -349,22 +429,52 @@ public: ///////////////////////////// RotatedRect ///////////////////////////// -/*! - The rotated 2D rectangle. +/** @brief The class represents rotated (i.e. not up-right) rectangles on a plane. + +Each rectangle is specified by the center point (mass center), length of each side (represented by +cv::Size2f structure) and the rotation angle in degrees. + +The sample below demonstrates how to use RotatedRect: +@code + Mat image(200, 200, CV_8UC3, Scalar(0)); + RotatedRect rRect = RotatedRect(Point2f(100,100), Size2f(100,50), 30); - The class represents rotated (i.e. not up-right) rectangles on a plane. - Each rectangle is described by the center point (mass center), length of each side - (represented by cv::Size2f structure) and the rotation angle in degrees. + Point2f vertices[4]; + rRect.points(vertices); + for (int i = 0; i < 4; i++) + line(image, vertices[i], vertices[(i+1)%4], Scalar(0,255,0)); + + Rect brect = rRect.boundingRect(); + rectangle(image, brect, Scalar(255,0,0)); + + imshow("rectangles", image); + waitKey(0); +@endcode +![image](pics/rotatedrect.png) + +@sa CamShift, fitEllipse, minAreaRect, CvBox2D */ class CV_EXPORTS RotatedRect { public: //! various constructors RotatedRect(); + /** + @param center The rectangle mass center. + @param size Width and height of the rectangle. + @param angle The rotation angle in a clockwise direction. When the angle is 0, 90, 180, 270 etc., + the rectangle becomes an up-right rectangle. + */ RotatedRect(const Point2f& center, const Size2f& size, float angle); + /** + Any 3 end points of the RotatedRect. They must be given in order (either clockwise or + anticlockwise). + */ RotatedRect(const Point2f& point1, const Point2f& point2, const Point2f& point3); - //! returns 4 vertices of the rectangle + /** returns 4 vertices of the rectangle + @param pts The points array for storing rectangle vertices. + */ void points(Point2f pts[]) const; //! returns the minimal up-right rectangle containing the rotated rectangle Rect boundingRect() const; @@ -395,10 +505,28 @@ public: //////////////////////////////// Range ///////////////////////////////// -/*! - The 2D range class +/** @brief Template class specifying a continuous subsequence (slice) of a sequence. - This is the class used to specify a continuous subsequence, i.e. part of a contour, or a column span in a matrix. +The class is used to specify a row or a column span in a matrix ( Mat ) and for many other purposes. +Range(a,b) is basically the same as a:b in Matlab or a..b in Python. As in Python, start is an +inclusive left boundary of the range and end is an exclusive right boundary of the range. Such a +half-opened interval is usually denoted as \f$[start,end)\f$ . + +The static method Range::all() returns a special variable that means "the whole sequence" or "the +whole range", just like " : " in Matlab or " ... " in Python. All the methods and functions in +OpenCV that take Range support this special Range::all() value. But, of course, in case of your own +custom processing, you will probably have to check and handle it explicitly: +@code + void my_function(..., const Range& r, ....) + { + if(r == Range::all()) { + // process all the data + } + else { + // process [r.start, r.end) + } + } +@endcode */ class CV_EXPORTS Range { @@ -433,11 +561,11 @@ public: //////////////////////////////// Scalar_ /////////////////////////////// -/*! - The template scalar class. +/** @brief Template class for a 4-element vector derived from Vec. - This is partially specialized cv::Vec class with the number of elements = 4, i.e. a short vector of four elements. - Normally, cv::Scalar ~ cv::Scalar_ is used. +Being derived from Vec\<_Tp, 4\> , Scalar_ and Scalar can be used just as typical 4-element +vectors. In addition, they can be converted to/from CvScalar . The type Scalar is widely used in +OpenCV to pass pixel values. */ template class Scalar_ : public Vec<_Tp, 4> { @@ -489,42 +617,76 @@ public: /////////////////////////////// KeyPoint //////////////////////////////// -/*! - The Keypoint Class +/** @brief Data structure for salient point detectors. - The class instance stores a keypoint, i.e. a point feature found by one of many available keypoint detectors, such as - Harris corner detector, cv::FAST, cv::StarDetector, cv::SURF, cv::SIFT, cv::LDetector etc. +The class instance stores a keypoint, i.e. a point feature found by one of many available keypoint +detectors, such as Harris corner detector, cv::FAST, cv::StarDetector, cv::SURF, cv::SIFT, +cv::LDetector etc. - The keypoint is characterized by the 2D position, scale - (proportional to the diameter of the neighborhood that needs to be taken into account), - orientation and some other parameters. The keypoint neighborhood is then analyzed by another algorithm that builds a descriptor - (usually represented as a feature vector). The keypoints representing the same object in different images can then be matched using - cv::KDTree or another method. +The keypoint is characterized by the 2D position, scale (proportional to the diameter of the +neighborhood that needs to be taken into account), orientation and some other parameters. The +keypoint neighborhood is then analyzed by another algorithm that builds a descriptor (usually +represented as a feature vector). The keypoints representing the same object in different images +can then be matched using cv::KDTree or another method. */ class CV_EXPORTS_W_SIMPLE KeyPoint { public: //! the default constructor CV_WRAP KeyPoint(); - //! the full constructor + /** + @param _pt x & y coordinates of the keypoint + @param _size keypoint diameter + @param _angle keypoint orientation + @param _response keypoint detector response on the keypoint (that is, strength of the keypoint) + @param _octave pyramid octave in which the keypoint has been detected + @param _class_id object id + */ KeyPoint(Point2f _pt, float _size, float _angle=-1, float _response=0, int _octave=0, int _class_id=-1); - //! another form of the full constructor + /** + @param x x-coordinate of the keypoint + @param y y-coordinate of the keypoint + @param _size keypoint diameter + @param _angle keypoint orientation + @param _response keypoint detector response on the keypoint (that is, strength of the keypoint) + @param _octave pyramid octave in which the keypoint has been detected + @param _class_id object id + */ CV_WRAP KeyPoint(float x, float y, float _size, float _angle=-1, float _response=0, int _octave=0, int _class_id=-1); size_t hash() const; - //! converts vector of keypoints to vector of points + /** + This method converts vector of keypoints to vector of points or the reverse, where each keypoint is + assigned the same size and the same orientation. + + @param keypoints Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB + @param points2f Array of (x,y) coordinates of each keypoint + @param keypointIndexes Array of indexes of keypoints to be converted to points. (Acts like a mask to + convert only specified keypoints) + */ CV_WRAP static void convert(const std::vector& keypoints, CV_OUT std::vector& points2f, const std::vector& keypointIndexes=std::vector()); - //! converts vector of points to the vector of keypoints, where each keypoint is assigned the same size and the same orientation + /** @overload + @param points2f Array of (x,y) coordinates of each keypoint + @param keypoints Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB + @param size keypoint diameter + @param response keypoint detector response on the keypoint (that is, strength of the keypoint) + @param octave pyramid octave in which the keypoint has been detected + @param class_id object id + */ CV_WRAP static void convert(const std::vector& points2f, CV_OUT std::vector& keypoints, float size=1, float response=1, int octave=0, int class_id=-1); - //! computes overlap for pair of keypoints; - //! overlap is a ratio between area of keypoint regions intersection and - //! area of keypoint regions union (now keypoint region is circle) + /** + This method computes overlap for pair of keypoints. Overlap is the ratio between area of keypoint + regions' intersection and area of keypoint regions' union (considering keypoint region as circle). + If they don't overlap, we get zero. If they coincide at same location with same size, we get 1. + @param kp1 First keypoint + @param kp2 Second keypoint + */ CV_WRAP static float overlap(const KeyPoint& kp1, const KeyPoint& kp2); CV_PROP_RW Point2f pt; //!< coordinates of the keypoints @@ -558,9 +720,11 @@ public: //////////////////////////////// DMatch ///////////////////////////////// -/* - * Struct for matching: query descriptor index, train descriptor index, train image index and distance between descriptors. - */ +/** @brief Class for matching keypoint descriptors + +query descriptor index, train descriptor index, train image index, and distance between +descriptors. +*/ class CV_EXPORTS_W_SIMPLE DMatch { public: @@ -599,13 +763,18 @@ public: ///////////////////////////// TermCriteria ////////////////////////////// -/*! - Termination criteria in iterative algorithms - */ +/** @brief The class defining termination criteria for iterative algorithms. + +You can initialize it by default constructor and then override any parameters, or the structure may +be fully initialized using the advanced variant of the constructor. +*/ class CV_EXPORTS TermCriteria { public: - enum + /** + Criteria type, can be one of: COUNT, EPS or COUNT + EPS + */ + enum Type { COUNT=1, //!< the maximum number of iterations or elements to compute MAX_ITER=COUNT, //!< ditto @@ -614,7 +783,11 @@ public: //! default constructor TermCriteria(); - //! full constructor + /** + @param type The type of termination criteria, one of TermCriteria::Type + @param maxCount The maximum number of iterations or elements to compute. + @param epsilon The desired accuracy or change in parameters at which the iterative algorithm stops. + */ TermCriteria(int type, int maxCount, double epsilon); int type; //!< the type of termination criteria: COUNT, EPS or COUNT + EPS @@ -623,9 +796,15 @@ public: }; +//! @} core_basic ///////////////////////// raster image moments ////////////////////////// +//! @addtogroup imgproc_shape +//! @{ + +/** @brief struct returned by cv::moments + */ class CV_EXPORTS_W_MAP Moments { public: @@ -639,12 +818,20 @@ public: ////! the conversion to CvMoments //operator CvMoments() const; - //! spatial moments + //! @name spatial moments + //! @{ CV_PROP_RW double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; - //! central moments + //! @} + + //! @name central moments + //! @{ CV_PROP_RW double mu20, mu11, mu02, mu30, mu21, mu12, mu03; - //! central normalized moments + //! @} + + //! @name central normalized moments + //! @{ CV_PROP_RW double nu20, nu11, nu02, nu30, nu21, nu12, nu03; + //! @} }; template<> class DataType @@ -664,7 +851,9 @@ public: typedef Vec vec_type; }; +//! @} imgproc_shape +//! @cond IGNORED ///////////////////////////////////////////////////////////////////////// ///////////////////////////// Implementation //////////////////////////// @@ -2002,6 +2191,8 @@ inline TermCriteria::TermCriteria(int _type, int _maxCount, double _epsilon) : type(_type), maxCount(_maxCount), epsilon(_epsilon) {} +//! @endcond + } // cv #endif //__OPENCV_CORE_TYPES_HPP__ diff --git a/modules/core/include/opencv2/core/types_c.h b/modules/core/include/opencv2/core/types_c.h index ecf5f597c7..e824701801 100644 --- a/modules/core/include/opencv2/core/types_c.h +++ b/modules/core/include/opencv2/core/types_c.h @@ -101,10 +101,15 @@ # include "opencv2/core.hpp" #endif -/* CvArr* is used to pass arbitrary - * array-like data structures - * into functions where the particular - * array type is recognized at runtime: +/** @addtogroup core_c + @{ +*/ + +/** @brief This is the "metatype" used *only* as a function parameter. + +It denotes that the function accepts arrays of multiple types, such as IplImage*, CvMat* or even +CvSeq* sometimes. The particular array type is determined at runtime by analyzing the first 4 +bytes of the header. In C++ interface the role of CvArr is played by InputArray and OutputArray. */ typedef void CvArr; @@ -126,19 +131,20 @@ Cv64suf; typedef int CVStatus; +/** @see cv::Error::Code */ enum { - CV_StsOk= 0, /* everithing is ok */ - CV_StsBackTrace= -1, /* pseudo error for back trace */ - CV_StsError= -2, /* unknown /unspecified error */ - CV_StsInternal= -3, /* internal error (bad state) */ - CV_StsNoMem= -4, /* insufficient memory */ - CV_StsBadArg= -5, /* function arg/param is bad */ - CV_StsBadFunc= -6, /* unsupported function */ - CV_StsNoConv= -7, /* iter. didn't converge */ - CV_StsAutoTrace= -8, /* tracing */ - CV_HeaderIsNull= -9, /* image header is NULL */ - CV_BadImageSize= -10, /* image size is invalid */ - CV_BadOffset= -11, /* offset is invalid */ + CV_StsOk= 0, /**< everithing is ok */ + CV_StsBackTrace= -1, /**< pseudo error for back trace */ + CV_StsError= -2, /**< unknown /unspecified error */ + CV_StsInternal= -3, /**< internal error (bad state) */ + CV_StsNoMem= -4, /**< insufficient memory */ + CV_StsBadArg= -5, /**< function arg/param is bad */ + CV_StsBadFunc= -6, /**< unsupported function */ + CV_StsNoConv= -7, /**< iter. didn't converge */ + CV_StsAutoTrace= -8, /**< tracing */ + CV_HeaderIsNull= -9, /**< image header is NULL */ + CV_BadImageSize= -10, /**< image size is invalid */ + CV_BadOffset= -11, /**< offset is invalid */ CV_BadDataPtr= -12, /**/ CV_BadStep= -13, /**/ CV_BadModelOrChSeq= -14, /**/ @@ -154,26 +160,26 @@ enum { CV_BadCOI= -24, /**/ CV_BadROISize= -25, /**/ CV_MaskIsTiled= -26, /**/ - CV_StsNullPtr= -27, /* null pointer */ - CV_StsVecLengthErr= -28, /* incorrect vector length */ - CV_StsFilterStructContentErr= -29, /* incorr. filter structure content */ - CV_StsKernelStructContentErr= -30, /* incorr. transform kernel content */ - CV_StsFilterOffsetErr= -31, /* incorrect filter offset value */ - CV_StsBadSize= -201, /* the input/output structure size is incorrect */ - CV_StsDivByZero= -202, /* division by zero */ - CV_StsInplaceNotSupported= -203, /* in-place operation is not supported */ - CV_StsObjectNotFound= -204, /* request can't be completed */ - CV_StsUnmatchedFormats= -205, /* formats of input/output arrays differ */ - CV_StsBadFlag= -206, /* flag is wrong or not supported */ - CV_StsBadPoint= -207, /* bad CvPoint */ - CV_StsBadMask= -208, /* bad format of mask (neither 8uC1 nor 8sC1)*/ - CV_StsUnmatchedSizes= -209, /* sizes of input/output structures do not match */ - CV_StsUnsupportedFormat= -210, /* the data format/type is not supported by the function*/ - CV_StsOutOfRange= -211, /* some of parameters are out of range */ - CV_StsParseError= -212, /* invalid syntax/structure of the parsed file */ - CV_StsNotImplemented= -213, /* the requested function/feature is not implemented */ - CV_StsBadMemBlock= -214, /* an allocated block has been corrupted */ - CV_StsAssert= -215, /* assertion failed */ + CV_StsNullPtr= -27, /**< null pointer */ + CV_StsVecLengthErr= -28, /**< incorrect vector length */ + CV_StsFilterStructContentErr= -29, /**< incorr. filter structure content */ + CV_StsKernelStructContentErr= -30, /**< incorr. transform kernel content */ + CV_StsFilterOffsetErr= -31, /**< incorrect filter offset value */ + CV_StsBadSize= -201, /**< the input/output structure size is incorrect */ + CV_StsDivByZero= -202, /**< division by zero */ + CV_StsInplaceNotSupported= -203, /**< in-place operation is not supported */ + CV_StsObjectNotFound= -204, /**< request can't be completed */ + CV_StsUnmatchedFormats= -205, /**< formats of input/output arrays differ */ + CV_StsBadFlag= -206, /**< flag is wrong or not supported */ + CV_StsBadPoint= -207, /**< bad CvPoint */ + CV_StsBadMask= -208, /**< bad format of mask (neither 8uC1 nor 8sC1)*/ + CV_StsUnmatchedSizes= -209, /**< sizes of input/output structures do not match */ + CV_StsUnsupportedFormat= -210, /**< the data format/type is not supported by the function*/ + CV_StsOutOfRange= -211, /**< some of parameters are out of range */ + CV_StsParseError= -212, /**< invalid syntax/structure of the parsed file */ + CV_StsNotImplemented= -213, /**< the requested function/feature is not implemented */ + CV_StsBadMemBlock= -214, /**< an allocated block has been corrupted */ + CV_StsAssert= -215, /**< assertion failed */ CV_GpuNotSupported= -216, CV_GpuApiCallError= -217, CV_OpenGlNotSupported= -218, @@ -190,12 +196,12 @@ enum { #define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t)) -/* min & max without jumps */ +/** min & max without jumps */ #define CV_IMIN(a, b) ((a) ^ (((a)^(b)) & (((a) < (b)) - 1))) #define CV_IMAX(a, b) ((a) ^ (((a)^(b)) & (((a) > (b)) - 1))) -/* absolute value without jumps */ +/** absolute value without jumps */ #ifndef __cplusplus # define CV_IABS(a) (((a) ^ ((a) < 0 ? -1 : 0)) - ((a) < 0 ? -1 : 0)) #else @@ -214,13 +220,27 @@ typedef uint64 CvRNG; #define CV_RNG_COEFF 4164903690U +/** @brief Initializes a random number generator state. + +The function initializes a random number generator and returns the state. The pointer to the state +can be then passed to the cvRandInt, cvRandReal and cvRandArr functions. In the current +implementation a multiply-with-carry generator is used. +@param seed 64-bit value used to initiate a random sequence +@sa the C++ class RNG replaced CvRNG. + */ CV_INLINE CvRNG cvRNG( int64 seed CV_DEFAULT(-1)) { CvRNG rng = seed ? (uint64)seed : (uint64)(int64)-1; return rng; } -/* Return random 32-bit unsigned integer: */ +/** @brief Returns a 32-bit unsigned integer and updates RNG. + +The function returns a uniformly-distributed random 32-bit unsigned integer and updates the RNG +state. It is similar to the rand() function from the C runtime library, except that OpenCV functions +always generates a 32-bit random number, regardless of the platform. +@param rng CvRNG state initialized by cvRNG. + */ CV_INLINE unsigned cvRandInt( CvRNG* rng ) { uint64 temp = *rng; @@ -229,7 +249,12 @@ CV_INLINE unsigned cvRandInt( CvRNG* rng ) return (unsigned)temp; } -/* Returns random floating-point number between 0 and 1: */ +/** @brief Returns a floating-point random number and updates RNG. + +The function returns a uniformly-distributed random floating-point number between 0 and 1 (1 is not +included). +@param rng RNG state initialized by cvRNG + */ CV_INLINE double cvRandReal( CvRNG* rng ) { return cvRandInt(rng)*2.3283064365386962890625e-10 /* 2^-32 */; @@ -276,40 +301,48 @@ CV_INLINE double cvRandReal( CvRNG* rng ) #define IPL_BORDER_REFLECT 2 #define IPL_BORDER_WRAP 3 +/** The IplImage is taken from the Intel Image Processing Library, in which the format is native. OpenCV +only supports a subset of possible IplImage formats, as outlined in the parameter list above. + +In addition to the above restrictions, OpenCV handles ROIs differently. OpenCV functions require +that the image size or ROI size of all source and destination images match exactly. On the other +hand, the Intel Image Processing Library processes the area of intersection between the source and +destination images (or ROIs), allowing them to vary independently. +*/ typedef struct #ifdef __cplusplus CV_EXPORTS #endif _IplImage { - int nSize; /* sizeof(IplImage) */ - int ID; /* version (=0)*/ - int nChannels; /* Most of OpenCV functions support 1,2,3 or 4 channels */ - int alphaChannel; /* Ignored by OpenCV */ - int depth; /* Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16S, + int nSize; /**< sizeof(IplImage) */ + int ID; /**< version (=0)*/ + int nChannels; /**< Most of OpenCV functions support 1,2,3 or 4 channels */ + int alphaChannel; /**< Ignored by OpenCV */ + int depth; /**< Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16S, IPL_DEPTH_32S, IPL_DEPTH_32F and IPL_DEPTH_64F are supported. */ - char colorModel[4]; /* Ignored by OpenCV */ - char channelSeq[4]; /* ditto */ - int dataOrder; /* 0 - interleaved color channels, 1 - separate color channels. + char colorModel[4]; /**< Ignored by OpenCV */ + char channelSeq[4]; /**< ditto */ + int dataOrder; /**< 0 - interleaved color channels, 1 - separate color channels. cvCreateImage can only create interleaved images */ - int origin; /* 0 - top-left origin, + int origin; /**< 0 - top-left origin, 1 - bottom-left origin (Windows bitmaps style). */ - int align; /* Alignment of image rows (4 or 8). + int align; /**< Alignment of image rows (4 or 8). OpenCV ignores it and uses widthStep instead. */ - int width; /* Image width in pixels. */ - int height; /* Image height in pixels. */ - struct _IplROI *roi; /* Image ROI. If NULL, the whole image is selected. */ - struct _IplImage *maskROI; /* Must be NULL. */ - void *imageId; /* " " */ - struct _IplTileInfo *tileInfo; /* " " */ - int imageSize; /* Image data size in bytes + int width; /**< Image width in pixels. */ + int height; /**< Image height in pixels. */ + struct _IplROI *roi; /**< Image ROI. If NULL, the whole image is selected. */ + struct _IplImage *maskROI; /**< Must be NULL. */ + void *imageId; /**< " " */ + struct _IplTileInfo *tileInfo; /**< " " */ + int imageSize; /**< Image data size in bytes (==image->height*image->widthStep in case of interleaved data)*/ - char *imageData; /* Pointer to aligned image data. */ - int widthStep; /* Size of aligned image row in bytes. */ - int BorderMode[4]; /* Ignored by OpenCV. */ - int BorderConst[4]; /* Ditto. */ - char *imageDataOrigin; /* Pointer to very origin of image data + char *imageData; /**< Pointer to aligned image data. */ + int widthStep; /**< Size of aligned image row in bytes. */ + int BorderMode[4]; /**< Ignored by OpenCV. */ + int BorderConst[4]; /**< Ditto. */ + char *imageDataOrigin; /**< Pointer to very origin of image data (not necessarily aligned) - needed for correct deallocation */ @@ -324,7 +357,7 @@ typedef struct _IplTileInfo IplTileInfo; typedef struct _IplROI { - int coi; /* 0 - no COI (all channels are selected), 1 - 0th channel is selected ...*/ + int coi; /**< 0 - no COI (all channels are selected), 1 - 0th channel is selected ...*/ int xOffset; int yOffset; int width; @@ -359,7 +392,7 @@ IplConvKernelFP; #endif/*HAVE_IPL*/ -/* extra border mode */ +/** extra border mode */ #define IPL_BORDER_REFLECT_101 4 #define IPL_BORDER_TRANSPARENT 5 @@ -372,11 +405,11 @@ IplConvKernelFP; #define CV_IS_IMAGE(img) \ (CV_IS_IMAGE_HDR(img) && ((IplImage*)img)->imageData != NULL) -/* for storing double-precision +/** for storing double-precision floating point data in IplImage's */ #define IPL_DEPTH_64F 64 -/* get reference to pixel at (col,row), +/** get reference to pixel at (col,row), for multi-channel images (col) should be multiplied by number of channels */ #define CV_IMAGE_ELEM( image, elemtype, row, col ) \ (((elemtype*)((image)->imageData + (image)->widthStep*(row)))[(col)]) @@ -392,6 +425,17 @@ IplConvKernelFP; #define CV_MAT_MAGIC_VAL 0x42420000 #define CV_TYPE_NAME_MAT "opencv-matrix" +/** Matrix elements are stored row by row. Element (i, j) (i - 0-based row index, j - 0-based column +index) of a matrix can be retrieved or modified using CV_MAT_ELEM macro: + + uchar pixval = CV_MAT_ELEM(grayimg, uchar, i, j) + CV_MAT_ELEM(cameraMatrix, float, 0, 2) = image.width*0.5f; + +To access multiple-channel matrices, you can use +CV_MAT_ELEM(matrix, type, i, j\*nchannels + channel_idx). + +@deprecated CvMat is now obsolete; consider using Mat instead. + */ typedef struct CvMat { int type; @@ -474,7 +518,7 @@ CvMat; (CV_16S<<24)+(CV_32S<<28)) >> ((((depth) & 0xF0) >> 2) + \ (((depth) & IPL_DEPTH_SIGN) ? 20 : 0))) & 15) -/* Inline constructor. No data is allocated internally!!! +/** Inline constructor. No data is allocated internally!!! * (Use together with cvCreateData, or use cvCreateMat instead to * get a matrix with allocated data): */ @@ -517,7 +561,15 @@ inline CvMat::CvMat(const cv::Mat& m) #define CV_MAT_ELEM( mat, elemtype, row, col ) \ (*(elemtype*)CV_MAT_ELEM_PTR_FAST( mat, row, col, sizeof(elemtype))) +/** @brief Returns the particular element of single-channel floating-point matrix. +The function is a fast replacement for cvGetReal2D in the case of single-channel floating-point +matrices. It is faster because it is inline, it does fewer checks for array type and array element +type, and it checks for the row and column ranges only in debug mode. +@param mat Input matrix +@param row The zero-based index of row +@param col The zero-based index of column + */ CV_INLINE double cvmGet( const CvMat* mat, int row, int col ) { int type; @@ -535,7 +587,16 @@ CV_INLINE double cvmGet( const CvMat* mat, int row, int col ) } } +/** @brief Sets a specific element of a single-channel floating-point matrix. +The function is a fast replacement for cvSetReal2D in the case of single-channel floating-point +matrices. It is faster because it is inline, it does fewer checks for array type and array element +type, and it checks for the row and column ranges only in debug mode. +@param mat The matrix +@param row The zero-based index of row +@param col The zero-based index of column +@param value The new value of the matrix element + */ CV_INLINE void cvmSet( CvMat* mat, int row, int col, double value ) { int type; @@ -571,6 +632,9 @@ CV_INLINE int cvIplDepth( int type ) #define CV_MAX_DIM 32 #define CV_MAX_DIM_HEAP 1024 +/** + @deprecated consider using cv::Mat instead + */ typedef struct #ifdef __cplusplus CV_EXPORTS @@ -686,14 +750,14 @@ typedef int CvHistType; #define CV_HIST_MAGIC_VAL 0x42450000 #define CV_HIST_UNIFORM_FLAG (1 << 10) -/* indicates whether bin ranges are set already or not */ +/** indicates whether bin ranges are set already or not */ #define CV_HIST_RANGES_FLAG (1 << 11) #define CV_HIST_ARRAY 0 #define CV_HIST_SPARSE 1 #define CV_HIST_TREE CV_HIST_SPARSE -/* should be used as a parameter only, +/** should be used as a parameter only, it turns to CV_HIST_UNIFORM_FLAG of hist->type */ #define CV_HIST_UNIFORM 1 @@ -701,9 +765,9 @@ typedef struct CvHistogram { int type; CvArr* bins; - float thresh[CV_MAX_DIM][2]; /* For uniform histograms. */ - float** thresh2; /* For non-uniform histograms. */ - CvMatND mat; /* Embedded matrix header for array histograms. */ + float thresh[CV_MAX_DIM][2]; /**< For uniform histograms. */ + float** thresh2; /**< For non-uniform histograms. */ + CvMatND mat; /**< Embedded matrix header for array histograms. */ } CvHistogram; @@ -726,7 +790,7 @@ CvHistogram; \****************************************************************************************/ /*************************************** CvRect *****************************************/ - +/** @sa Rect_ */ typedef struct CvRect { int x; @@ -744,6 +808,7 @@ typedef struct CvRect } CvRect; +/** constructs CvRect structure. */ CV_INLINE CvRect cvRect( int x, int y, int width, int height ) { CvRect r; @@ -781,9 +846,11 @@ CV_INLINE CvRect cvROIToRect( IplROI roi ) #define CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER #define CV_TERMCRIT_EPS 2 +/** @sa TermCriteria + */ typedef struct CvTermCriteria { - int type; /* may be combination of + int type; /**< may be combination of CV_TERMCRIT_ITER CV_TERMCRIT_EPS */ int max_iter; @@ -827,7 +894,7 @@ typedef struct CvPoint } CvPoint; - +/** constructs CvPoint structure. */ CV_INLINE CvPoint cvPoint( int x, int y ) { CvPoint p; @@ -854,7 +921,7 @@ typedef struct CvPoint2D32f } CvPoint2D32f; - +/** constructs CvPoint2D32f structure. */ CV_INLINE CvPoint2D32f cvPoint2D32f( double x, double y ) { CvPoint2D32f p; @@ -865,13 +932,13 @@ CV_INLINE CvPoint2D32f cvPoint2D32f( double x, double y ) return p; } - +/** converts CvPoint to CvPoint2D32f. */ CV_INLINE CvPoint2D32f cvPointTo32f( CvPoint point ) { return cvPoint2D32f( (float)point.x, (float)point.y ); } - +/** converts CvPoint2D32f to CvPoint. */ CV_INLINE CvPoint cvPointFrom32f( CvPoint2D32f point ) { CvPoint ipt; @@ -898,7 +965,7 @@ typedef struct CvPoint3D32f } CvPoint3D32f; - +/** constructs CvPoint3D32f structure. */ CV_INLINE CvPoint3D32f cvPoint3D32f( double x, double y, double z ) { CvPoint3D32f p; @@ -918,7 +985,7 @@ typedef struct CvPoint2D64f } CvPoint2D64f; - +/** constructs CvPoint2D64f structure.*/ CV_INLINE CvPoint2D64f cvPoint2D64f( double x, double y ) { CvPoint2D64f p; @@ -938,7 +1005,7 @@ typedef struct CvPoint3D64f } CvPoint3D64f; - +/** constructs CvPoint3D64f structure. */ CV_INLINE CvPoint3D64f cvPoint3D64f( double x, double y, double z ) { CvPoint3D64f p; @@ -968,6 +1035,7 @@ typedef struct CvSize } CvSize; +/** constructs CvSize structure. */ CV_INLINE CvSize cvSize( int width, int height ) { CvSize s; @@ -993,7 +1061,7 @@ typedef struct CvSize2D32f } CvSize2D32f; - +/** constructs CvSize2D32f structure. */ CV_INLINE CvSize2D32f cvSize2D32f( double width, double height ) { CvSize2D32f s; @@ -1004,12 +1072,14 @@ CV_INLINE CvSize2D32f cvSize2D32f( double width, double height ) return s; } +/** @sa RotatedRect + */ typedef struct CvBox2D { - CvPoint2D32f center; /* Center of the box. */ - CvSize2D32f size; /* Box width and length. */ - float angle; /* Angle between the horizontal axis */ - /* and the first side (i.e. length) in degrees */ + CvPoint2D32f center; /**< Center of the box. */ + CvSize2D32f size; /**< Box width and length. */ + float angle; /**< Angle between the horizontal axis */ + /**< and the first side (i.e. length) in degrees */ #ifdef __cplusplus CvBox2D(CvPoint2D32f c = CvPoint2D32f(), CvSize2D32f s = CvSize2D32f(), float a = 0) : center(c), size(s), angle(a) {} @@ -1020,10 +1090,10 @@ typedef struct CvBox2D CvBox2D; -/* Line iterator state: */ +/** Line iterator state: */ typedef struct CvLineIterator { - /* Pointer to the current point: */ + /** Pointer to the current point: */ uchar* ptr; /* Bresenham algorithm state: */ @@ -1065,7 +1135,8 @@ CV_INLINE CvSlice cvSlice( int start, int end ) /************************************* CvScalar *****************************************/ - +/** @sa Scalar_ + */ typedef struct CvScalar { double val[4]; @@ -1134,11 +1205,11 @@ CvMemBlock; typedef struct CvMemStorage { int signature; - CvMemBlock* bottom; /* First allocated block. */ - CvMemBlock* top; /* Current memory block - top of the stack. */ - struct CvMemStorage* parent; /* We get new blocks from parent as needed. */ - int block_size; /* Block size. */ - int free_space; /* Remaining free space in current block. */ + CvMemBlock* bottom; /**< First allocated block. */ + CvMemBlock* top; /**< Current memory block - top of the stack. */ + struct CvMemStorage* parent; /**< We get new blocks from parent as needed. */ + int block_size; /**< Block size. */ + int free_space; /**< Remaining free space in current block. */ } CvMemStorage; @@ -1159,38 +1230,38 @@ CvMemStoragePos; typedef struct CvSeqBlock { - struct CvSeqBlock* prev; /* Previous sequence block. */ - struct CvSeqBlock* next; /* Next sequence block. */ - int start_index; /* Index of the first element in the block + */ - /* sequence->first->start_index. */ - int count; /* Number of elements in the block. */ - schar* data; /* Pointer to the first element of the block. */ + struct CvSeqBlock* prev; /**< Previous sequence block. */ + struct CvSeqBlock* next; /**< Next sequence block. */ + int start_index; /**< Index of the first element in the block + */ + /**< sequence->first->start_index. */ + int count; /**< Number of elements in the block. */ + schar* data; /**< Pointer to the first element of the block. */ } CvSeqBlock; #define CV_TREE_NODE_FIELDS(node_type) \ - int flags; /* Miscellaneous flags. */ \ - int header_size; /* Size of sequence header. */ \ - struct node_type* h_prev; /* Previous sequence. */ \ - struct node_type* h_next; /* Next sequence. */ \ - struct node_type* v_prev; /* 2nd previous sequence. */ \ - struct node_type* v_next /* 2nd next sequence. */ - -/* + int flags; /**< Miscellaneous flags. */ \ + int header_size; /**< Size of sequence header. */ \ + struct node_type* h_prev; /**< Previous sequence. */ \ + struct node_type* h_next; /**< Next sequence. */ \ + struct node_type* v_prev; /**< 2nd previous sequence. */ \ + struct node_type* v_next /**< 2nd next sequence. */ + +/** Read/Write sequence. Elements can be dynamically inserted to or deleted from the sequence. */ #define CV_SEQUENCE_FIELDS() \ CV_TREE_NODE_FIELDS(CvSeq); \ - int total; /* Total number of elements. */ \ - int elem_size; /* Size of sequence element in bytes. */ \ - schar* block_max; /* Maximal bound of the last block. */ \ - schar* ptr; /* Current write pointer. */ \ - int delta_elems; /* Grow seq this many at a time. */ \ - CvMemStorage* storage; /* Where the seq is stored. */ \ - CvSeqBlock* free_blocks; /* Free blocks list. */ \ - CvSeqBlock* first; /* Pointer to the first sequence block. */ + int total; /**< Total number of elements. */ \ + int elem_size; /**< Size of sequence element in bytes. */ \ + schar* block_max; /**< Maximal bound of the last block. */ \ + schar* ptr; /**< Current write pointer. */ \ + int delta_elems; /**< Grow seq this many at a time. */ \ + CvMemStorage* storage; /**< Where the seq is stored. */ \ + CvSeqBlock* free_blocks; /**< Free blocks list. */ \ + CvSeqBlock* first; /**< Pointer to the first sequence block. */ typedef struct CvSeq { @@ -1202,8 +1273,7 @@ CvSeq; #define CV_TYPE_NAME_SEQ_TREE "opencv-sequence-tree" /*************************************** Set ********************************************/ -/* - Set. +/** @brief Set Order is not preserved. There can be gaps between sequence elements. After the element has been inserted it stays in the same place all the time. The MSB(most-significant or sign bit) of the first field (flags) is 0 iff the element exists. @@ -1233,28 +1303,30 @@ CvSet; #define CV_SET_ELEM_IDX_MASK ((1 << 26) - 1) #define CV_SET_ELEM_FREE_FLAG (1 << (sizeof(int)*8-1)) -/* Checks whether the element pointed by ptr belongs to a set or not */ +/** Checks whether the element pointed by ptr belongs to a set or not */ #define CV_IS_SET_ELEM( ptr ) (((CvSetElem*)(ptr))->flags >= 0) /************************************* Graph ********************************************/ -/* - We represent a graph as a set of vertices. - Vertices contain their adjacency lists (more exactly, pointers to first incoming or - outcoming edge (or 0 if isolated vertex)). Edges are stored in another set. - There is a singly-linked list of incoming/outcoming edges for each vertex. +/** @name Graph + +We represent a graph as a set of vertices. Vertices contain their adjacency lists (more exactly, +pointers to first incoming or outcoming edge (or 0 if isolated vertex)). Edges are stored in +another set. There is a singly-linked list of incoming/outcoming edges for each vertex. + +Each edge consists of: - Each edge consists of +- Two pointers to the starting and ending vertices (vtx[0] and vtx[1] respectively). - o Two pointers to the starting and ending vertices - (vtx[0] and vtx[1] respectively). + A graph may be oriented or not. In the latter case, edges between vertex i to vertex j are not +distinguished during search operations. - A graph may be oriented or not. In the latter case, edges between - vertex i to vertex j are not distinguished during search operations. +- Two pointers to next edges for the starting and ending vertices, where next[0] points to the +next edge in the vtx[0] adjacency list and next[1] points to the next edge in the vtx[1] +adjacency list. - o Two pointers to next edges for the starting and ending vertices, where - next[0] points to the next edge in the vtx[0] adjacency list and - next[1] points to the next edge in the vtx[1] adjacency list. +@see CvGraphEdge, CvGraphVtx, CvGraphVtx2D, CvGraph +@{ */ #define CV_GRAPH_EDGE_FIELDS() \ int flags; \ @@ -1287,7 +1359,7 @@ typedef struct CvGraphVtx2D } CvGraphVtx2D; -/* +/** Graph is "derived" from the set (this is set a of vertices) and includes another set (edges) */ @@ -1303,6 +1375,8 @@ CvGraph; #define CV_TYPE_NAME_GRAPH "opencv-graph" +/** @} */ + /*********************************** Chain/Countour *************************************/ typedef struct CvChain @@ -1342,45 +1416,45 @@ typedef CvContour CvPoint2DSeq; #define CV_SEQ_ELTYPE_BITS 12 #define CV_SEQ_ELTYPE_MASK ((1 << CV_SEQ_ELTYPE_BITS) - 1) -#define CV_SEQ_ELTYPE_POINT CV_32SC2 /* (x,y) */ -#define CV_SEQ_ELTYPE_CODE CV_8UC1 /* freeman code: 0..7 */ +#define CV_SEQ_ELTYPE_POINT CV_32SC2 /**< (x,y) */ +#define CV_SEQ_ELTYPE_CODE CV_8UC1 /**< freeman code: 0..7 */ #define CV_SEQ_ELTYPE_GENERIC 0 #define CV_SEQ_ELTYPE_PTR CV_USRTYPE1 -#define CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR /* &(x,y) */ -#define CV_SEQ_ELTYPE_INDEX CV_32SC1 /* #(x,y) */ -#define CV_SEQ_ELTYPE_GRAPH_EDGE 0 /* &next_o, &next_d, &vtx_o, &vtx_d */ -#define CV_SEQ_ELTYPE_GRAPH_VERTEX 0 /* first_edge, &(x,y) */ -#define CV_SEQ_ELTYPE_TRIAN_ATR 0 /* vertex of the binary tree */ -#define CV_SEQ_ELTYPE_CONNECTED_COMP 0 /* connected component */ -#define CV_SEQ_ELTYPE_POINT3D CV_32FC3 /* (x,y,z) */ +#define CV_SEQ_ELTYPE_PPOINT CV_SEQ_ELTYPE_PTR /**< &(x,y) */ +#define CV_SEQ_ELTYPE_INDEX CV_32SC1 /**< #(x,y) */ +#define CV_SEQ_ELTYPE_GRAPH_EDGE 0 /**< &next_o, &next_d, &vtx_o, &vtx_d */ +#define CV_SEQ_ELTYPE_GRAPH_VERTEX 0 /**< first_edge, &(x,y) */ +#define CV_SEQ_ELTYPE_TRIAN_ATR 0 /**< vertex of the binary tree */ +#define CV_SEQ_ELTYPE_CONNECTED_COMP 0 /**< connected component */ +#define CV_SEQ_ELTYPE_POINT3D CV_32FC3 /**< (x,y,z) */ #define CV_SEQ_KIND_BITS 2 #define CV_SEQ_KIND_MASK (((1 << CV_SEQ_KIND_BITS) - 1)<flags & CV_SEQ_ELTYPE_MASK) #define CV_SEQ_KIND( seq ) ((seq)->flags & CV_SEQ_KIND_MASK ) -/* flag checking */ +/** flag checking */ #define CV_IS_SEQ_INDEX( seq ) ((CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_INDEX) && \ (CV_SEQ_KIND(seq) == CV_SEQ_KIND_GENERIC)) @@ -1414,7 +1488,7 @@ typedef CvContour CvPoint2DSeq; #define CV_IS_SEQ_HOLE( seq ) (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0) #define CV_IS_SEQ_SIMPLE( seq ) 1 -/* type checking macros */ +/** type checking macros */ #define CV_IS_SEQ_POINT_SET( seq ) \ ((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) == CV_32FC2)) @@ -1455,11 +1529,11 @@ typedef CvContour CvPoint2DSeq; #define CV_SEQ_WRITER_FIELDS() \ int header_size; \ - CvSeq* seq; /* the sequence written */ \ - CvSeqBlock* block; /* current block */ \ - schar* ptr; /* pointer to free space */ \ - schar* block_min; /* pointer to the beginning of block*/\ - schar* block_max; /* pointer to the end of block */ + CvSeq* seq; /**< the sequence written */ \ + CvSeqBlock* block; /**< current block */ \ + schar* ptr; /**< pointer to free space */ \ + schar* block_min; /**< pointer to the beginning of block*/\ + schar* block_max; /**< pointer to the end of block */ typedef struct CvSeqWriter { @@ -1470,13 +1544,13 @@ CvSeqWriter; #define CV_SEQ_READER_FIELDS() \ int header_size; \ - CvSeq* seq; /* sequence, beign read */ \ - CvSeqBlock* block; /* current block */ \ - schar* ptr; /* pointer to element be read next */ \ - schar* block_min; /* pointer to the beginning of block */\ - schar* block_max; /* pointer to the end of block */ \ - int delta_index;/* = seq->first->start_index */ \ - schar* prev_elem; /* pointer to previous element */ + CvSeq* seq; /**< sequence, beign read */ \ + CvSeqBlock* block; /**< current block */ \ + schar* ptr; /**< pointer to element be read next */ \ + schar* block_min; /**< pointer to the beginning of block */\ + schar* block_max; /**< pointer to the end of block */ \ + int delta_index;/**< = seq->first->start_index */ \ + schar* prev_elem; /**< pointer to previous element */ typedef struct CvSeqReader { @@ -1489,7 +1563,7 @@ CvSeqReader; /****************************************************************************************/ #define CV_SEQ_ELEM( seq, elem_type, index ) \ -/* assert gives some guarantee that parameter is valid */ \ +/** assert gives some guarantee that parameter is valid */ \ ( assert(sizeof((seq)->first[0]) == sizeof(CvSeqBlock) && \ (seq)->elem_size == sizeof(elem_type)), \ (elem_type*)((seq)->first && (unsigned)index < \ @@ -1498,7 +1572,7 @@ CvSeqReader; cvGetSeqElem( (CvSeq*)(seq), (index) ))) #define CV_GET_SEQ_ELEM( elem_type, seq, index ) CV_SEQ_ELEM( (seq), elem_type, (index) ) -/* Add element to sequence: */ +/** Add element to sequence: */ #define CV_WRITE_SEQ_ELEM_VAR( elem_ptr, writer ) \ { \ if( (writer).ptr >= (writer).block_max ) \ @@ -1522,7 +1596,7 @@ CvSeqReader; } -/* Move reader position forward: */ +/** Move reader position forward: */ #define CV_NEXT_SEQ_ELEM( elem_size, reader ) \ { \ if( ((reader).ptr += (elem_size)) >= (reader).block_max ) \ @@ -1532,7 +1606,7 @@ CvSeqReader; } -/* Move reader position backward: */ +/** Move reader position backward: */ #define CV_PREV_SEQ_ELEM( elem_size, reader ) \ { \ if( ((reader).ptr -= (elem_size)) < (reader).block_min ) \ @@ -1541,7 +1615,7 @@ CvSeqReader; } \ } -/* Read element and move read position forward: */ +/** Read element and move read position forward: */ #define CV_READ_SEQ_ELEM( elem, reader ) \ { \ assert( (reader).seq->elem_size == sizeof(elem)); \ @@ -1549,7 +1623,7 @@ CvSeqReader; CV_NEXT_SEQ_ELEM( sizeof(elem), reader ) \ } -/* Read element and move read position backward: */ +/** Read element and move read position backward: */ #define CV_REV_READ_SEQ_ELEM( elem, reader ) \ { \ assert( (reader).seq->elem_size == sizeof(elem)); \ @@ -1586,7 +1660,7 @@ CvSeqReader; /************ Graph macros ************/ -/* Return next graph edge for given vertex: */ +/** Return next graph edge for given vertex: */ #define CV_NEXT_GRAPH_EDGE( edge, vertex ) \ (assert((edge)->vtx[0] == (vertex) || (edge)->vtx[1] == (vertex)), \ (edge)->next[(edge)->vtx[1] == (vertex)]) @@ -1597,10 +1671,10 @@ CvSeqReader; * Data structures for persistence (a.k.a serialization) functionality * \****************************************************************************************/ -/* "black box" file storage */ +/** "black box" file storage */ typedef struct CvFileStorage CvFileStorage; -/* Storage flags: */ +/** Storage flags: */ #define CV_STORAGE_READ 0 #define CV_STORAGE_WRITE 1 #define CV_STORAGE_WRITE_TEXT CV_STORAGE_WRITE @@ -1612,14 +1686,21 @@ typedef struct CvFileStorage CvFileStorage; #define CV_STORAGE_FORMAT_XML 8 #define CV_STORAGE_FORMAT_YAML 16 -/* List of attributes: */ +/** @brief List of attributes. : + +In the current implementation, attributes are used to pass extra parameters when writing user +objects (see cvWrite). XML attributes inside tags are not supported, aside from the object type +specification (type_id attribute). +@see cvAttrList, cvAttrValue + */ typedef struct CvAttrList { - const char** attr; /* NULL-terminated array of (attribute_name,attribute_value) pairs. */ - struct CvAttrList* next; /* Pointer to next chunk of the attributes list. */ + const char** attr; /**< NULL-terminated array of (attribute_name,attribute_value) pairs. */ + struct CvAttrList* next; /**< Pointer to next chunk of the attributes list. */ } CvAttrList; +/** initializes CvAttrList structure */ CV_INLINE CvAttrList cvAttrList( const char** attr CV_DEFAULT(NULL), CvAttrList* next CV_DEFAULT(NULL) ) { @@ -1639,15 +1720,15 @@ struct CvTypeInfo; #define CV_NODE_FLOAT CV_NODE_REAL #define CV_NODE_STR 3 #define CV_NODE_STRING CV_NODE_STR -#define CV_NODE_REF 4 /* not used */ +#define CV_NODE_REF 4 /**< not used */ #define CV_NODE_SEQ 5 #define CV_NODE_MAP 6 #define CV_NODE_TYPE_MASK 7 #define CV_NODE_TYPE(flags) ((flags) & CV_NODE_TYPE_MASK) -/* file node flags */ -#define CV_NODE_FLOW 8 /* Used only for writing structures in YAML format. */ +/** file node flags */ +#define CV_NODE_FLOW 8 /** 0) ? fixed_size : 1]; }; -//! Sets/resets the break-on-error mode. +/** @brief Sets/resets the break-on-error mode. -/*! - When the break-on-error mode is set, the default error handler - issues a hardware exception, which can make debugging more convenient. +When the break-on-error mode is set, the default error handler issues a hardware exception, which +can make debugging more convenient. - \return the previous state +\return the previous state */ CV_EXPORTS bool setBreakOnError(bool flag); @@ -158,9 +159,9 @@ extern "C" typedef int (*ErrorCallback)( int status, const char* func_name, const char* err_msg, const char* file_name, int line, void* userdata ); -//! Sets the new error handler and the optional user data. -/*! +/** @brief Sets the new error handler and the optional user data. + The function sets the new error handler, called from cv::error(). \param errCallback the new error handler. If NULL, the default error handler is used. @@ -171,124 +172,194 @@ extern "C" typedef int (*ErrorCallback)( int status, const char* func_name, */ CV_EXPORTS ErrorCallback redirectError( ErrorCallback errCallback, void* userdata=0, void** prevUserdata=0); +/** @brief Returns a text string formatted using the printf-like expression. + +The function acts like sprintf but forms and returns an STL string. It can be used to form an error +message in the Exception constructor. +@param fmt printf-compatible formatting specifiers. + */ CV_EXPORTS String format( const char* fmt, ... ); CV_EXPORTS String tempfile( const char* suffix = 0); CV_EXPORTS void glob(String pattern, std::vector& result, bool recursive = false); + +/** @brief OpenCV will try to set the number of threads for the next parallel region. + +If threads == 0, OpenCV will disable threading optimizations and run all it's functions +sequentially. Passing threads \< 0 will reset threads number to system default. This function must +be called outside of parallel region. + +OpenCV will try to run it's functions with specified threads number, but some behaviour differs from +framework: +- `TBB` – User-defined parallel constructions will run with the same threads number, if + another does not specified. If late on user creates own scheduler, OpenCV will be use it. +- `OpenMP` – No special defined behaviour. +- `Concurrency` – If threads == 1, OpenCV will disable threading optimizations and run it's + functions sequentially. +- `GCD` – Supports only values \<= 0. +- `C=` – No special defined behaviour. +@param nthreads Number of threads used by OpenCV. +@sa getNumThreads, getThreadNum + */ CV_EXPORTS void setNumThreads(int nthreads); + +/** @brief Returns the number of threads used by OpenCV for parallel regions. + +Always returns 1 if OpenCV is built without threading support. + +The exact meaning of return value depends on the threading framework used by OpenCV library: +- `TBB` – The number of threads, that OpenCV will try to use for parallel regions. If there is + any tbb::thread_scheduler_init in user code conflicting with OpenCV, then function returns + default number of threads used by TBB library. +- `OpenMP` – An upper bound on the number of threads that could be used to form a new team. +- `Concurrency` – The number of threads, that OpenCV will try to use for parallel regions. +- `GCD` – Unsupported; returns the GCD thread pool limit (512) for compatibility. +- `C=` – The number of threads, that OpenCV will try to use for parallel regions, if before + called setNumThreads with threads \> 0, otherwise returns the number of logical CPUs, + available for the process. +@sa setNumThreads, getThreadNum + */ CV_EXPORTS int getNumThreads(); + +/** @brief Returns the index of the currently executed thread within the current parallel region. Always +returns 0 if called outside of parallel region. + +The exact meaning of return value depends on the threading framework used by OpenCV library: +- `TBB` – Unsupported with current 4.1 TBB release. May be will be supported in future. +- `OpenMP` – The thread number, within the current team, of the calling thread. +- `Concurrency` – An ID for the virtual processor that the current context is executing on (0 + for master thread and unique number for others, but not necessary 1,2,3,...). +- `GCD` – System calling thread's ID. Never returns 0 inside parallel region. +- `C=` – The index of the current parallel task. +@sa setNumThreads, getNumThreads + */ CV_EXPORTS int getThreadNum(); +/** @brief Returns full configuration time cmake output. + +Returned value is raw cmake output including version control system revision, compiler version, +compiler flags, enabled modules and third party libraries, etc. Output format depends on target +architecture. + */ CV_EXPORTS_W const String& getBuildInformation(); -//! Returns the number of ticks. +/** @brief Returns the number of ticks. -/*! - The function returns the number of ticks since the certain event (e.g. when the machine was turned on). - It can be used to initialize cv::RNG or to measure a function execution time by reading the tick count - before and after the function call. The granularity of ticks depends on the hardware and OS used. Use - cv::getTickFrequency() to convert ticks to seconds. -*/ +The function returns the number of ticks after the certain event (for example, when the machine was +turned on). It can be used to initialize RNG or to measure a function execution time by reading the +tick count before and after the function call. See also the tick frequency. + */ CV_EXPORTS_W int64 getTickCount(); -/*! - Returns the number of ticks per seconds. - - The function returns the number of ticks (as returned by cv::getTickCount()) per second. - The following code computes the execution time in milliseconds: +/** @brief Returns the number of ticks per second. - \code - double exec_time = (double)getTickCount(); - // do something ... - exec_time = ((double)getTickCount() - exec_time)*1000./getTickFrequency(); - \endcode -*/ +The function returns the number of ticks per second. That is, the following code computes the +execution time in seconds: +@code + double t = (double)getTickCount(); + // do something ... + t = ((double)getTickCount() - t)/getTickFrequency(); +@endcode + */ CV_EXPORTS_W double getTickFrequency(); -/*! - Returns the number of CPU ticks. - - On platforms where the feature is available, the function returns the number of CPU ticks - since the certain event (normally, the system power-on moment). Using this function - one can accurately measure the execution time of very small code fragments, - for which cv::getTickCount() granularity is not enough. -*/ +/** @brief Returns the number of CPU ticks. + +The function returns the current number of CPU ticks on some architectures (such as x86, x64, +PowerPC). On other platforms the function is equivalent to getTickCount. It can also be used for +very accurate time measurements, as well as for RNG initialization. Note that in case of multi-CPU +systems a thread, from which getCPUTickCount is called, can be suspended and resumed at another CPU +with its own counter. So, theoretically (and practically) the subsequent calls to the function do +not necessary return the monotonously increasing values. Also, since a modern CPU varies the CPU +frequency depending on the load, the number of CPU clocks spent in some code cannot be directly +converted to time units. Therefore, getTickCount is generally a preferable solution for measuring +execution time. + */ CV_EXPORTS_W int64 getCPUTickCount(); -//! Available CPU features. Currently, the following features are recognized: -enum { - CPU_MMX = 1, - CPU_SSE = 2, - CPU_SSE2 = 3, - CPU_SSE3 = 4, - CPU_SSSE3 = 5, - CPU_SSE4_1 = 6, - CPU_SSE4_2 = 7, - CPU_POPCNT = 8, - CPU_AVX = 10, - CPU_NEON = 11 - }; -// remember to keep this list identical to the one in cvdef.h - -/*! - Returns SSE etc. support status - - The function returns true if certain hardware features are available. - - \note {Note that the function output is not static. Once you called cv::useOptimized(false), - most of the hardware acceleration is disabled and thus the function will returns false, - until you call cv::useOptimized(true)} +/** @brief Available CPU features. + +remember to keep this list identical to the one in cvdef.h */ +enum CpuFeatures { + CPU_MMX = 1, + CPU_SSE = 2, + CPU_SSE2 = 3, + CPU_SSE3 = 4, + CPU_SSSE3 = 5, + CPU_SSE4_1 = 6, + CPU_SSE4_2 = 7, + CPU_POPCNT = 8, + CPU_AVX = 10, + CPU_NEON = 11 +}; + +/** @brief Returns true if the specified feature is supported by the host hardware. + +The function returns true if the host hardware supports the specified feature. When user calls +setUseOptimized(false), the subsequent calls to checkHardwareSupport() will return false until +setUseOptimized(true) is called. This way user can dynamically switch on and off the optimized code +in OpenCV. +@param feature The feature of interest, one of cv::CpuFeatures + */ CV_EXPORTS_W bool checkHardwareSupport(int feature); -//! returns the number of CPUs (including hyper-threading) +/** @brief Returns the number of logical CPUs available for the process. + */ CV_EXPORTS_W int getNumberOfCPUs(); -/*! - Aligns pointer by the certain number of bytes +/** @brief Aligns a pointer to the specified number of bytes. - This small inline function aligns the pointer by the certian number of bytes by shifting - it forward by 0 or a positive offset. -*/ +The function returns the aligned pointer of the same type as the input pointer: +\f[\texttt{(\_Tp*)(((size\_t)ptr + n-1) \& -n)}\f] +@param ptr Aligned pointer. +@param n Alignment size that must be a power of two. + */ template static inline _Tp* alignPtr(_Tp* ptr, int n=(int)sizeof(_Tp)) { return (_Tp*)(((size_t)ptr + n-1) & -n); } -/*! - Aligns buffer size by the certain number of bytes +/** @brief Aligns a buffer size to the specified number of bytes. - This small inline function aligns a buffer size by the certian number of bytes by enlarging it. -*/ +The function returns the minimum number that is greater or equal to sz and is divisible by n : +\f[\texttt{(sz + n-1) \& -n}\f] +@param sz Buffer size to align. +@param n Alignment size that must be a power of two. + */ static inline size_t alignSize(size_t sz, int n) { CV_DbgAssert((n & (n - 1)) == 0); // n is a power of 2 return (sz + n-1) & -n; } -/*! - Turns on/off available optimization +/** @brief Enables or disables the optimized code. - The function turns on or off the optimized code in OpenCV. Some optimization can not be enabled - or disabled, but, for example, most of SSE code in OpenCV can be temporarily turned on or off this way. +The function can be used to dynamically turn on and off optimized code (code that uses SSE2, AVX, +and other instructions on the platforms that support it). It sets a global flag that is further +checked by OpenCV functions. Since the flag is not checked in the inner OpenCV loops, it is only +safe to call the function on the very top level in your application where you can be sure that no +other OpenCV function is currently executed. - \note{Since optimization may imply using special data structures, it may be unsafe - to call this function anywhere in the code. Instead, call it somewhere at the top level.} -*/ +By default, the optimized code is enabled unless you disable it in CMake. The current status can be +retrieved using useOptimized. +@param onoff The boolean flag specifying whether the optimized code should be used (onoff=true) +or not (onoff=false). + */ CV_EXPORTS_W void setUseOptimized(bool onoff); -/*! - Returns the current optimization status +/** @brief Returns the status of optimized code usage. - The function returns the current optimization status, which is controlled by cv::setUseOptimized(). -*/ +The function returns true if the optimized code is enabled. Otherwise, it returns false. + */ CV_EXPORTS_W bool useOptimized(); static inline size_t getElemSize(int type) { return CV_ELEM_SIZE(type); } /////////////////////////////// Parallel Primitives ////////////////////////////////// -// a base body class +/** @brief Base class for parallel data processors +*/ class CV_EXPORTS ParallelLoopBody { public: @@ -296,6 +367,8 @@ public: virtual void operator() (const Range& range) const = 0; }; +/** @brief Parallel data processor +*/ CV_EXPORTS void parallel_for_(const Range& range, const ParallelLoopBody& body, double nstripes=-1.); /////////////////////////////// forEach method of cv::Mat //////////////////////////// @@ -451,8 +524,58 @@ private: virtual void deleteDataInstance(void* data) const { delete (T*)data; } }; -// The CommandLineParser class is designed for command line arguments parsing +/** @brief designed for command line arguments parsing + +The sample below demonstrates how to use CommandLineParser: +@code + CommandLineParser parser(argc, argv, keys); + parser.about("Application name v1.0.0"); + if (parser.has("help")) + { + parser.printMessage(); + return 0; + } + + int N = parser.get("N"); + double fps = parser.get("fps"); + String path = parser.get("path"); + + use_time_stamp = parser.has("timestamp"); + + String img1 = parser.get(0); + String img2 = parser.get(1); + + int repeat = parser.get(2); + + if (!parser.check()) + { + parser.printErrors(); + return 0; + } +@endcode +Syntax: +@code + const String keys = + "{help h usage ? | | print this message }" + "{@image1 | | image1 for compare }" + "{@image2 | | image2 for compare }" + "{@repeat |1 | number }" + "{path |. | path to file }" + "{fps | -1.0 | fps for output video }" + "{N count |100 | count of objects }" + "{ts timestamp | | use time stamp }" + ; +@endcode +Use: +@code + # ./app -N=200 1.png 2.jpg 19 -ts + + # ./app -fps=aaa + ERRORS: + Exception: can not convert: [aaa] to [double] +@endcode + */ class CV_EXPORTS CommandLineParser { public: @@ -497,6 +620,10 @@ protected: Impl* impl; }; +//! @} core_utils + +//! @cond IGNORED + /////////////////////////////// AutoBuffer implementation //////////////////////////////////////// template inline @@ -615,6 +742,8 @@ template<> inline std::string CommandLineParser::get(const String& } #endif // OPENCV_NOSTL +//! @endcond + } //namespace cv #endif //__OPENCV_CORE_UTILITY_H__ diff --git a/modules/core/include/opencv2/core/wimage.hpp b/modules/core/include/opencv2/core/wimage.hpp index c7afa8c5de..ef9d39833a 100644 --- a/modules/core/include/opencv2/core/wimage.hpp +++ b/modules/core/include/opencv2/core/wimage.hpp @@ -1,4 +1,4 @@ -/////////////////////////////////////////////////////////////////////////////// +/*M////////////////////////////////////////////////////////////////////////////// // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // // By downloading, copying, installing or using the software you agree to @@ -36,67 +36,9 @@ // and on any theory of liability, whether in contract, strict liability, // or tort (including negligence or otherwise) arising in any way out of // the use of this software, even if advised of the possibility of such damage. - - ///////////////////////////////////////////////////////////////////////////////// -// -// Image class which provides a thin layer around an IplImage. The goals -// of the class design are: -// 1. All the data has explicit ownership to avoid memory leaks -// 2. No hidden allocations or copies for performance. -// 3. Easy access to OpenCV methods (which will access IPP if available) -// 4. Can easily treat external data as an image -// 5. Easy to create images which are subsets of other images -// 6. Fast pixel access which can take advantage of number of channels -// if known at compile time. -// -// The WImage class is the image class which provides the data accessors. -// The 'W' comes from the fact that it is also a wrapper around the popular -// but inconvenient IplImage class. A WImage can be constructed either using a -// WImageBuffer class which allocates and frees the data, -// or using a WImageView class which constructs a subimage or a view into -// external data. The view class does no memory management. Each class -// actually has two versions, one when the number of channels is known at -// compile time and one when it isn't. Using the one with the number of -// channels specified can provide some compile time optimizations by using the -// fact that the number of channels is a constant. -// -// We use the convention (c,r) to refer to column c and row r with (0,0) being -// the upper left corner. This is similar to standard Euclidean coordinates -// with the first coordinate varying in the horizontal direction and the second -// coordinate varying in the vertical direction. -// Thus (c,r) is usually in the domain [0, width) X [0, height) -// -// Example usage: -// WImageBuffer3_b im(5,7); // Make a 5X7 3 channel image of type uchar -// WImageView3_b sub_im(im, 2,2, 3,3); // 3X3 submatrix -// vector vec(10, 3.0f); -// WImageView1_f user_im(&vec[0], 2, 5); // 2X5 image w/ supplied data -// -// im.SetZero(); // same as cvSetZero(im.Ipl()) -// *im(2, 3) = 15; // Modify the element at column 2, row 3 -// MySetRand(&sub_im); -// -// // Copy the second row into the first. This can be done with no memory -// // allocation and will use SSE if IPP is available. -// int w = im.Width(); -// im.View(0,0, w,1).CopyFrom(im.View(0,1, w,1)); -// -// // Doesn't care about source of data since using WImage -// void MySetRand(WImage_b* im) { // Works with any number of channels -// for (int r = 0; r < im->Height(); ++r) { -// float* row = im->Row(r); -// for (int c = 0; c < im->Width(); ++c) { -// for (int ch = 0; ch < im->Channels(); ++ch, ++row) { -// *row = uchar(rand() & 255); -// } -// } -// } -// } -// -// Functions that are not part of the basic image allocation, viewing, and -// access should come from OpenCV, except some useful functions that are not -// part of OpenCV can be found in wimage_util.h +//M*/ + #ifndef __OPENCV_CORE_WIMAGE_HPP__ #define __OPENCV_CORE_WIMAGE_HPP__ @@ -106,6 +48,9 @@ namespace cv { +//! @addtogroup core +//! @{ + template class WImage; template class WImageBuffer; template class WImageView; @@ -165,12 +110,63 @@ typedef WImageC WImage3_16u; typedef WImageViewC WImageView3_16u; typedef WImageBufferC WImageBuffer3_16u; -// -// WImage definitions -// -// This WImage class gives access to the data it refers to. It can be -// constructed either by allocating the data with a WImageBuffer class or -// using the WImageView class to refer to a subimage or outside data. +/** @brief Image class which provides a thin layer around an IplImage. + +The goals of the class design are: + + -# All the data has explicit ownership to avoid memory leaks + -# No hidden allocations or copies for performance. + -# Easy access to OpenCV methods (which will access IPP if available) + -# Can easily treat external data as an image + -# Easy to create images which are subsets of other images + -# Fast pixel access which can take advantage of number of channels if known at compile time. + +The WImage class is the image class which provides the data accessors. The 'W' comes from the fact +that it is also a wrapper around the popular but inconvenient IplImage class. A WImage can be +constructed either using a WImageBuffer class which allocates and frees the data, or using a +WImageView class which constructs a subimage or a view into external data. The view class does no +memory management. Each class actually has two versions, one when the number of channels is known +at compile time and one when it isn't. Using the one with the number of channels specified can +provide some compile time optimizations by using the fact that the number of channels is a +constant. + +We use the convention (c,r) to refer to column c and row r with (0,0) being the upper left corner. +This is similar to standard Euclidean coordinates with the first coordinate varying in the +horizontal direction and the second coordinate varying in the vertical direction. Thus (c,r) is +usually in the domain [0, width) X [0, height) + +Example usage: +@code +WImageBuffer3_b im(5,7); // Make a 5X7 3 channel image of type uchar +WImageView3_b sub_im(im, 2,2, 3,3); // 3X3 submatrix +vector vec(10, 3.0f); +WImageView1_f user_im(&vec[0], 2, 5); // 2X5 image w/ supplied data + +im.SetZero(); // same as cvSetZero(im.Ipl()) +*im(2, 3) = 15; // Modify the element at column 2, row 3 +MySetRand(&sub_im); + +// Copy the second row into the first. This can be done with no memory +// allocation and will use SSE if IPP is available. +int w = im.Width(); +im.View(0,0, w,1).CopyFrom(im.View(0,1, w,1)); + +// Doesn't care about source of data since using WImage +void MySetRand(WImage_b* im) { // Works with any number of channels +for (int r = 0; r < im->Height(); ++r) { + float* row = im->Row(r); + for (int c = 0; c < im->Width(); ++c) { + for (int ch = 0; ch < im->Channels(); ++ch, ++row) { + *row = uchar(rand() & 255); + } + } +} +} +@endcode + +Functions that are not part of the basic image allocation, viewing, and access should come from +OpenCV, except some useful functions that are not part of OpenCV can be found in wimage_util.h +*/ template class WImage { @@ -252,10 +248,10 @@ protected: }; - -// Image class when both the pixel type and number of channels -// are known at compile time. This wrapper will speed up some of the operations -// like accessing individual pixels using the () operator. +/** Image class when both the pixel type and number of channels +are known at compile time. This wrapper will speed up some of the operations +like accessing individual pixels using the () operator. +*/ template class WImageC : public WImage { @@ -292,12 +288,9 @@ protected: } }; -// -// WImageBuffer definitions -// -// Image class which owns the data, so it can be allocated and is always -// freed. It cannot be copied but can be explicity cloned. -// +/** Image class which owns the data, so it can be allocated and is always +freed. It cannot be copied but can be explicity cloned. +*/ template class WImageBuffer : public WImage { @@ -352,8 +345,8 @@ private: void operator=(const WImageBuffer&); }; -// Like a WImageBuffer class but when the number of channels is known -// at compile time. +/** Like a WImageBuffer class but when the number of channels is known at compile time. +*/ template class WImageBufferC : public WImageC { @@ -409,14 +402,10 @@ private: void operator=(const WImageBufferC&); }; -// -// WImageView definitions -// -// View into an image class which allows treating a subimage as an image -// or treating external data as an image -// -template -class WImageView : public WImage +/** View into an image class which allows treating a subimage as an image or treating external data +as an image +*/ +template class WImageView : public WImage { public: typedef typename WImage::BaseType BaseType; @@ -518,15 +507,9 @@ inline int WImage::Depth() const {return IPL_DEPTH_32F; } template<> inline int WImage::Depth() const {return IPL_DEPTH_64F; } -// -// Pure virtual destructors still need to be defined. -// template inline WImage::~WImage() {} template inline WImageC::~WImageC() {} -// -// Allocate ImageData -// template inline void WImageBuffer::Allocate(int width, int height, int nchannels) { @@ -547,9 +530,6 @@ inline void WImageBufferC::Allocate(int width, int height) } } -// -// ImageView methods -// template WImageView::WImageView(WImage* img, int c, int r, int width, int height) : WImage(0) @@ -614,6 +594,8 @@ WImageViewC WImageC::View(int c, int r, int width, int height) { return WImageViewC(this, c, r, width, height); } +//! @} core + } // end of namespace #endif // __cplusplus diff --git a/modules/core/src/mathfuncs.cpp b/modules/core/src/mathfuncs.cpp index 96107a0a4b..1c045f3faa 100644 --- a/modules/core/src/mathfuncs.cpp +++ b/modules/core/src/mathfuncs.cpp @@ -168,6 +168,31 @@ static void FastAtan2_32f(const float *Y, const float *X, float *angle, int len, _mm_storeu_ps(angle + i, a); } } +#elif CV_NEON + float32x4_t eps = vdupq_n_f32((float)DBL_EPSILON); + float32x4_t _90 = vdupq_n_f32(90.f), _180 = vdupq_n_f32(180.f), _360 = vdupq_n_f32(360.f); + float32x4_t z = vdupq_n_f32(0.0f), scale4 = vdupq_n_f32(scale); + float32x4_t p1 = vdupq_n_f32(atan2_p1), p3 = vdupq_n_f32(atan2_p3); + float32x4_t p5 = vdupq_n_f32(atan2_p5), p7 = vdupq_n_f32(atan2_p7); + + for( ; i <= len - 4; i += 4 ) + { + float32x4_t x = vld1q_f32(X + i), y = vld1q_f32(Y + i); + float32x4_t ax = vabsq_f32(x), ay = vabsq_f32(y); + float32x4_t tmin = vminq_f32(ax, ay), tmax = vmaxq_f32(ax, ay); + float32x4_t c = vmulq_f32(tmin, cv_vrecpq_f32(vaddq_f32(tmax, eps))); + float32x4_t c2 = vmulq_f32(c, c); + float32x4_t a = vmulq_f32(c2, p7); + a = vmulq_f32(vaddq_f32(a, p5), c2); + a = vmulq_f32(vaddq_f32(a, p3), c2); + a = vmulq_f32(vaddq_f32(a, p1), c); + + a = vbslq_f32(vcgeq_f32(ax, ay), a, vsubq_f32(_90, a)); + a = vbslq_f32(vcltq_f32(x, z), vsubq_f32(_180, a), a); + a = vbslq_f32(vcltq_f32(y, z), vsubq_f32(_360, a), a); + + vst1q_f32(angle + i, vmulq_f32(a, scale4)); + } #endif for( ; i < len; i++ ) @@ -268,17 +293,15 @@ static void Magnitude_32f(const float* x, const float* y, float* mag, int len) } } #elif CV_NEON - float CV_DECL_ALIGNED(16) m[4]; - for( ; i <= len - 4; i += 4 ) { float32x4_t v_x = vld1q_f32(x + i), v_y = vld1q_f32(y + i); - vst1q_f32(m, vaddq_f32(vmulq_f32(v_x, v_x), vmulq_f32(v_y, v_y))); - - mag[i] = std::sqrt(m[0]); - mag[i+1] = std::sqrt(m[1]); - mag[i+2] = std::sqrt(m[2]); - mag[i+3] = std::sqrt(m[3]); + vst1q_f32(mag + i, cv_vsqrtq_f32(vmlaq_f32(vmulq_f32(v_x, v_x), v_y, v_y))); + } + for( ; i <= len - 2; i += 2 ) + { + float32x2_t v_x = vld1_f32(x + i), v_y = vld1_f32(y + i); + vst1_f32(mag + i, cv_vsqrt_f32(vmla_f32(vmul_f32(v_x, v_x), v_y, v_y))); } #endif @@ -370,6 +393,12 @@ static void InvSqrt_32f(const float* src, float* dst, int len) _mm_storeu_ps(dst + i, t0); _mm_storeu_ps(dst + i + 4, t1); } } +#elif CV_NEON + for ( ; i <= len - 8; i += 8) + { + vst1q_f32(dst + i, cv_vrsqrtq_f32(vld1q_f32(src + i))); + vst1q_f32(dst + i + 4, cv_vrsqrtq_f32(vld1q_f32(src + i + 4))); + } #endif for( ; i < len; i++ ) @@ -428,6 +457,12 @@ static void Sqrt_32f(const float* src, float* dst, int len) _mm_storeu_ps(dst + i, t0); _mm_storeu_ps(dst + i + 4, t1); } } +#elif CV_NEON + for ( ; i <= len - 8; i += 8) + { + vst1q_f32(dst + i, cv_vsqrtq_f32(vld1q_f32(src + i))); + vst1q_f32(dst + i + 4, cv_vsqrtq_f32(vld1q_f32(src + i + 4))); + } #endif for( ; i < len; i++ ) @@ -869,11 +904,24 @@ void polarToCart( InputArray src1, InputArray src2, SinCos_32f( angle, y, x, len, angleInDegrees ); if( mag ) - for( k = 0; k < len; k++ ) + { + k = 0; + + #if CV_NEON + for( ; k <= len - 4; k += 4 ) + { + float32x4_t v_m = vld1q_f32(mag + k); + vst1q_f32(x + k, vmulq_f32(vld1q_f32(x + k), v_m)); + vst1q_f32(y + k, vmulq_f32(vld1q_f32(y + k), v_m)); + } + #endif + + for( ; k < len; k++ ) { float m = mag[k]; x[k] *= m; y[k] *= m; } + } } else { @@ -2121,12 +2169,230 @@ void log( InputArray _src, OutputArray _dst ) * P O W E R * \****************************************************************************************/ +template +struct iPow_SIMD +{ + int operator() ( const T *, T *, int, int) + { + return 0; + } +}; + +#if CV_NEON + +template <> +struct iPow_SIMD +{ + int operator() ( const uchar * src, uchar * dst, int len, int power) + { + int i = 0; + uint32x4_t v_1 = vdupq_n_u32(1u); + + for ( ; i <= len - 8; i += 8) + { + uint32x4_t v_a1 = v_1, v_a2 = v_1; + uint16x8_t v_src = vmovl_u8(vld1_u8(src + i)); + uint32x4_t v_b1 = vmovl_u16(vget_low_u16(v_src)), v_b2 = vmovl_u16(vget_high_u16(v_src)); + int p = power; + + while( p > 1 ) + { + if (p & 1) + { + v_a1 = vmulq_u32(v_a1, v_b1); + v_a2 = vmulq_u32(v_a2, v_b2); + } + v_b1 = vmulq_u32(v_b1, v_b1); + v_b2 = vmulq_u32(v_b2, v_b2); + p >>= 1; + } + + v_a1 = vmulq_u32(v_a1, v_b1); + v_a2 = vmulq_u32(v_a2, v_b2); + vst1_u8(dst + i, vqmovn_u16(vcombine_u16(vqmovn_u32(v_a1), vqmovn_u32(v_a2)))); + } + + return i; + } +}; + +template <> +struct iPow_SIMD +{ + int operator() ( const schar * src, schar * dst, int len, int power) + { + int i = 0; + int32x4_t v_1 = vdupq_n_s32(1); + + for ( ; i <= len - 8; i += 8) + { + int32x4_t v_a1 = v_1, v_a2 = v_1; + int16x8_t v_src = vmovl_s8(vld1_s8(src + i)); + int32x4_t v_b1 = vmovl_s16(vget_low_s16(v_src)), v_b2 = vmovl_s16(vget_high_s16(v_src)); + int p = power; + + while( p > 1 ) + { + if (p & 1) + { + v_a1 = vmulq_s32(v_a1, v_b1); + v_a2 = vmulq_s32(v_a2, v_b2); + } + v_b1 = vmulq_s32(v_b1, v_b1); + v_b2 = vmulq_s32(v_b2, v_b2); + p >>= 1; + } + + v_a1 = vmulq_s32(v_a1, v_b1); + v_a2 = vmulq_s32(v_a2, v_b2); + vst1_s8(dst + i, vqmovn_s16(vcombine_s16(vqmovn_s32(v_a1), vqmovn_s32(v_a2)))); + } + + return i; + } +}; + +template <> +struct iPow_SIMD +{ + int operator() ( const ushort * src, ushort * dst, int len, int power) + { + int i = 0; + uint32x4_t v_1 = vdupq_n_u32(1u); + + for ( ; i <= len - 8; i += 8) + { + uint32x4_t v_a1 = v_1, v_a2 = v_1; + uint16x8_t v_src = vld1q_u16(src + i); + uint32x4_t v_b1 = vmovl_u16(vget_low_u16(v_src)), v_b2 = vmovl_u16(vget_high_u16(v_src)); + int p = power; + + while( p > 1 ) + { + if (p & 1) + { + v_a1 = vmulq_u32(v_a1, v_b1); + v_a2 = vmulq_u32(v_a2, v_b2); + } + v_b1 = vmulq_u32(v_b1, v_b1); + v_b2 = vmulq_u32(v_b2, v_b2); + p >>= 1; + } + + v_a1 = vmulq_u32(v_a1, v_b1); + v_a2 = vmulq_u32(v_a2, v_b2); + vst1q_u16(dst + i, vcombine_u16(vqmovn_u32(v_a1), vqmovn_u32(v_a2))); + } + + return i; + } +}; + +template <> +struct iPow_SIMD +{ + int operator() ( const short * src, short * dst, int len, int power) + { + int i = 0; + int32x4_t v_1 = vdupq_n_s32(1); + + for ( ; i <= len - 8; i += 8) + { + int32x4_t v_a1 = v_1, v_a2 = v_1; + int16x8_t v_src = vld1q_s16(src + i); + int32x4_t v_b1 = vmovl_s16(vget_low_s16(v_src)), v_b2 = vmovl_s16(vget_high_s16(v_src)); + int p = power; + + while( p > 1 ) + { + if (p & 1) + { + v_a1 = vmulq_s32(v_a1, v_b1); + v_a2 = vmulq_s32(v_a2, v_b2); + } + v_b1 = vmulq_s32(v_b1, v_b1); + v_b2 = vmulq_s32(v_b2, v_b2); + p >>= 1; + } + + v_a1 = vmulq_s32(v_a1, v_b1); + v_a2 = vmulq_s32(v_a2, v_b2); + vst1q_s16(dst + i, vcombine_s16(vqmovn_s32(v_a1), vqmovn_s32(v_a2))); + } + + return i; + } +}; + + +template <> +struct iPow_SIMD +{ + int operator() ( const int * src, int * dst, int len, int power) + { + int i = 0; + int32x4_t v_1 = vdupq_n_s32(1); + + for ( ; i <= len - 4; i += 4) + { + int32x4_t v_b = vld1q_s32(src + i), v_a = v_1; + int p = power; + + while( p > 1 ) + { + if (p & 1) + v_a = vmulq_s32(v_a, v_b); + v_b = vmulq_s32(v_b, v_b); + p >>= 1; + } + + v_a = vmulq_s32(v_a, v_b); + vst1q_s32(dst + i, v_a); + } + + return i; + } +}; + +template <> +struct iPow_SIMD +{ + int operator() ( const float * src, float * dst, int len, int power) + { + int i = 0; + float32x4_t v_1 = vdupq_n_f32(1.0f); + + for ( ; i <= len - 4; i += 4) + { + float32x4_t v_b = vld1q_f32(src + i), v_a = v_1; + int p = power; + + while( p > 1 ) + { + if (p & 1) + v_a = vmulq_f32(v_a, v_b); + v_b = vmulq_f32(v_b, v_b); + p >>= 1; + } + + v_a = vmulq_f32(v_a, v_b); + vst1q_f32(dst + i, v_a); + } + + return i; + } +}; + +#endif + template static void iPow_( const T* src, T* dst, int len, int power ) { - int i; - for( i = 0; i < len; i++ ) + iPow_SIMD vop; + int i = vop(src, dst, len, power); + + for( ; i < len; i++ ) { WT a = 1, b = src[i]; int p = power; @@ -2212,8 +2478,8 @@ static bool ocl_pow(InputArray _src, double power, OutputArray _dst, if (depth == CV_64F && !doubleSupport) return false; - bool issqrt = std::abs(power - 0.5) < DBL_EPSILON, nonnegative = power >= 0; - const char * const op = issqrt ? "OP_SQRT" : is_ipower ? nonnegative ? "OP_POWN" : "OP_ROOTN" : nonnegative ? "OP_POWR" : "OP_POW"; + bool issqrt = std::abs(power - 0.5) < DBL_EPSILON; + const char * const op = issqrt ? "OP_SQRT" : is_ipower ? "OP_POWN" : "OP_POW"; ocl::Kernel k("KF", ocl::core::arithm_oclsrc, format("-D dstT=%s -D depth=%d -D rowsPerWI=%d -D %s -D UNARY_OP%s", diff --git a/modules/core/src/ocl.cpp b/modules/core/src/ocl.cpp index 9f8489e131..5e18e035ec 100644 --- a/modules/core/src/ocl.cpp +++ b/modules/core/src/ocl.cpp @@ -1453,7 +1453,7 @@ bool useOpenCL() { try { - data->useOpenCL = (int)haveOpenCL() && Device::getDefault().ptr() != NULL; + data->useOpenCL = (int)haveOpenCL() && Device::getDefault().ptr() && Device::getDefault().available(); } catch (...) { @@ -2130,7 +2130,8 @@ const Device& Device::getDefault() { const Context& ctx = Context::getDefault(); int idx = coreTlsData.get()->device; - return ctx.device(idx); + const Device& device = ctx.device(idx); + return device; } ////////////////////////////////////// Context /////////////////////////////////////////////////// @@ -2210,7 +2211,10 @@ static cl_device_id selectOpenCLDevice() std::vector deviceTypes; const char* configuration = getenv("OPENCV_OPENCL_DEVICE"); - if (configuration && !parseOpenCLDeviceConfiguration(std::string(configuration), platform, deviceTypes, deviceName)) + if (configuration && + (strcmp(configuration, "disabled") == 0 || + !parseOpenCLDeviceConfiguration(std::string(configuration), platform, deviceTypes, deviceName) + )) return NULL; bool isID = false; @@ -2339,14 +2343,16 @@ static cl_device_id selectOpenCLDevice() } not_found: - std::cerr << "ERROR: Required OpenCL device not found, check configuration: " << (configuration == NULL ? "" : configuration) << std::endl + if (!configuration) + return NULL; // suppress messages on stderr + + std::cerr << "ERROR: Requested OpenCL device not found, check configuration: " << (configuration == NULL ? "" : configuration) << std::endl << " Platform: " << (platform.length() == 0 ? "any" : platform) << std::endl << " Device types: "; for (size_t t = 0; t < deviceTypes.size(); t++) std::cerr << deviceTypes[t] << " "; std::cerr << std::endl << " Device name: " << (deviceName.length() == 0 ? "any" : deviceName) << std::endl; - CV_Error(CL_INVALID_DEVICE, "Requested OpenCL device is not found"); return NULL; } #endif diff --git a/modules/core/src/opencl/arithm.cl b/modules/core/src/opencl/arithm.cl index 345066622c..0b81d76183 100644 --- a/modules/core/src/opencl/arithm.cl +++ b/modules/core/src/opencl/arithm.cl @@ -277,16 +277,6 @@ #elif defined OP_POW #define PROCESS_ELEM storedst(pow(srcelem1, srcelem2)) -#elif defined OP_ROOTN -#define PROCESS_ELEM storedst(rootn(srcelem1, srcelem2)) - -#elif defined OP_POWR -#if depth == 5 -#define PROCESS_ELEM storedst(native_powr(srcelem1, srcelem2)) -#else -#define PROCESS_ELEM storedst(powr(srcelem1, srcelem2)) -#endif - #elif defined OP_POWN #undef workT #define workT int diff --git a/modules/core/src/stat.cpp b/modules/core/src/stat.cpp index 998ae7df0d..ca56a7c966 100644 --- a/modules/core/src/stat.cpp +++ b/modules/core/src/stat.cpp @@ -3212,7 +3212,9 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m type == CV_16UC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16u_C1R : type == CV_16UC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16u_C3R : type == CV_16UC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16u_C4R : +#if !(IPP_VERSION_X100 == 802 && (!defined(IPP_VERSION_UPDATE) || IPP_VERSION_UPDATE <= 1)) // Oct 2014: Accuracy issue with IPP 8.2 / 8.2.1 type == CV_16SC1 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16s_C1R : +#endif type == CV_16SC3 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16s_C3R : type == CV_16SC4 ? (ippiNormDiffFuncNoHint)ippiNormDiff_L1_16s_C4R : 0) : diff --git a/modules/core/test/test_umat.cpp b/modules/core/test/test_umat.cpp index 8e51aadad2..0e25b6ba9a 100644 --- a/modules/core/test/test_umat.cpp +++ b/modules/core/test/test_umat.cpp @@ -130,6 +130,12 @@ TEST_P(UMatBasicTests, swap) TEST_P(UMatBasicTests, base) { + const int align_mask = 3; + roi.x &= ~align_mask; + roi.y &= ~align_mask; + roi.width = (roi.width + align_mask) & ~align_mask; + roi &= Rect(0, 0, ua.cols, ua.rows); + if(useRoi) { ua = UMat(ua,roi); diff --git a/modules/cudaarithm/doc/element_operations.rst b/modules/cudaarithm/doc/element_operations.rst index d3dba67b88..5ccca78a20 100644 --- a/modules/cudaarithm/doc/element_operations.rst +++ b/modules/cudaarithm/doc/element_operations.rst @@ -430,7 +430,7 @@ Applies a fixed-level threshold to each array element. :param maxval: Maximum value to use with ``THRESH_BINARY`` and ``THRESH_BINARY_INV`` threshold types. - :param type: Threshold type. For details, see :ocv:func:`threshold` . The ``THRESH_OTSU`` threshold type is not supported. + :param type: Threshold type. For details, see :ocv:func:`threshold` . The ``THRESH_OTSU`` and ``THRESH_TRIANGLE`` threshold types are not supported. :param stream: Stream for the asynchronous version. diff --git a/modules/cudafeatures2d/perf/perf_features2d.cpp b/modules/cudafeatures2d/perf/perf_features2d.cpp index 542195ea55..26eb434f44 100644 --- a/modules/cudafeatures2d/perf/perf_features2d.cpp +++ b/modules/cudafeatures2d/perf/perf_features2d.cpp @@ -128,12 +128,12 @@ PERF_TEST_P(Image_NFeatures, ORB, } else { - cv::ORB orb(nFeatures); + cv::Ptr orb = cv::ORB::create(nFeatures); std::vector cpu_keypoints; cv::Mat cpu_descriptors; - TEST_CYCLE() orb(img, cv::noArray(), cpu_keypoints, cpu_descriptors); + TEST_CYCLE() orb->detectAndCompute(img, cv::noArray(), cpu_keypoints, cpu_descriptors); SANITY_CHECK_KEYPOINTS(cpu_keypoints); SANITY_CHECK(cpu_descriptors); diff --git a/modules/cudafeatures2d/test/test_features2d.cpp b/modules/cudafeatures2d/test/test_features2d.cpp index ae71a2e36b..6e4479b7d5 100644 --- a/modules/cudafeatures2d/test/test_features2d.cpp +++ b/modules/cudafeatures2d/test/test_features2d.cpp @@ -185,11 +185,11 @@ CUDA_TEST_P(ORB, Accuracy) cv::cuda::GpuMat descriptors; orb(loadMat(image), loadMat(mask), keypoints, descriptors); - cv::ORB orb_gold(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize); + cv::Ptr orb_gold = cv::ORB::create(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize); std::vector keypoints_gold; cv::Mat descriptors_gold; - orb_gold(image, mask, keypoints_gold, descriptors_gold); + orb_gold->detectAndCompute(image, mask, keypoints_gold, descriptors_gold); cv::BFMatcher matcher(cv::NORM_HAMMING); std::vector matches; diff --git a/modules/cudastereo/perf/perf_stereo.cpp b/modules/cudastereo/perf/perf_stereo.cpp index 68650cd243..36b065e5e8 100644 --- a/modules/cudastereo/perf/perf_stereo.cpp +++ b/modules/cudastereo/perf/perf_stereo.cpp @@ -79,7 +79,7 @@ PERF_TEST_P(ImagePair, StereoBM, } else { - cv::Ptr bm = cv::createStereoBM(ndisp); + cv::Ptr bm = cv::StereoBM::create(ndisp); cv::Mat dst; diff --git a/modules/imgproc/doc/feature_detection.rst b/modules/imgproc/doc/feature_detection.rst index 9c661d04fc..9a9a054e3e 100644 --- a/modules/imgproc/doc/feature_detection.rst +++ b/modules/imgproc/doc/feature_detection.rst @@ -268,7 +268,7 @@ The function finds the most prominent corners in the image or in the specified i The function can be used to initialize a point-based tracker of an object. -.. note:: If the function is called with different values ``A`` and ``B`` of the parameter ``qualityLevel`` , and ``A`` > {B}, the vector of returned corners with ``qualityLevel=A`` will be the prefix of the output vector with ``qualityLevel=B`` . +.. note:: If the function is called with different values ``A`` and ``B`` of the parameter ``qualityLevel`` , and ``A`` > ``B``, the vector of returned corners with ``qualityLevel=A`` will be the prefix of the output vector with ``qualityLevel=B`` . .. seealso:: diff --git a/modules/imgproc/doc/miscellaneous_transformations.rst b/modules/imgproc/doc/miscellaneous_transformations.rst index bbd692e1f9..b0dedfaaca 100644 --- a/modules/imgproc/doc/miscellaneous_transformations.rst +++ b/modules/imgproc/doc/miscellaneous_transformations.rst @@ -712,11 +712,11 @@ types of thresholding supported by the function. They are determined by ``type`` \texttt{dst} (x,y) = \fork{0}{if $\texttt{src}(x,y) > \texttt{thresh}$}{\texttt{src}(x,y)}{otherwise} -Also, the special value ``THRESH_OTSU`` may be combined with -one of the above values. In this case, the function determines the optimal threshold -value using the Otsu's algorithm and uses it instead of the specified ``thresh`` . +Also, the special values ``THRESH_OTSU`` or ``THRESH_TRIANGLE`` may be combined with +one of the above values. In these cases, the function determines the optimal threshold +value using the Otsu's or Triangle algorithm and uses it instead of the specified ``thresh`` . The function returns the computed threshold value. -Currently, the Otsu's method is implemented only for 8-bit images. +Currently, the Otsu's and Triangle methods are implemented only for 8-bit images. .. image:: pics/threshold.png diff --git a/modules/imgproc/include/opencv2/imgproc.hpp b/modules/imgproc/include/opencv2/imgproc.hpp index ee20f379af..2e693542e3 100644 --- a/modules/imgproc/include/opencv2/imgproc.hpp +++ b/modules/imgproc/include/opencv2/imgproc.hpp @@ -45,12 +45,23 @@ #include "opencv2/core.hpp" -/*! \namespace cv - Namespace where all the C++ OpenCV functionality resides - */ +/** + @defgroup imgproc Image processing + @{ + @defgroup imgproc_filter Image filtering + @defgroup imgproc_transform Image transformations + @defgroup imgproc_drawing Drawing functions + @defgroup imgproc_shape Structural Analysis and Shape Descriptors + @} +*/ + namespace cv { +/** @addtogroup imgproc +@{ +*/ + //! type of morphological operation enum { MORPH_ERODE = 0, MORPH_DILATE = 1, @@ -109,7 +120,8 @@ enum { THRESH_BINARY = 0, // value = value > threshold ? max_value : 0 THRESH_TOZERO = 3, // value = value > threshold ? value : 0 THRESH_TOZERO_INV = 4, // value = value > threshold ? 0 : value THRESH_MASK = 7, - THRESH_OTSU = 8 // use Otsu algorithm to choose the optimal threshold value + THRESH_OTSU = 8, // use Otsu algorithm to choose the optimal threshold value + THRESH_TRIANGLE = 16 // use Triangle algorithm to choose the optimal threshold value }; //! adaptive threshold algorithm @@ -1315,6 +1327,8 @@ CV_EXPORTS_W Size getTextSize(const String& text, int fontFace, double fontScale, int thickness, CV_OUT int* baseLine); +/** @} */ + } // cv #endif diff --git a/modules/imgproc/include/opencv2/imgproc/types_c.h b/modules/imgproc/include/opencv2/imgproc/types_c.h index de8fb62038..544dee0345 100644 --- a/modules/imgproc/include/opencv2/imgproc/types_c.h +++ b/modules/imgproc/include/opencv2/imgproc/types_c.h @@ -551,8 +551,11 @@ enum CV_THRESH_TOZERO =3, /* value = value > threshold ? value : 0 */ CV_THRESH_TOZERO_INV =4, /* value = value > threshold ? 0 : value */ CV_THRESH_MASK =7, - CV_THRESH_OTSU =8 /* use Otsu algorithm to choose the optimal threshold value; + CV_THRESH_OTSU =8, /* use Otsu algorithm to choose the optimal threshold value; combine the flag with one of the above CV_THRESH_* values */ + CV_THRESH_TRIANGLE =16 /* use Triangle algorithm to choose the optimal threshold value; + combine the flag with one of the above CV_THRESH_* values, but not + with CV_THRESH_OTSU */ }; /* Adaptive threshold methods */ diff --git a/modules/imgproc/src/canny.cpp b/modules/imgproc/src/canny.cpp index 352fc8f524..1311d5abb9 100644 --- a/modules/imgproc/src/canny.cpp +++ b/modules/imgproc/src/canny.cpp @@ -138,10 +138,10 @@ static bool ocl_Canny(InputArray _src, OutputArray _dst, float low_thresh, float */ char cvt[40]; ocl::Kernel with_sobel("stage1_with_sobel", ocl::imgproc::canny_oclsrc, - format("-D WITH_SOBEL -D cn=%d -D TYPE=%s -D convert_intN=%s -D intN=%s -D GRP_SIZEX=%d -D GRP_SIZEY=%d%s", + format("-D WITH_SOBEL -D cn=%d -D TYPE=%s -D convert_floatN=%s -D floatN=%s -D GRP_SIZEX=%d -D GRP_SIZEY=%d%s", cn, ocl::memopTypeToStr(_src.depth()), - ocl::convertTypeStr(_src.type(), CV_32SC(cn), cn, cvt), - ocl::memopTypeToStr(CV_32SC(cn)), + ocl::convertTypeStr(_src.depth(), CV_32F, cn, cvt), + ocl::typeToStr(CV_MAKE_TYPE(CV_32F, cn)), lSizeX, lSizeY, L2gradient ? " -D L2GRAD" : "")); if (with_sobel.empty()) @@ -151,7 +151,7 @@ static bool ocl_Canny(InputArray _src, OutputArray _dst, float low_thresh, float map.create(size, CV_32S); with_sobel.args(ocl::KernelArg::ReadOnly(src), ocl::KernelArg::WriteOnlyNoSize(map), - low, high); + (float) low, (float) high); size_t globalsize[2] = { size.width, size.height }, localsize[2] = { lSizeX, lSizeY }; @@ -453,7 +453,7 @@ void cv::Canny( InputArray _src, OutputArray _dst, if ((stack_top - stack_bottom) + src.cols > maxsize) { int sz = (int)(stack_top - stack_bottom); - maxsize = maxsize * 3/2; + maxsize = std::max(maxsize * 3/2, sz + src.cols); stack.resize(maxsize); stack_bottom = &stack[0]; stack_top = stack_bottom + sz; diff --git a/modules/imgproc/src/corner.cpp b/modules/imgproc/src/corner.cpp index e2e19871ce..85f2063b28 100644 --- a/modules/imgproc/src/corner.cpp +++ b/modules/imgproc/src/corner.cpp @@ -69,7 +69,7 @@ static void calcMinEigenVal( const Mat& _cov, Mat& _dst ) if( simd ) { __m128 half = _mm_set1_ps(0.5f); - for( ; j <= size.width - 5; j += 4 ) + for( ; j <= size.width - 4; j += 4 ) { __m128 t0 = _mm_loadu_ps(cov + j*3); // a0 b0 c0 x __m128 t1 = _mm_loadu_ps(cov + j*3 + 3); // a1 b1 c1 x @@ -90,6 +90,19 @@ static void calcMinEigenVal( const Mat& _cov, Mat& _dst ) _mm_storeu_ps(dst + j, a); } } + #elif CV_NEON + float32x4_t v_half = vdupq_n_f32(0.5f); + for( ; j <= size.width - 4; j += 4 ) + { + float32x4x3_t v_src = vld3q_f32(cov + j * 3); + float32x4_t v_a = vmulq_f32(v_src.val[0], v_half); + float32x4_t v_b = v_src.val[1]; + float32x4_t v_c = vmulq_f32(v_src.val[2], v_half); + + float32x4_t v_t = vsubq_f32(v_a, v_c); + v_t = vmlaq_f32(vmulq_f32(v_t, v_t), v_b, v_b); + vst1q_f32(dst + j, vsubq_f32(vaddq_f32(v_a, v_c), cv_vsqrtq_f32(v_t))); + } #endif for( ; j < size.width; j++ ) { @@ -290,8 +303,24 @@ cornerEigenValsVecs( const Mat& src, Mat& eigenv, int block_size, float* cov_data = cov.ptr(i); const float* dxdata = Dx.ptr(i); const float* dydata = Dy.ptr(i); + j = 0; - for( j = 0; j < size.width; j++ ) + #if CV_NEON + for( ; j <= size.width - 4; j += 4 ) + { + float32x4_t v_dx = vld1q_f32(dxdata + j); + float32x4_t v_dy = vld1q_f32(dydata + j); + + float32x4x3_t v_dst; + v_dst.val[0] = vmulq_f32(v_dx, v_dx); + v_dst.val[1] = vmulq_f32(v_dx, v_dy); + v_dst.val[2] = vmulq_f32(v_dy, v_dy); + + vst3q_f32(cov_data + j * 3, v_dst); + } + #endif + + for( ; j < size.width; j++ ) { float dx = dxdata[j]; float dy = dydata[j]; diff --git a/modules/imgproc/src/histogram.cpp b/modules/imgproc/src/histogram.cpp index 7385f00936..9acdc11415 100644 --- a/modules/imgproc/src/histogram.cpp +++ b/modules/imgproc/src/histogram.cpp @@ -2316,7 +2316,16 @@ double cv::compareHist( InputArray _H1, InputArray _H2, int method ) } else if( method == CV_COMP_INTERSECT ) { - for( j = 0; j < len; j++ ) + j = 0; + #if CV_NEON + float32x4_t v_result = vdupq_n_f32(0.0f); + for( ; j <= len - 4; j += 4 ) + v_result = vaddq_f32(v_result, vminq_f32(vld1q_f32(h1 + j), vld1q_f32(h2 + j))); + float CV_DECL_ALIGNED(16) ar[4]; + vst1q_f32(ar, v_result); + result += ar[0] + ar[1] + ar[2] + ar[3]; + #endif + for( ; j < len; j++ ) result += std::min(h1[j], h2[j]); } else if( method == CV_COMP_BHATTACHARYYA ) diff --git a/modules/imgproc/src/hough.cpp b/modules/imgproc/src/hough.cpp index 88482b4a8f..f7c0efcccf 100644 --- a/modules/imgproc/src/hough.cpp +++ b/modules/imgproc/src/hough.cpp @@ -303,7 +303,7 @@ HoughLinesSDiv( const Mat& img, ti1 < halftn; ti1++, phi += theta_it, phi1 += scale_factor ) { rv = r0 * std::cos( phi ); - i = cvFloor( rv ) * tn; + i = (int)rv * tn; i += cvFloor( phi1 ); assert( i >= 0 ); assert( i < rn * tn ); diff --git a/modules/imgproc/src/imgwarp.cpp b/modules/imgproc/src/imgwarp.cpp index 63a98c1421..d952b60ea8 100644 --- a/modules/imgproc/src/imgwarp.cpp +++ b/modules/imgproc/src/imgwarp.cpp @@ -133,7 +133,7 @@ static uchar NNDeltaTab_i[INTER_TAB_SIZE2][2]; static float BilinearTab_f[INTER_TAB_SIZE2][2][2]; static short BilinearTab_i[INTER_TAB_SIZE2][2][2]; -#if CV_SSE2 +#if CV_SSE2 || CV_NEON static short BilinearTab_iC4_buf[INTER_TAB_SIZE2+2][2][8]; static short (*BilinearTab_iC4)[2][8] = (short (*)[2][8])alignPtr(BilinearTab_iC4_buf, 16); #endif @@ -269,7 +269,7 @@ static const void* initInterTab2D( int method, bool fixpt ) } tab -= INTER_TAB_SIZE2*ksize*ksize; itab -= INTER_TAB_SIZE2*ksize*ksize; -#if CV_SSE2 +#if CV_SSE2 || CV_NEON if( method == INTER_LINEAR ) { for( i = 0; i < INTER_TAB_SIZE2; i++ ) @@ -894,9 +894,51 @@ struct VResizeCubicVec_32f } }; +typedef VResizeNoVec VResizeLanczos4Vec_32f16u; +typedef VResizeNoVec VResizeLanczos4Vec_32f16s; +typedef VResizeNoVec VResizeLanczos4Vec_32f; + #elif CV_NEON -typedef VResizeNoVec VResizeLinearVec_32s8u; +struct VResizeLinearVec_32s8u +{ + int operator()(const uchar** _src, uchar* dst, const uchar* _beta, int width ) const + { + const int** src = (const int**)_src, *S0 = src[0], *S1 = src[1]; + const short* beta = (const short*)_beta; + int x = 0; + int16x8_t v_b0 = vdupq_n_s16(beta[0]), v_b1 = vdupq_n_s16(beta[1]), v_delta = vdupq_n_s16(2); + + for( ; x <= width - 16; x += 16) + { + int32x4_t v_src00 = vshrq_n_s32(vld1q_s32(S0 + x), 4), v_src10 = vshrq_n_s32(vld1q_s32(S1 + x), 4); + int32x4_t v_src01 = vshrq_n_s32(vld1q_s32(S0 + x + 4), 4), v_src11 = vshrq_n_s32(vld1q_s32(S1 + x + 4), 4); + + int16x8_t v_src0 = vcombine_s16(vmovn_s32(v_src00), vmovn_s32(v_src01)); + int16x8_t v_src1 = vcombine_s16(vmovn_s32(v_src10), vmovn_s32(v_src11)); + + int16x8_t v_dst0 = vaddq_s16(vshrq_n_s16(vqdmulhq_s16(v_src0, v_b0), 1), + vshrq_n_s16(vqdmulhq_s16(v_src1, v_b1), 1)); + v_dst0 = vshrq_n_s16(vaddq_s16(v_dst0, v_delta), 2); + + v_src00 = vshrq_n_s32(vld1q_s32(S0 + x + 8), 4); + v_src10 = vshrq_n_s32(vld1q_s32(S1 + x + 8), 4); + v_src01 = vshrq_n_s32(vld1q_s32(S0 + x + 12), 4); + v_src11 = vshrq_n_s32(vld1q_s32(S1 + x + 12), 4); + + v_src0 = vcombine_s16(vmovn_s32(v_src00), vmovn_s32(v_src01)); + v_src1 = vcombine_s16(vmovn_s32(v_src10), vmovn_s32(v_src11)); + + int16x8_t v_dst1 = vaddq_s16(vshrq_n_s16(vqdmulhq_s16(v_src0, v_b0), 1), + vshrq_n_s16(vqdmulhq_s16(v_src1, v_b1), 1)); + v_dst1 = vshrq_n_s16(vaddq_s16(v_dst1, v_delta), 2); + + vst1q_u8(dst + x, vcombine_u8(vqmovun_s16(v_dst0), vqmovun_s16(v_dst1))); + } + + return x; + } +}; struct VResizeLinearVec_32f16u { @@ -1071,6 +1113,128 @@ struct VResizeCubicVec_32f } }; +struct VResizeLanczos4Vec_32f16u +{ + int operator()(const uchar** _src, uchar* _dst, const uchar* _beta, int width ) const + { + const float** src = (const float**)_src; + const float* beta = (const float*)_beta; + const float *S0 = src[0], *S1 = src[1], *S2 = src[2], *S3 = src[3], + *S4 = src[4], *S5 = src[5], *S6 = src[6], *S7 = src[7]; + ushort * dst = (ushort*)_dst; + int x = 0; + float32x4_t v_b0 = vdupq_n_f32(beta[0]), v_b1 = vdupq_n_f32(beta[1]), + v_b2 = vdupq_n_f32(beta[2]), v_b3 = vdupq_n_f32(beta[3]), + v_b4 = vdupq_n_f32(beta[4]), v_b5 = vdupq_n_f32(beta[5]), + v_b6 = vdupq_n_f32(beta[6]), v_b7 = vdupq_n_f32(beta[7]); + + for( ; x <= width - 8; x += 8 ) + { + float32x4_t v_dst0 = vmlaq_f32(vmlaq_f32(vmlaq_f32(vmulq_f32(v_b0, vld1q_f32(S0 + x)), + v_b1, vld1q_f32(S1 + x)), + v_b2, vld1q_f32(S2 + x)), + v_b3, vld1q_f32(S3 + x)); + float32x4_t v_dst1 = vmlaq_f32(vmlaq_f32(vmlaq_f32(vmulq_f32(v_b4, vld1q_f32(S4 + x)), + v_b5, vld1q_f32(S5 + x)), + v_b6, vld1q_f32(S6 + x)), + v_b7, vld1q_f32(S7 + x)); + float32x4_t v_dst = vaddq_f32(v_dst0, v_dst1); + + v_dst0 = vmlaq_f32(vmlaq_f32(vmlaq_f32(vmulq_f32(v_b0, vld1q_f32(S0 + x + 4)), + v_b1, vld1q_f32(S1 + x + 4)), + v_b2, vld1q_f32(S2 + x + 4)), + v_b3, vld1q_f32(S3 + x + 4)); + v_dst1 = vmlaq_f32(vmlaq_f32(vmlaq_f32(vmulq_f32(v_b4, vld1q_f32(S4 + x + 4)), + v_b5, vld1q_f32(S5 + x + 4)), + v_b6, vld1q_f32(S6 + x + 4)), + v_b7, vld1q_f32(S7 + x + 4)); + v_dst1 = vaddq_f32(v_dst0, v_dst1); + + vst1q_u16(dst + x, vcombine_u16(vqmovn_u32(cv_vrndq_u32_f32(v_dst)), + vqmovn_u32(cv_vrndq_u32_f32(v_dst1)))); + } + + return x; + } +}; + +struct VResizeLanczos4Vec_32f16s +{ + int operator()(const uchar** _src, uchar* _dst, const uchar* _beta, int width ) const + { + const float** src = (const float**)_src; + const float* beta = (const float*)_beta; + const float *S0 = src[0], *S1 = src[1], *S2 = src[2], *S3 = src[3], + *S4 = src[4], *S5 = src[5], *S6 = src[6], *S7 = src[7]; + short * dst = (short*)_dst; + int x = 0; + float32x4_t v_b0 = vdupq_n_f32(beta[0]), v_b1 = vdupq_n_f32(beta[1]), + v_b2 = vdupq_n_f32(beta[2]), v_b3 = vdupq_n_f32(beta[3]), + v_b4 = vdupq_n_f32(beta[4]), v_b5 = vdupq_n_f32(beta[5]), + v_b6 = vdupq_n_f32(beta[6]), v_b7 = vdupq_n_f32(beta[7]); + + for( ; x <= width - 8; x += 8 ) + { + float32x4_t v_dst0 = vmlaq_f32(vmlaq_f32(vmlaq_f32(vmulq_f32(v_b0, vld1q_f32(S0 + x)), + v_b1, vld1q_f32(S1 + x)), + v_b2, vld1q_f32(S2 + x)), + v_b3, vld1q_f32(S3 + x)); + float32x4_t v_dst1 = vmlaq_f32(vmlaq_f32(vmlaq_f32(vmulq_f32(v_b4, vld1q_f32(S4 + x)), + v_b5, vld1q_f32(S5 + x)), + v_b6, vld1q_f32(S6 + x)), + v_b7, vld1q_f32(S7 + x)); + float32x4_t v_dst = vaddq_f32(v_dst0, v_dst1); + + v_dst0 = vmlaq_f32(vmlaq_f32(vmlaq_f32(vmulq_f32(v_b0, vld1q_f32(S0 + x + 4)), + v_b1, vld1q_f32(S1 + x + 4)), + v_b2, vld1q_f32(S2 + x + 4)), + v_b3, vld1q_f32(S3 + x + 4)); + v_dst1 = vmlaq_f32(vmlaq_f32(vmlaq_f32(vmulq_f32(v_b4, vld1q_f32(S4 + x + 4)), + v_b5, vld1q_f32(S5 + x + 4)), + v_b6, vld1q_f32(S6 + x + 4)), + v_b7, vld1q_f32(S7 + x + 4)); + v_dst1 = vaddq_f32(v_dst0, v_dst1); + + vst1q_s16(dst + x, vcombine_s16(vqmovn_s32(cv_vrndq_s32_f32(v_dst)), + vqmovn_s32(cv_vrndq_s32_f32(v_dst1)))); + } + + return x; + } +}; + +struct VResizeLanczos4Vec_32f +{ + int operator()(const uchar** _src, uchar* _dst, const uchar* _beta, int width ) const + { + const float** src = (const float**)_src; + const float* beta = (const float*)_beta; + const float *S0 = src[0], *S1 = src[1], *S2 = src[2], *S3 = src[3], + *S4 = src[4], *S5 = src[5], *S6 = src[6], *S7 = src[7]; + float* dst = (float*)_dst; + int x = 0; + float32x4_t v_b0 = vdupq_n_f32(beta[0]), v_b1 = vdupq_n_f32(beta[1]), + v_b2 = vdupq_n_f32(beta[2]), v_b3 = vdupq_n_f32(beta[3]), + v_b4 = vdupq_n_f32(beta[4]), v_b5 = vdupq_n_f32(beta[5]), + v_b6 = vdupq_n_f32(beta[6]), v_b7 = vdupq_n_f32(beta[7]); + + for( ; x <= width - 4; x += 4 ) + { + float32x4_t v_dst0 = vmlaq_f32(vmlaq_f32(vmlaq_f32(vmulq_f32(v_b0, vld1q_f32(S0 + x)), + v_b1, vld1q_f32(S1 + x)), + v_b2, vld1q_f32(S2 + x)), + v_b3, vld1q_f32(S3 + x)); + float32x4_t v_dst1 = vmlaq_f32(vmlaq_f32(vmlaq_f32(vmulq_f32(v_b4, vld1q_f32(S4 + x)), + v_b5, vld1q_f32(S5 + x)), + v_b6, vld1q_f32(S6 + x)), + v_b7, vld1q_f32(S7 + x)); + vst1q_f32(dst + x, vaddq_f32(v_dst0, v_dst1)); + } + + return x; + } +}; + #else typedef VResizeNoVec VResizeLinearVec_32s8u; @@ -1083,6 +1247,10 @@ typedef VResizeNoVec VResizeCubicVec_32f16u; typedef VResizeNoVec VResizeCubicVec_32f16s; typedef VResizeNoVec VResizeCubicVec_32f; +typedef VResizeNoVec VResizeLanczos4Vec_32f16u; +typedef VResizeNoVec VResizeLanczos4Vec_32f16s; +typedef VResizeNoVec VResizeLanczos4Vec_32f; + #endif typedef HResizeNoVec HResizeLinearVec_8u32s; @@ -1611,6 +1779,107 @@ private: int cn, step; }; +class ResizeAreaFastVec_SIMD_16s +{ +public: + ResizeAreaFastVec_SIMD_16s(int _cn, int _step) : + cn(_cn), step(_step) + { + } + + int operator() (const short * S, short * D, int w) const + { + int dx = 0; + const short * S0 = S, * S1 = (const short *)((const uchar *)(S0) + step); + + int32x4_t v_2 = vdupq_n_s32(2); + + if (cn == 1) + { + for ( ; dx <= w - 8; dx += 8, S0 += 16, S1 += 16, D += 8) + { + int16x8x2_t v_row0 = vld2q_s16(S0), v_row1 = vld2q_s16(S1); + + int32x4_t v_dst0 = vaddl_s16(vget_low_s16(v_row0.val[0]), vget_low_s16(v_row0.val[1])); + v_dst0 = vaddq_s32(v_dst0, vaddl_s16(vget_low_s16(v_row1.val[0]), vget_low_s16(v_row1.val[1]))); + v_dst0 = vshrq_n_s32(vaddq_s32(v_dst0, v_2), 2); + + int32x4_t v_dst1 = vaddl_s16(vget_high_s16(v_row0.val[0]), vget_high_s16(v_row0.val[1])); + v_dst1 = vaddq_s32(v_dst1, vaddl_s16(vget_high_s16(v_row1.val[0]), vget_high_s16(v_row1.val[1]))); + v_dst1 = vshrq_n_s32(vaddq_s32(v_dst1, v_2), 2); + + vst1q_s16(D, vcombine_s16(vmovn_s32(v_dst0), vmovn_s32(v_dst1))); + } + } + else if (cn == 4) + { + for ( ; dx <= w - 4; dx += 4, S0 += 8, S1 += 8, D += 4) + { + int16x8_t v_row0 = vld1q_s16(S0), v_row1 = vld1q_s16(S1); + int32x4_t v_dst = vaddq_s32(vaddl_s16(vget_low_s16(v_row0), vget_high_s16(v_row0)), + vaddl_s16(vget_low_s16(v_row1), vget_high_s16(v_row1))); + vst1_s16(D, vmovn_s32(vshrq_n_s32(vaddq_s32(v_dst, v_2), 2))); + } + } + + return dx; + } + +private: + int cn, step; +}; + +struct ResizeAreaFastVec_SIMD_32f +{ + ResizeAreaFastVec_SIMD_32f(int _scale_x, int _scale_y, int _cn, int _step) : + scale_x(_scale_x), scale_y(_scale_y), cn(_cn), step(_step) + { + fast_mode = scale_x == 2 && scale_y == 2 && (cn == 1 || cn == 3 || cn == 4); + } + + int operator() (const float * S, float * D, int w) const + { + if (!fast_mode) + return 0; + + const float * S0 = S, * S1 = (const float *)((const uchar *)(S0) + step); + int dx = 0; + + float32x4_t v_025 = vdupq_n_f32(0.25f); + + if (cn == 1) + { + for ( ; dx <= w - 4; dx += 4, S0 += 8, S1 += 8, D += 4) + { + float32x4x2_t v_row0 = vld2q_f32(S0), v_row1 = vld2q_f32(S1); + + float32x4_t v_dst0 = vaddq_f32(v_row0.val[0], v_row0.val[1]); + float32x4_t v_dst1 = vaddq_f32(v_row1.val[0], v_row1.val[1]); + + vst1q_f32(D, vmulq_f32(vaddq_f32(v_dst0, v_dst1), v_025)); + } + } + else if (cn == 4) + { + for ( ; dx <= w - 4; dx += 4, S0 += 8, S1 += 8, D += 4) + { + float32x4_t v_dst0 = vaddq_f32(vld1q_f32(S0), vld1q_f32(S0 + 4)); + float32x4_t v_dst1 = vaddq_f32(vld1q_f32(S1), vld1q_f32(S1 + 4)); + + vst1q_f32(D, vmulq_f32(vaddq_f32(v_dst0, v_dst1), v_025)); + } + } + + return dx; + } + +private: + int scale_x, scale_y; + int cn; + bool fast_mode; + int step; +}; + #elif CV_SSE2 class ResizeAreaFastVec_SIMD_8u @@ -1800,9 +2069,16 @@ private: bool use_simd; }; +typedef ResizeAreaFastNoVec ResizeAreaFastVec_SIMD_16s; +typedef ResizeAreaFastNoVec ResizeAreaFastVec_SIMD_32f; + #else + typedef ResizeAreaFastNoVec ResizeAreaFastVec_SIMD_8u; typedef ResizeAreaFastNoVec ResizeAreaFastVec_SIMD_16u; +typedef ResizeAreaFastNoVec ResizeAreaFastVec_SIMD_16s; +typedef ResizeAreaFastNoVec ResizeAreaFastVec_SIMD_32f; + #endif template @@ -2626,14 +2902,14 @@ void cv::resize( InputArray _src, OutputArray _dst, Size dsize, 0, resizeGeneric_, VResizeLanczos4, - VResizeNoVec> >, + VResizeLanczos4Vec_32f16u> >, resizeGeneric_, VResizeLanczos4, - VResizeNoVec> >, + VResizeLanczos4Vec_32f16s> >, 0, resizeGeneric_, VResizeLanczos4, - VResizeNoVec> >, + VResizeLanczos4Vec_32f> >, resizeGeneric_, VResizeLanczos4, VResizeNoVec> >, @@ -2645,9 +2921,9 @@ void cv::resize( InputArray _src, OutputArray _dst, Size dsize, resizeAreaFast_ >, 0, resizeAreaFast_ >, - resizeAreaFast_ > >, + resizeAreaFast_ >, 0, - resizeAreaFast_ >, + resizeAreaFast_, resizeAreaFast_ >, 0 }; @@ -4281,17 +4557,59 @@ void cv::convertMaps( InputArray _map1, InputArray _map2, float* dst2f = dstmap2.ptr(y); short* dst1 = (short*)dst1f; ushort* dst2 = (ushort*)dst2f; + x = 0; if( m1type == CV_32FC1 && dstm1type == CV_16SC2 ) { if( nninterpolate ) - for( x = 0; x < size.width; x++ ) + { + #if CV_NEON + for( ; x <= size.width - 8; x += 8 ) + { + int16x8x2_t v_dst; + v_dst.val[0] = vcombine_s16(vqmovn_s32(cv_vrndq_s32_f32(vld1q_f32(src1f + x))), + vqmovn_s32(cv_vrndq_s32_f32(vld1q_f32(src1f + x + 4)))); + v_dst.val[1] = vcombine_s16(vqmovn_s32(cv_vrndq_s32_f32(vld1q_f32(src2f + x))), + vqmovn_s32(cv_vrndq_s32_f32(vld1q_f32(src2f + x + 4)))); + + vst2q_s16(dst1 + (x << 1), v_dst); + } + #endif + for( ; x < size.width; x++ ) { dst1[x*2] = saturate_cast(src1f[x]); dst1[x*2+1] = saturate_cast(src2f[x]); } + } else - for( x = 0; x < size.width; x++ ) + { + #if CV_NEON + float32x4_t v_scale = vdupq_n_f32((float)INTER_TAB_SIZE); + int32x4_t v_mask = vdupq_n_s32(INTER_TAB_SIZE - 1); + + for( ; x <= size.width - 8; x += 8 ) + { + int32x4_t v_ix0 = cv_vrndq_s32_f32(vmulq_f32(vld1q_f32(src1f + x), v_scale)); + int32x4_t v_ix1 = cv_vrndq_s32_f32(vmulq_f32(vld1q_f32(src1f + x + 4), v_scale)); + int32x4_t v_iy0 = cv_vrndq_s32_f32(vmulq_f32(vld1q_f32(src2f + x), v_scale)); + int32x4_t v_iy1 = cv_vrndq_s32_f32(vmulq_f32(vld1q_f32(src2f + x + 4), v_scale)); + + int16x8x2_t v_dst; + v_dst.val[0] = vcombine_s16(vqmovn_s32(vshrq_n_s32(v_ix0, INTER_BITS)), + vqmovn_s32(vshrq_n_s32(v_ix1, INTER_BITS))); + v_dst.val[1] = vcombine_s16(vqmovn_s32(vshrq_n_s32(v_iy0, INTER_BITS)), + vqmovn_s32(vshrq_n_s32(v_iy1, INTER_BITS))); + + vst2q_s16(dst1 + (x << 1), v_dst); + + uint16x4_t v_dst0 = vqmovun_s32(vaddq_s32(vshlq_n_s32(vandq_s32(v_iy0, v_mask), INTER_BITS), + vandq_s32(v_ix0, v_mask))); + uint16x4_t v_dst1 = vqmovun_s32(vaddq_s32(vshlq_n_s32(vandq_s32(v_iy1, v_mask), INTER_BITS), + vandq_s32(v_ix1, v_mask))); + vst1q_u16(dst2 + x, vcombine_u16(v_dst0, v_dst1)); + } + #endif + for( ; x < size.width; x++ ) { int ix = saturate_cast(src1f[x]*INTER_TAB_SIZE); int iy = saturate_cast(src2f[x]*INTER_TAB_SIZE); @@ -4299,17 +4617,53 @@ void cv::convertMaps( InputArray _map1, InputArray _map2, dst1[x*2+1] = saturate_cast(iy >> INTER_BITS); dst2[x] = (ushort)((iy & (INTER_TAB_SIZE-1))*INTER_TAB_SIZE + (ix & (INTER_TAB_SIZE-1))); } + } } else if( m1type == CV_32FC2 && dstm1type == CV_16SC2 ) { if( nninterpolate ) - for( x = 0; x < size.width; x++ ) + { + #if CV_NEON + for( ; x <= (size.width << 1) - 8; x += 8 ) + vst1q_s16(dst1 + x, vcombine_s16(vqmovn_s32(cv_vrndq_s32_f32(vld1q_f32(src1f + x))), + vqmovn_s32(cv_vrndq_s32_f32(vld1q_f32(src1f + x + 4))))); + #endif + for( ; x < size.width; x++ ) { dst1[x*2] = saturate_cast(src1f[x*2]); dst1[x*2+1] = saturate_cast(src1f[x*2+1]); } + } else - for( x = 0; x < size.width; x++ ) + { + #if CV_NEON + float32x4_t v_scale = vdupq_n_f32((float)INTER_TAB_SIZE); + int32x4_t v_mask = vdupq_n_s32(INTER_TAB_SIZE - 1); + + for( ; x <= size.width - 8; x += 8 ) + { + float32x4x2_t v_src0 = vld2q_f32(src1f + (x << 1)), v_src1 = vld2q_f32(src1f + (x << 1) + 8); + int32x4_t v_ix0 = cv_vrndq_s32_f32(vmulq_f32(v_src0.val[0], v_scale)); + int32x4_t v_ix1 = cv_vrndq_s32_f32(vmulq_f32(v_src1.val[0], v_scale)); + int32x4_t v_iy0 = cv_vrndq_s32_f32(vmulq_f32(v_src0.val[1], v_scale)); + int32x4_t v_iy1 = cv_vrndq_s32_f32(vmulq_f32(v_src1.val[1], v_scale)); + + int16x8x2_t v_dst; + v_dst.val[0] = vcombine_s16(vqmovn_s32(vshrq_n_s32(v_ix0, INTER_BITS)), + vqmovn_s32(vshrq_n_s32(v_ix1, INTER_BITS))); + v_dst.val[1] = vcombine_s16(vqmovn_s32(vshrq_n_s32(v_iy0, INTER_BITS)), + vqmovn_s32(vshrq_n_s32(v_iy1, INTER_BITS))); + + vst2q_s16(dst1 + (x << 1), v_dst); + + uint16x4_t v_dst0 = vqmovun_s32(vaddq_s32(vshlq_n_s32(vandq_s32(v_iy0, v_mask), INTER_BITS), + vandq_s32(v_ix0, v_mask))); + uint16x4_t v_dst1 = vqmovun_s32(vaddq_s32(vshlq_n_s32(vandq_s32(v_iy1, v_mask), INTER_BITS), + vandq_s32(v_ix1, v_mask))); + vst1q_u16(dst2 + x, vcombine_u16(v_dst0, v_dst1)); + } + #endif + for( ; x < size.width; x++ ) { int ix = saturate_cast(src1f[x*2]*INTER_TAB_SIZE); int iy = saturate_cast(src1f[x*2+1]*INTER_TAB_SIZE); @@ -4317,10 +4671,44 @@ void cv::convertMaps( InputArray _map1, InputArray _map2, dst1[x*2+1] = saturate_cast(iy >> INTER_BITS); dst2[x] = (ushort)((iy & (INTER_TAB_SIZE-1))*INTER_TAB_SIZE + (ix & (INTER_TAB_SIZE-1))); } + } } else if( m1type == CV_16SC2 && dstm1type == CV_32FC1 ) { - for( x = 0; x < size.width; x++ ) + #if CV_NEON + uint16x8_t v_mask2 = vdupq_n_u16(INTER_TAB_SIZE2-1); + uint32x4_t v_zero = vdupq_n_u32(0u), v_mask = vdupq_n_u32(INTER_TAB_SIZE-1); + float32x4_t v_scale = vdupq_n_f32(scale); + + for( ; x <= size.width - 8; x += 8) + { + uint32x4_t v_fxy1, v_fxy2; + if (src2) + { + uint16x8_t v_src2 = vandq_u16(vld1q_u16(src2 + x), v_mask2); + v_fxy1 = vmovl_u16(vget_low_u16(v_src2)); + v_fxy2 = vmovl_u16(vget_high_u16(v_src2)); + } + else + v_fxy1 = v_fxy2 = v_zero; + + int16x8x2_t v_src = vld2q_s16(src1 + (x << 1)); + float32x4_t v_dst1 = vmlaq_f32(vcvtq_f32_s32(vmovl_s16(vget_low_s16(v_src.val[0]))), + v_scale, vcvtq_f32_u32(vandq_u32(v_fxy1, v_mask))); + float32x4_t v_dst2 = vmlaq_f32(vcvtq_f32_s32(vmovl_s16(vget_low_s16(v_src.val[1]))), + v_scale, vcvtq_f32_u32(vshrq_n_u32(v_fxy1, INTER_BITS))); + vst1q_f32(dst1f + x, v_dst1); + vst1q_f32(dst2f + x, v_dst2); + + v_dst1 = vmlaq_f32(vcvtq_f32_s32(vmovl_s16(vget_high_s16(v_src.val[0]))), + v_scale, vcvtq_f32_u32(vandq_u32(v_fxy2, v_mask))); + v_dst2 = vmlaq_f32(vcvtq_f32_s32(vmovl_s16(vget_high_s16(v_src.val[1]))), + v_scale, vcvtq_f32_u32(vshrq_n_u32(v_fxy2, INTER_BITS))); + vst1q_f32(dst1f + x + 4, v_dst1); + vst1q_f32(dst2f + x + 4, v_dst2); + } + #endif + for( ; x < size.width; x++ ) { int fxy = src2 ? src2[x] & (INTER_TAB_SIZE2-1) : 0; dst1f[x] = src1[x*2] + (fxy & (INTER_TAB_SIZE-1))*scale; @@ -4329,7 +4717,39 @@ void cv::convertMaps( InputArray _map1, InputArray _map2, } else if( m1type == CV_16SC2 && dstm1type == CV_32FC2 ) { - for( x = 0; x < size.width; x++ ) + #if CV_NEON + int16x8_t v_mask2 = vdupq_n_s16(INTER_TAB_SIZE2-1); + int32x4_t v_zero = vdupq_n_s32(0), v_mask = vdupq_n_s32(INTER_TAB_SIZE-1); + float32x4_t v_scale = vdupq_n_f32(scale); + + for( ; x <= size.width - 8; x += 8) + { + int32x4_t v_fxy1, v_fxy2; + if (src2) + { + int16x8_t v_src2 = vandq_s16(vld1q_s16((short *)src2 + x), v_mask2); + v_fxy1 = vmovl_s16(vget_low_s16(v_src2)); + v_fxy2 = vmovl_s16(vget_high_s16(v_src2)); + } + else + v_fxy1 = v_fxy2 = v_zero; + + int16x8x2_t v_src = vld2q_s16(src1 + (x << 1)); + float32x4x2_t v_dst; + v_dst.val[0] = vmlaq_f32(vcvtq_f32_s32(vmovl_s16(vget_low_s16(v_src.val[0]))), + v_scale, vcvtq_f32_s32(vandq_s32(v_fxy1, v_mask))); + v_dst.val[1] = vmlaq_f32(vcvtq_f32_s32(vmovl_s16(vget_low_s16(v_src.val[1]))), + v_scale, vcvtq_f32_s32(vshrq_n_s32(v_fxy1, INTER_BITS))); + vst2q_f32(dst1f + (x << 1), v_dst); + + v_dst.val[0] = vmlaq_f32(vcvtq_f32_s32(vmovl_s16(vget_high_s16(v_src.val[0]))), + v_scale, vcvtq_f32_s32(vandq_s32(v_fxy2, v_mask))); + v_dst.val[1] = vmlaq_f32(vcvtq_f32_s32(vmovl_s16(vget_high_s16(v_src.val[1]))), + v_scale, vcvtq_f32_s32(vshrq_n_s32(v_fxy2, INTER_BITS))); + vst2q_f32(dst1f + (x << 1) + 8, v_dst); + } + #endif + for( ; x < size.width; x++ ) { int fxy = src2 ? src2[x] & (INTER_TAB_SIZE2-1): 0; dst1f[x*2] = src1[x*2] + (fxy & (INTER_TAB_SIZE-1))*scale; @@ -4389,13 +4809,29 @@ public: int Y0 = saturate_cast((M[4]*(y + y1) + M[5])*AB_SCALE) + round_delta; if( interpolation == INTER_NEAREST ) - for( x1 = 0; x1 < bw; x1++ ) + { + x1 = 0; + #if CV_NEON + int32x4_t v_X0 = vdupq_n_s32(X0), v_Y0 = vdupq_n_s32(Y0); + for( ; x1 <= bw - 8; x1 += 8 ) + { + int16x8x2_t v_dst; + v_dst.val[0] = vcombine_s16(vqmovn_s32(vshrq_n_s32(vaddq_s32(v_X0, vld1q_s32(adelta + x + x1)), AB_BITS)), + vqmovn_s32(vshrq_n_s32(vaddq_s32(v_X0, vld1q_s32(adelta + x + x1 + 4)), AB_BITS))); + v_dst.val[1] = vcombine_s16(vqmovn_s32(vshrq_n_s32(vaddq_s32(v_Y0, vld1q_s32(bdelta + x + x1)), AB_BITS)), + vqmovn_s32(vshrq_n_s32(vaddq_s32(v_Y0, vld1q_s32(bdelta + x + x1 + 4)), AB_BITS))); + + vst2q_s16(xy + (x1 << 1), v_dst); + } + #endif + for( ; x1 < bw; x1++ ) { int X = (X0 + adelta[x+x1]) >> AB_BITS; int Y = (Y0 + bdelta[x+x1]) >> AB_BITS; xy[x1*2] = saturate_cast(X); xy[x1*2+1] = saturate_cast(Y); } + } else { short* alpha = A + y1*bw; @@ -4433,6 +4869,27 @@ public: _mm_storeu_si128((__m128i*)(alpha + x1), fx_); } } + #elif CV_NEON + int32x4_t v__X0 = vdupq_n_s32(X0), v__Y0 = vdupq_n_s32(Y0), v_mask = vdupq_n_s32(INTER_TAB_SIZE - 1); + for( ; x1 <= bw - 8; x1 += 8 ) + { + int32x4_t v_X0 = vshrq_n_s32(vaddq_s32(v__X0, vld1q_s32(adelta + x + x1)), AB_BITS - INTER_BITS); + int32x4_t v_Y0 = vshrq_n_s32(vaddq_s32(v__Y0, vld1q_s32(bdelta + x + x1)), AB_BITS - INTER_BITS); + int32x4_t v_X1 = vshrq_n_s32(vaddq_s32(v__X0, vld1q_s32(adelta + x + x1 + 4)), AB_BITS - INTER_BITS); + int32x4_t v_Y1 = vshrq_n_s32(vaddq_s32(v__Y0, vld1q_s32(bdelta + x + x1 + 4)), AB_BITS - INTER_BITS); + + int16x8x2_t v_xy; + v_xy.val[0] = vcombine_s16(vqmovn_s32(vshrq_n_s32(v_X0, INTER_BITS)), vqmovn_s32(vshrq_n_s32(v_X1, INTER_BITS))); + v_xy.val[1] = vcombine_s16(vqmovn_s32(vshrq_n_s32(v_Y0, INTER_BITS)), vqmovn_s32(vshrq_n_s32(v_Y1, INTER_BITS))); + + vst2q_s16(xy + (x1 << 1), v_xy); + + int16x4_t v_alpha0 = vmovn_s32(vaddq_s32(vshlq_n_s32(vandq_s32(v_Y0, v_mask), INTER_BITS), + vandq_s32(v_X0, v_mask))); + int16x4_t v_alpha1 = vmovn_s32(vaddq_s32(vshlq_n_s32(vandq_s32(v_Y1, v_mask), INTER_BITS), + vandq_s32(v_X1, v_mask))); + vst1q_s16(alpha + x1, vcombine_s16(v_alpha0, v_alpha1)); + } #endif for( ; x1 < bw; x1++ ) { diff --git a/modules/imgproc/src/opencl/canny.cl b/modules/imgproc/src/opencl/canny.cl index dd455d04b5..caa7969032 100644 --- a/modules/imgproc/src/opencl/canny.cl +++ b/modules/imgproc/src/opencl/canny.cl @@ -49,9 +49,9 @@ #ifdef WITH_SOBEL #if cn == 1 -#define loadpix(addr) convert_intN(*(__global const TYPE *)(addr)) +#define loadpix(addr) convert_floatN(*(__global const TYPE *)(addr)) #else -#define loadpix(addr) convert_intN(vload3(0, (__global const TYPE *)(addr))) +#define loadpix(addr) convert_floatN(vload3(0, (__global const TYPE *)(addr))) #endif #define storepix(value, addr) *(__global int *)(addr) = (int)(value) @@ -77,23 +77,21 @@ __constant int next[4][2] = { { 1, 1 } }; -inline int3 sobel(int idx, __local const intN *smem) +inline float3 sobel(int idx, __local const floatN *smem) { // result: x, y, mag - int3 res; + float3 res; - intN dx = smem[idx + 2] - smem[idx] - + 2 * (smem[idx + GRP_SIZEX + 6] - smem[idx + GRP_SIZEX + 4]) - + smem[idx + 2 * GRP_SIZEX + 10] - smem[idx + 2 * GRP_SIZEX + 8]; + floatN dx = fma(2, smem[idx + GRP_SIZEX + 6] - smem[idx + GRP_SIZEX + 4], + smem[idx + 2] - smem[idx] + smem[idx + 2 * GRP_SIZEX + 10] - smem[idx + 2 * GRP_SIZEX + 8]); - intN dy = smem[idx] - smem[idx + 2 * GRP_SIZEX + 8] - + 2 * (smem[idx + 1] - smem[idx + 2 * GRP_SIZEX + 9]) - + smem[idx + 2] - smem[idx + 2 * GRP_SIZEX + 10]; + floatN dy = fma(2, smem[idx + 1] - smem[idx + 2 * GRP_SIZEX + 9], + smem[idx + 2] - smem[idx + 2 * GRP_SIZEX + 10] + smem[idx] - smem[idx + 2 * GRP_SIZEX + 8]); #ifdef L2GRAD - intN magN = dx * dx + dy * dy; + floatN magN = fma(dx, dx, dy * dy); #else - intN magN = convert_intN(abs(dx) + abs(dy)); + floatN magN = fabs(dx) + fabs(dy); #endif #if cn == 1 res.z = magN; @@ -120,9 +118,9 @@ inline int3 sobel(int idx, __local const intN *smem) __kernel void stage1_with_sobel(__global const uchar *src, int src_step, int src_offset, int rows, int cols, __global uchar *map, int map_step, int map_offset, - int low_thr, int high_thr) + float low_thr, float high_thr) { - __local intN smem[(GRP_SIZEX + 4) * (GRP_SIZEY + 4)]; + __local floatN smem[(GRP_SIZEX + 4) * (GRP_SIZEY + 4)]; int lidx = get_local_id(0); int lidy = get_local_id(1); @@ -143,7 +141,7 @@ __kernel void stage1_with_sobel(__global const uchar *src, int src_step, int src //// Sobel, Magnitude // - __local int mag[(GRP_SIZEX + 2) * (GRP_SIZEY + 2)]; + __local float mag[(GRP_SIZEX + 2) * (GRP_SIZEY + 2)]; lidx++; lidy++; @@ -164,13 +162,13 @@ __kernel void stage1_with_sobel(__global const uchar *src, int src_step, int src int idx = lidx + lidy * (GRP_SIZEX + 4); i = lidx + lidy * (GRP_SIZEX + 2); - int3 res = sobel(idx, smem); + float3 res = sobel(idx, smem); mag[i] = res.z; - int x = res.x; - int y = res.y; - barrier(CLK_LOCAL_MEM_FENCE); + int x = (int) res.x; + int y = (int) res.y; + //// Threshold + Non maxima suppression // @@ -218,7 +216,7 @@ __kernel void stage1_with_sobel(__global const uchar *src, int src_step, int src if (gidx >= cols || gidy >= rows) return; - int mag0 = mag[i]; + float mag0 = mag[i]; int value = 1; if (mag0 > low_thr) @@ -235,8 +233,8 @@ __kernel void stage1_with_sobel(__global const uchar *src, int src_step, int src int dir3 = (a * b) & (((x ^ y) & 0x80000000) >> 31); // if a = 1, b = 1, dy ^ dx < 0 int dir = a * b + 2 * dir3; - int prev_mag = mag[(lidy + prev[dir][0]) * (GRP_SIZEX + 2) + lidx + prev[dir][1]]; - int next_mag = mag[(lidy + next[dir][0]) * (GRP_SIZEX + 2) + lidx + next[dir][1]] + (dir & 1); + float prev_mag = mag[(lidy + prev[dir][0]) * (GRP_SIZEX + 2) + lidx + prev[dir][1]]; + float next_mag = mag[(lidy + next[dir][0]) * (GRP_SIZEX + 2) + lidx + next[dir][1]] + (dir & 1); if (mag0 > prev_mag && mag0 >= next_mag) { @@ -384,12 +382,12 @@ __constant short move_dir[2][8] = { { -1, 0, 1, -1, 1, -1, 0, 1 } }; -__kernel void stage2_hysteresis(__global uchar *map, int map_step, int map_offset, int rows, int cols) +__kernel void stage2_hysteresis(__global uchar *map_ptr, int map_step, int map_offset, int rows, int cols) { - map += map_offset; + map_ptr += map_offset; int x = get_global_id(0); - int y0 = get_global_id(1) * PIX_PER_WI; + int y = get_global_id(1) * PIX_PER_WI; int lid = get_local_id(0) + get_local_id(1) * LOCAL_X; @@ -400,15 +398,23 @@ __kernel void stage2_hysteresis(__global uchar *map, int map_step, int map_offse l_counter = 0; barrier(CLK_LOCAL_MEM_FENCE); - #pragma unroll - for (int y = y0; y < min(y0 + PIX_PER_WI, rows); ++y) + if (x < cols) { - if (x < cols) + __global uchar* map = map_ptr + mad24(y, map_step, x * (int)sizeof(int)); + + #pragma unroll + for (int cy = 0; cy < PIX_PER_WI; ++cy) { - int type = loadpix(map + mad24(y, map_step, x * (int)sizeof(int))); - if (type == 2) + if (y < rows) { - l_stack[atomic_inc(&l_counter)] = (ushort2)(x, y); + int type = loadpix(map); + if (type == 2) + { + l_stack[atomic_inc(&l_counter)] = (ushort2)(x, y); + } + + y++; + map += map_step; } } } @@ -422,7 +428,6 @@ __kernel void stage2_hysteresis(__global uchar *map, int map_step, int map_offse int mod = l_counter % LOCAL_TOTAL; int pix_per_thr = l_counter / LOCAL_TOTAL + ((lid < mod) ? 1 : 0); - #pragma unroll for (int i = 0; i < pix_per_thr; ++i) { ushort2 pos = l_stack[ atomic_dec(&l_counter) - 1 ]; @@ -434,7 +439,7 @@ __kernel void stage2_hysteresis(__global uchar *map, int map_step, int map_offse ushort posy = pos.y + move_dir[1][j]; if (posx < 0 || posy < 0 || posx >= cols || posy >= rows) continue; - __global uchar *addr = map + mad24(posy, map_step, posx * (int)sizeof(int)); + __global uchar *addr = map_ptr + mad24(posy, map_step, posx * (int)sizeof(int)); int type = loadpix(addr); if (type == 0) { @@ -463,16 +468,26 @@ __kernel void getEdges(__global const uchar *mapptr, int map_step, int map_offse __global uchar *dst, int dst_step, int dst_offset) { int x = get_global_id(0); - int y0 = get_global_id(1) * PIX_PER_WI; + int y = get_global_id(1) * PIX_PER_WI; - #pragma unroll - for (int y = y0; y < min(y0 + PIX_PER_WI, rows); ++y) + if (x < cols) { int map_index = mad24(map_step, y, mad24(x, (int)sizeof(int), map_offset)); - int dst_index = mad24(dst_step, y, x) + dst_offset; + int dst_index = mad24(dst_step, y, x + dst_offset); + + #pragma unroll + for (int cy = 0; cy < PIX_PER_WI; ++cy) + { + if (y < rows) + { + __global const int * map = (__global const int *)(mapptr + map_index); + dst[dst_index] = (uchar)(-(map[0] >> 1)); - __global const int * map = (__global const int *)(mapptr + map_index); - dst[dst_index] = (uchar)(-(map[0] >> 1)); + y++; + map_index += map_step; + dst_index += dst_step; + } + } } } diff --git a/modules/imgproc/src/opencl/hough_lines.cl b/modules/imgproc/src/opencl/hough_lines.cl index f318133ec4..4c2d0a94cd 100644 --- a/modules/imgproc/src/opencl/hough_lines.cl +++ b/modules/imgproc/src/opencl/hough_lines.cl @@ -184,146 +184,149 @@ __kernel void get_lines(__global const uchar * accum_ptr, int accum_step, int ac int x = get_global_id(0); int y = get_global_id(1); - __global uchar* accum = accum_ptr + mad24(y+1, accum_step, mad24(x+1, (int) sizeof(int), accum_offset)); - __global int4* lines = (__global int4*)(lines_ptr + lines_offset); - __global int* lines_index = lines_index_ptr + 1; - - int curVote = ACCUM(accum); - - if (curVote >= threshold && - curVote > ACCUM(accum - accum_step - sizeof(int)) && - curVote > ACCUM(accum - accum_step) && - curVote > ACCUM(accum - accum_step + sizeof(int)) && - curVote > ACCUM(accum - sizeof(int)) && - curVote > ACCUM(accum + sizeof(int)) && - curVote > ACCUM(accum + accum_step - sizeof(int)) && - curVote > ACCUM(accum + accum_step) && - curVote > ACCUM(accum + accum_step + sizeof(int))) + if (y < accum_rows-2) { - const float radius = (x - (accum_cols - 2 - 1) * 0.5f) * rho; - const float angle = y * theta; - - float cosa; - float sina = sincos(angle, &cosa); - - float2 p0 = (float2)(cosa * radius, sina * radius); - float2 dir = (float2)(-sina, cosa); - - float2 pb[4] = { (float2)(-1, -1), (float2)(-1, -1), (float2)(-1, -1), (float2)(-1, -1) }; - float a; + __global uchar* accum = accum_ptr + mad24(y+1, accum_step, mad24(x+1, (int) sizeof(int), accum_offset)); + __global int4* lines = (__global int4*)(lines_ptr + lines_offset); + __global int* lines_index = lines_index_ptr + 1; - if (dir.x != 0) + int curVote = ACCUM(accum); + + if (curVote >= threshold && + curVote > ACCUM(accum - accum_step - sizeof(int)) && + curVote > ACCUM(accum - accum_step) && + curVote > ACCUM(accum - accum_step + sizeof(int)) && + curVote > ACCUM(accum - sizeof(int)) && + curVote > ACCUM(accum + sizeof(int)) && + curVote > ACCUM(accum + accum_step - sizeof(int)) && + curVote > ACCUM(accum + accum_step) && + curVote > ACCUM(accum + accum_step + sizeof(int))) { - a = -p0.x / dir.x; - pb[0].x = 0; - pb[0].y = p0.y + a * dir.y; + const float radius = (x - (accum_cols - 2 - 1) * 0.5f) * rho; + const float angle = y * theta; - a = (src_cols - 1 - p0.x) / dir.x; - pb[1].x = src_cols - 1; - pb[1].y = p0.y + a * dir.y; - } + float cosa; + float sina = sincos(angle, &cosa); - if (dir.y != 0) - { - a = -p0.y / dir.y; - pb[2].x = p0.x + a * dir.x; - pb[2].y = 0; + float2 p0 = (float2)(cosa * radius, sina * radius); + float2 dir = (float2)(-sina, cosa); - a = (src_rows - 1 - p0.y) / dir.y; - pb[3].x = p0.x + a * dir.x; - pb[3].y = src_rows - 1; - } + float2 pb[4] = { (float2)(-1, -1), (float2)(-1, -1), (float2)(-1, -1), (float2)(-1, -1) }; + float a; - if (pb[0].x == 0 && (pb[0].y >= 0 && pb[0].y < src_rows)) - { - p0 = pb[0]; - if (dir.x < 0) - dir = -dir; - } - else if (pb[1].x == src_cols - 1 && (pb[1].y >= 0 && pb[1].y < src_rows)) - { - p0 = pb[1]; - if (dir.x > 0) - dir = -dir; - } - else if (pb[2].y == 0 && (pb[2].x >= 0 && pb[2].x < src_cols)) - { - p0 = pb[2]; - if (dir.y < 0) - dir = -dir; - } - else if (pb[3].y == src_rows - 1 && (pb[3].x >= 0 && pb[3].x < src_cols)) - { - p0 = pb[3]; - if (dir.y > 0) - dir = -dir; - } + if (dir.x != 0) + { + a = -p0.x / dir.x; + pb[0].x = 0; + pb[0].y = p0.y + a * dir.y; - dir /= max(fabs(dir.x), fabs(dir.y)); + a = (src_cols - 1 - p0.x) / dir.x; + pb[1].x = src_cols - 1; + pb[1].y = p0.y + a * dir.y; + } - float2 line_end[2]; - int gap; - bool inLine = false; + if (dir.y != 0) + { + a = -p0.y / dir.y; + pb[2].x = p0.x + a * dir.x; + pb[2].y = 0; - if (p0.x < 0 || p0.x >= src_cols || p0.y < 0 || p0.y >= src_rows) - return; + a = (src_rows - 1 - p0.y) / dir.y; + pb[3].x = p0.x + a * dir.x; + pb[3].y = src_rows - 1; + } - for (;;) - { - if (*(src_ptr + mad24(p0.y, src_step, p0.x + src_offset))) + if (pb[0].x == 0 && (pb[0].y >= 0 && pb[0].y < src_rows)) { - gap = 0; - - if (!inLine) - { - line_end[0] = p0; - line_end[1] = p0; - inLine = true; - } - else - { - line_end[1] = p0; - } + p0 = pb[0]; + if (dir.x < 0) + dir = -dir; } - else if (inLine) + else if (pb[1].x == src_cols - 1 && (pb[1].y >= 0 && pb[1].y < src_rows)) { - if (++gap > lineGap) - { - bool good_line = fabs(line_end[1].x - line_end[0].x) >= lineLength || - fabs(line_end[1].y - line_end[0].y) >= lineLength; + p0 = pb[1]; + if (dir.x > 0) + dir = -dir; + } + else if (pb[2].y == 0 && (pb[2].x >= 0 && pb[2].x < src_cols)) + { + p0 = pb[2]; + if (dir.y < 0) + dir = -dir; + } + else if (pb[3].y == src_rows - 1 && (pb[3].x >= 0 && pb[3].x < src_cols)) + { + p0 = pb[3]; + if (dir.y > 0) + dir = -dir; + } - if (good_line) - { - int index = atomic_inc(lines_index); - if (index < linesMax) - lines[index] = (int4)(line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y); - } + dir /= max(fabs(dir.x), fabs(dir.y)); - gap = 0; - inLine = false; - } - } + float2 line_end[2]; + int gap; + bool inLine = false; - p0 = p0 + dir; if (p0.x < 0 || p0.x >= src_cols || p0.y < 0 || p0.y >= src_rows) + return; + + for (;;) { - if (inLine) + if (*(src_ptr + mad24(p0.y, src_step, p0.x + src_offset))) { - bool good_line = fabs(line_end[1].x - line_end[0].x) >= lineLength || - fabs(line_end[1].y - line_end[0].y) >= lineLength; + gap = 0; - if (good_line) + if (!inLine) + { + line_end[0] = p0; + line_end[1] = p0; + inLine = true; + } + else { - int index = atomic_inc(lines_index); - if (index < linesMax) - lines[index] = (int4)(line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y); + line_end[1] = p0; } + } + else if (inLine) + { + if (++gap > lineGap) + { + bool good_line = fabs(line_end[1].x - line_end[0].x) >= lineLength || + fabs(line_end[1].y - line_end[0].y) >= lineLength; + + if (good_line) + { + int index = atomic_inc(lines_index); + if (index < linesMax) + lines[index] = (int4)(line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y); + } + + gap = 0; + inLine = false; + } + } + p0 = p0 + dir; + if (p0.x < 0 || p0.x >= src_cols || p0.y < 0 || p0.y >= src_rows) + { + if (inLine) + { + bool good_line = fabs(line_end[1].x - line_end[0].x) >= lineLength || + fabs(line_end[1].y - line_end[0].y) >= lineLength; + + if (good_line) + { + int index = atomic_inc(lines_index); + if (index < linesMax) + lines[index] = (int4)(line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y); + } + + } + break; } - break; } - } + } } } diff --git a/modules/imgproc/src/pyramids.cpp b/modules/imgproc/src/pyramids.cpp index 164ae50161..e510530afd 100644 --- a/modules/imgproc/src/pyramids.cpp +++ b/modules/imgproc/src/pyramids.cpp @@ -60,11 +60,16 @@ template struct FltCast rtype operator ()(type1 arg) const { return arg*(T)(1./(1 << shift)); } }; -template struct NoVec +template struct PyrDownNoVec { int operator()(T1**, T2*, int, int) const { return 0; } }; +template struct PyrUpNoVec +{ + int operator()(T1**, T2**, int, int) const { return 0; } +}; + #if CV_SSE2 struct PyrDownVec_32s8u @@ -178,10 +183,13 @@ struct PyrDownVec_32f } }; -typedef NoVec PyrDownVec_32s16u; -typedef NoVec PyrDownVec_32s16s; +typedef PyrDownNoVec PyrDownVec_32s16u; +typedef PyrDownNoVec PyrDownVec_32s16s; -typedef NoVec PyrUpVec_32f; +typedef PyrUpNoVec PyrUpVec_32s8u; +typedef PyrUpNoVec PyrUpVec_32s16s; +typedef PyrUpNoVec PyrUpVec_32s16u; +typedef PyrUpNoVec PyrUpVec_32f; #elif CV_NEON @@ -203,9 +211,9 @@ struct PyrDownVec_32s8u uint16x8_t v_r3 = vcombine_u16(vqmovn_u32(vld1q_u32(row3 + x)), vqmovn_u32(vld1q_u32(row3 + x + 4))); uint16x8_t v_r4 = vcombine_u16(vqmovn_u32(vld1q_u32(row4 + x)), vqmovn_u32(vld1q_u32(row4 + x + 4))); - v_r0 = vqaddq_u16(vqaddq_u16(v_r0, v_r4), vqaddq_u16(v_r2, v_r2)); - v_r1 = vqaddq_u16(vqaddq_u16(v_r1, v_r2), v_r3); - uint16x8_t v_dst0 = vqaddq_u16(v_r0, vshlq_n_u16(v_r1, 2)); + v_r0 = vaddq_u16(vaddq_u16(v_r0, v_r4), vaddq_u16(v_r2, v_r2)); + v_r1 = vaddq_u16(vaddq_u16(v_r1, v_r2), v_r3); + uint16x8_t v_dst0 = vaddq_u16(v_r0, vshlq_n_u16(v_r1, 2)); v_r0 = vcombine_u16(vqmovn_u32(vld1q_u32(row0 + x + 8)), vqmovn_u32(vld1q_u32(row0 + x + 12))); v_r1 = vcombine_u16(vqmovn_u32(vld1q_u32(row1 + x + 8)), vqmovn_u32(vld1q_u32(row1 + x + 12))); @@ -213,9 +221,9 @@ struct PyrDownVec_32s8u v_r3 = vcombine_u16(vqmovn_u32(vld1q_u32(row3 + x + 8)), vqmovn_u32(vld1q_u32(row3 + x + 12))); v_r4 = vcombine_u16(vqmovn_u32(vld1q_u32(row4 + x + 8)), vqmovn_u32(vld1q_u32(row4 + x + 12))); - v_r0 = vqaddq_u16(vqaddq_u16(v_r0, v_r4), vqaddq_u16(v_r2, v_r2)); - v_r1 = vqaddq_u16(vqaddq_u16(v_r1, v_r2), v_r3); - uint16x8_t v_dst1 = vqaddq_u16(v_r0, vshlq_n_u16(v_r1, 2)); + v_r0 = vaddq_u16(vaddq_u16(v_r0, v_r4), vaddq_u16(v_r2, v_r2)); + v_r1 = vaddq_u16(vaddq_u16(v_r1, v_r2), v_r3); + uint16x8_t v_dst1 = vaddq_u16(v_r0, vshlq_n_u16(v_r1, 2)); vst1q_u8(dst + x, vcombine_u8(vqmovn_u16(vshrq_n_u16(vaddq_u16(v_dst0, v_delta), 8)), vqmovn_u16(vshrq_n_u16(vaddq_u16(v_dst1, v_delta), 8)))); @@ -240,18 +248,17 @@ struct PyrDownVec_32s16u int32x4_t v_r20 = vld1q_s32(row2 + x), v_r21 = vld1q_s32(row2 + x + 4); int32x4_t v_r30 = vld1q_s32(row3 + x), v_r31 = vld1q_s32(row3 + x + 4); int32x4_t v_r40 = vld1q_s32(row4 + x), v_r41 = vld1q_s32(row4 + x + 4); - int32x4_t shifted; - v_r00 = vaddq_s32(vqaddq_s32(v_r00, v_r40), vqaddq_s32(v_r20, v_r20)); - v_r10 = vaddq_s32(vqaddq_s32(v_r10, v_r20), v_r30); + v_r00 = vaddq_s32(vaddq_s32(v_r00, v_r40), vaddq_s32(v_r20, v_r20)); + v_r10 = vaddq_s32(vaddq_s32(v_r10, v_r20), v_r30); - shifted = vshlq_n_s32(v_r10, 2); - int32x4_t v_dst0 = vshrq_n_s32(vaddq_s32(vqaddq_s32(v_r00, shifted), v_delta), 8); + v_r10 = vshlq_n_s32(v_r10, 2); + int32x4_t v_dst0 = vshrq_n_s32(vaddq_s32(vaddq_s32(v_r00, v_r10), v_delta), 8); - v_r01 = vaddq_s32(vqaddq_s32(v_r01, v_r41), vqaddq_s32(v_r21, v_r21)); - v_r11 = vaddq_s32(vqaddq_s32(v_r11, v_r21), v_r31); - shifted = vshlq_n_s32(v_r11, 2); - int32x4_t v_dst1 = vshrq_n_s32(vaddq_s32(vqaddq_s32(v_r01, shifted), v_delta), 8); + v_r01 = vaddq_s32(vaddq_s32(v_r01, v_r41), vaddq_s32(v_r21, v_r21)); + v_r11 = vaddq_s32(vaddq_s32(v_r11, v_r21), v_r31); + v_r11 = vshlq_n_s32(v_r11, 2); + int32x4_t v_dst1 = vshrq_n_s32(vaddq_s32(vaddq_s32(v_r01, v_r11), v_delta), 8); vst1q_u16(dst + x, vcombine_u16(vqmovun_s32(v_dst0), vqmovun_s32(v_dst1))); } @@ -275,17 +282,16 @@ struct PyrDownVec_32s16s int32x4_t v_r20 = vld1q_s32(row2 + x), v_r21 = vld1q_s32(row2 + x + 4); int32x4_t v_r30 = vld1q_s32(row3 + x), v_r31 = vld1q_s32(row3 + x + 4); int32x4_t v_r40 = vld1q_s32(row4 + x), v_r41 = vld1q_s32(row4 + x + 4); - int32x4_t shifted; - v_r00 = vaddq_s32(vqaddq_s32(v_r00, v_r40), vqaddq_s32(v_r20, v_r20)); - v_r10 = vaddq_s32(vqaddq_s32(v_r10, v_r20), v_r30); - shifted = vshlq_n_s32(v_r10, 2); - int32x4_t v_dst0 = vshrq_n_s32(vaddq_s32(vqaddq_s32(v_r00, shifted), v_delta), 8); + v_r00 = vaddq_s32(vaddq_s32(v_r00, v_r40), vaddq_s32(v_r20, v_r20)); + v_r10 = vaddq_s32(vaddq_s32(v_r10, v_r20), v_r30); + v_r10 = vshlq_n_s32(v_r10, 2); + int32x4_t v_dst0 = vshrq_n_s32(vaddq_s32(vaddq_s32(v_r00, v_r10), v_delta), 8); - v_r01 = vaddq_s32(vqaddq_s32(v_r01, v_r41), vqaddq_s32(v_r21, v_r21)); - v_r11 = vaddq_s32(vqaddq_s32(v_r11, v_r21), v_r31); - shifted = vshlq_n_s32(v_r11, 2); - int32x4_t v_dst1 = vshrq_n_s32(vaddq_s32(vqaddq_s32(v_r01, shifted), v_delta), 8); + v_r01 = vaddq_s32(vaddq_s32(v_r01, v_r41), vaddq_s32(v_r21, v_r21)); + v_r11 = vaddq_s32(vaddq_s32(v_r11, v_r21), v_r31); + v_r11 = vshlq_n_s32(v_r11, 2); + int32x4_t v_dst1 = vshrq_n_s32(vaddq_s32(vaddq_s32(v_r01, v_r11), v_delta), 8); vst1q_s16(dst + x, vcombine_s16(vqmovn_s32(v_dst0), vqmovn_s32(v_dst1))); } @@ -329,14 +335,156 @@ struct PyrDownVec_32f } }; +struct PyrUpVec_32s8u +{ + int operator()(int** src, uchar** dst, int, int width) const + { + int x = 0; + uchar *dst0 = dst[0], *dst1 = dst[1]; + const uint *row0 = (uint *)src[0], *row1 = (uint *)src[1], *row2 = (uint *)src[2]; + uint16x8_t v_delta = vdupq_n_u16(32); + + for( ; x <= width - 16; x += 16 ) + { + uint16x8_t v_r0 = vcombine_u16(vqmovn_u32(vld1q_u32(row0 + x)), vqmovn_u32(vld1q_u32(row0 + x + 4))); + uint16x8_t v_r1 = vcombine_u16(vqmovn_u32(vld1q_u32(row1 + x)), vqmovn_u32(vld1q_u32(row1 + x + 4))); + uint16x8_t v_r2 = vcombine_u16(vqmovn_u32(vld1q_u32(row2 + x)), vqmovn_u32(vld1q_u32(row2 + x + 4))); + + uint16x8_t v_2r1 = vaddq_u16(v_r1, v_r1), v_4r1 = vaddq_u16(v_2r1, v_2r1); + uint16x8_t v_dst00 = vaddq_u16(vaddq_u16(v_r0, v_r2), vaddq_u16(v_2r1, v_4r1)); + uint16x8_t v_dst10 = vshlq_n_u16(vaddq_u16(v_r1, v_r2), 2); + + v_r0 = vcombine_u16(vqmovn_u32(vld1q_u32(row0 + x + 8)), vqmovn_u32(vld1q_u32(row0 + x + 12))); + v_r1 = vcombine_u16(vqmovn_u32(vld1q_u32(row1 + x + 8)), vqmovn_u32(vld1q_u32(row1 + x + 12))); + v_r2 = vcombine_u16(vqmovn_u32(vld1q_u32(row2 + x + 8)), vqmovn_u32(vld1q_u32(row2 + x + 12))); + + v_2r1 = vaddq_u16(v_r1, v_r1), v_4r1 = vaddq_u16(v_2r1, v_2r1); + uint16x8_t v_dst01 = vaddq_u16(vaddq_u16(v_r0, v_r2), vaddq_u16(v_2r1, v_4r1)); + uint16x8_t v_dst11 = vshlq_n_u16(vaddq_u16(v_r1, v_r2), 2); + + vst1q_u8(dst0 + x, vcombine_u8(vqmovn_u16(vshrq_n_u16(vaddq_u16(v_dst00, v_delta), 6)), + vqmovn_u16(vshrq_n_u16(vaddq_u16(v_dst01, v_delta), 6)))); + vst1q_u8(dst1 + x, vcombine_u8(vqmovn_u16(vshrq_n_u16(vaddq_u16(v_dst10, v_delta), 6)), + vqmovn_u16(vshrq_n_u16(vaddq_u16(v_dst11, v_delta), 6)))); + } + + for( ; x <= width - 8; x += 8 ) + { + uint16x8_t v_r0 = vcombine_u16(vqmovn_u32(vld1q_u32(row0 + x)), vqmovn_u32(vld1q_u32(row0 + x + 4))); + uint16x8_t v_r1 = vcombine_u16(vqmovn_u32(vld1q_u32(row1 + x)), vqmovn_u32(vld1q_u32(row1 + x + 4))); + uint16x8_t v_r2 = vcombine_u16(vqmovn_u32(vld1q_u32(row2 + x)), vqmovn_u32(vld1q_u32(row2 + x + 4))); + + uint16x8_t v_2r1 = vaddq_u16(v_r1, v_r1), v_4r1 = vaddq_u16(v_2r1, v_2r1); + uint16x8_t v_dst0 = vaddq_u16(vaddq_u16(v_r0, v_r2), vaddq_u16(v_2r1, v_4r1)); + uint16x8_t v_dst1 = vshlq_n_u16(vaddq_u16(v_r1, v_r2), 2); + + vst1_u8(dst0 + x, vqmovn_u16(vshrq_n_u16(vaddq_u16(v_dst0, v_delta), 6))); + vst1_u8(dst1 + x, vqmovn_u16(vshrq_n_u16(vaddq_u16(v_dst1, v_delta), 6))); + } + + return x; + } +}; + +struct PyrUpVec_32s16u +{ + int operator()(int** src, ushort** dst, int, int width) const + { + int x = 0; + ushort *dst0 = dst[0], *dst1 = dst[1]; + const uint *row0 = (uint *)src[0], *row1 = (uint *)src[1], *row2 = (uint *)src[2]; + uint32x4_t v_delta = vdupq_n_u32(32); + + for( ; x <= width - 8; x += 8 ) + { + uint32x4_t v_r0 = vld1q_u32(row0 + x), v_r1 = vld1q_u32(row1 + x), v_r2 = vld1q_u32(row2 + x); + uint32x4_t v_2r1 = vshlq_n_u32(v_r1, 1), v_4r1 = vshlq_n_u32(v_r1, 2); + uint32x4_t v_dst00 = vaddq_u32(vaddq_u32(v_r0, v_r2), vaddq_u32(v_2r1, v_4r1)); + uint32x4_t v_dst10 = vshlq_n_u32(vaddq_u32(v_r1, v_r2), 2); + + v_r0 = vld1q_u32(row0 + x + 4); + v_r1 = vld1q_u32(row1 + x + 4); + v_r2 = vld1q_u32(row2 + x + 4); + v_2r1 = vshlq_n_u32(v_r1, 1); + v_4r1 = vshlq_n_u32(v_r1, 2); + uint32x4_t v_dst01 = vaddq_u32(vaddq_u32(v_r0, v_r2), vaddq_u32(v_2r1, v_4r1)); + uint32x4_t v_dst11 = vshlq_n_u32(vaddq_u32(v_r1, v_r2), 2); + + vst1q_u16(dst0 + x, vcombine_u16(vmovn_u32(vshrq_n_u32(vaddq_u32(v_dst00, v_delta), 6)), + vmovn_u32(vshrq_n_u32(vaddq_u32(v_dst01, v_delta), 6)))); + vst1q_u16(dst1 + x, vcombine_u16(vmovn_u32(vshrq_n_u32(vaddq_u32(v_dst10, v_delta), 6)), + vmovn_u32(vshrq_n_u32(vaddq_u32(v_dst11, v_delta), 6)))); + } + + for( ; x <= width - 4; x += 4 ) + { + uint32x4_t v_r0 = vld1q_u32(row0 + x), v_r1 = vld1q_u32(row1 + x), v_r2 = vld1q_u32(row2 + x); + uint32x4_t v_2r1 = vshlq_n_u32(v_r1, 1), v_4r1 = vshlq_n_u32(v_r1, 2); + + uint32x4_t v_dst0 = vaddq_u32(vaddq_u32(v_r0, v_r2), vaddq_u32(v_2r1, v_4r1)); + uint32x4_t v_dst1 = vshlq_n_u32(vaddq_u32(v_r1, v_r2), 2); + + vst1_u16(dst0 + x, vmovn_u32(vshrq_n_u32(vaddq_u32(v_dst0, v_delta), 6))); + vst1_u16(dst1 + x, vmovn_u32(vshrq_n_u32(vaddq_u32(v_dst1, v_delta), 6))); + } + + return x; + } +}; + +struct PyrUpVec_32s16s +{ + int operator()(int** src, short** dst, int, int width) const + { + int x = 0; + short *dst0 = dst[0], *dst1 = dst[1]; + const int *row0 = src[0], *row1 = src[1], *row2 = src[2]; + int32x4_t v_delta = vdupq_n_s32(32); + + for( ; x <= width - 8; x += 8 ) + { + int32x4_t v_r0 = vld1q_s32(row0 + x), v_r1 = vld1q_s32(row1 + x), v_r2 = vld1q_s32(row2 + x); + int32x4_t v_2r1 = vshlq_n_s32(v_r1, 1), v_4r1 = vshlq_n_s32(v_r1, 2); + int32x4_t v_dst00 = vaddq_s32(vaddq_s32(v_r0, v_r2), vaddq_s32(v_2r1, v_4r1)); + int32x4_t v_dst10 = vshlq_n_s32(vaddq_s32(v_r1, v_r2), 2); + + v_r0 = vld1q_s32(row0 + x + 4); + v_r1 = vld1q_s32(row1 + x + 4); + v_r2 = vld1q_s32(row2 + x + 4); + v_2r1 = vshlq_n_s32(v_r1, 1); + v_4r1 = vshlq_n_s32(v_r1, 2); + int32x4_t v_dst01 = vaddq_s32(vaddq_s32(v_r0, v_r2), vaddq_s32(v_2r1, v_4r1)); + int32x4_t v_dst11 = vshlq_n_s32(vaddq_s32(v_r1, v_r2), 2); + + vst1q_s16(dst0 + x, vcombine_s16(vqmovn_s32(vshrq_n_s32(vaddq_s32(v_dst00, v_delta), 6)), + vqmovn_s32(vshrq_n_s32(vaddq_s32(v_dst01, v_delta), 6)))); + vst1q_s16(dst1 + x, vcombine_s16(vqmovn_s32(vshrq_n_s32(vaddq_s32(v_dst10, v_delta), 6)), + vqmovn_s32(vshrq_n_s32(vaddq_s32(v_dst11, v_delta), 6)))); + } + + for( ; x <= width - 4; x += 4 ) + { + int32x4_t v_r0 = vld1q_s32(row0 + x), v_r1 = vld1q_s32(row1 + x), v_r2 = vld1q_s32(row2 + x); + int32x4_t v_2r1 = vshlq_n_s32(v_r1, 1), v_4r1 = vshlq_n_s32(v_r1, 2); + + int32x4_t v_dst0 = vaddq_s32(vaddq_s32(v_r0, v_r2), vaddq_s32(v_2r1, v_4r1)); + int32x4_t v_dst1 = vshlq_n_s32(vaddq_s32(v_r1, v_r2), 2); + + vst1_s16(dst0 + x, vqmovn_s32(vshrq_n_s32(vaddq_s32(v_dst0, v_delta), 6))); + vst1_s16(dst1 + x, vqmovn_s32(vshrq_n_s32(vaddq_s32(v_dst1, v_delta), 6))); + } + + return x; + } +}; + struct PyrUpVec_32f { - int operator()(float** src, float* dst, int, int width) const + int operator()(float** src, float** dst, int, int width) const { int x = 0; - float ** dsts = (float **)dst; const float *row0 = src[0], *row1 = src[1], *row2 = src[2]; - float *dst0 = dsts[0], *dst1 = dsts[1]; + float *dst0 = dst[0], *dst1 = dst[1]; float32x4_t v_6 = vdupq_n_f32(6.0f), v_scale = vdupq_n_f32(1.f/64.0f), v_scale4 = vmulq_n_f32(v_scale, 4.0f); for( ; x <= width - 8; x += 8 ) @@ -362,12 +510,15 @@ struct PyrUpVec_32f #else -typedef NoVec PyrDownVec_32s8u; -typedef NoVec PyrDownVec_32s16u; -typedef NoVec PyrDownVec_32s16s; -typedef NoVec PyrDownVec_32f; +typedef PyrDownNoVec PyrDownVec_32s8u; +typedef PyrDownNoVec PyrDownVec_32s16u; +typedef PyrDownNoVec PyrDownVec_32s16s; +typedef PyrDownNoVec PyrDownVec_32f; -typedef NoVec PyrUpVec_32f; +typedef PyrUpNoVec PyrUpVec_32s8u; +typedef PyrUpNoVec PyrUpVec_32s16s; +typedef PyrUpNoVec PyrUpVec_32s16u; +typedef PyrUpNoVec PyrUpVec_32f; #endif @@ -574,7 +725,7 @@ pyrUp_( const Mat& _src, Mat& _dst, int) row0 = rows[0]; row1 = rows[1]; row2 = rows[2]; dsts[0] = dst0; dsts[1] = dst1; - x = vecOp(rows, (T*)dsts, (int)_dst.step, dsize.width); + x = vecOp(rows, dsts, (int)_dst.step, dsize.width); for( ; x < dsize.width; x++ ) { T t1 = castOp((row1[x] + row2[x])*4); @@ -761,7 +912,7 @@ void cv::pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borde else if( depth == CV_32F ) func = pyrDown_, PyrDownVec_32f>; else if( depth == CV_64F ) - func = pyrDown_, NoVec >; + func = pyrDown_, PyrDownNoVec >; else CV_Error( CV_StsUnsupportedFormat, "" ); @@ -830,15 +981,15 @@ void cv::pyrUp( InputArray _src, OutputArray _dst, const Size& _dsz, int borderT PyrFunc func = 0; if( depth == CV_8U ) - func = pyrUp_, NoVec >; + func = pyrUp_, PyrUpVec_32s8u >; else if( depth == CV_16S ) - func = pyrUp_, NoVec >; + func = pyrUp_, PyrUpVec_32s16s >; else if( depth == CV_16U ) - func = pyrUp_, NoVec >; + func = pyrUp_, PyrUpVec_32s16u >; else if( depth == CV_32F ) func = pyrUp_, PyrUpVec_32f >; else if( depth == CV_64F ) - func = pyrUp_, NoVec >; + func = pyrUp_, PyrUpNoVec >; else CV_Error( CV_StsUnsupportedFormat, "" ); diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index be2789b22d..5ab70d9a26 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -1223,15 +1223,17 @@ void cv::boxFilter( InputArray _src, OutputArray _dst, int ddepth, else if (stype == CV_8UC4) IPP_FILTER_BOX_BORDER(Ipp8u, ipp8u, 8u_C4R); - else if (stype == CV_16UC1) - IPP_FILTER_BOX_BORDER(Ipp16u, ipp16u, 16u_C1R); + // Oct 2014: performance with BORDER_CONSTANT + //else if (stype == CV_16UC1) + // IPP_FILTER_BOX_BORDER(Ipp16u, ipp16u, 16u_C1R); else if (stype == CV_16UC3) IPP_FILTER_BOX_BORDER(Ipp16u, ipp16u, 16u_C3R); else if (stype == CV_16UC4) IPP_FILTER_BOX_BORDER(Ipp16u, ipp16u, 16u_C4R); - else if (stype == CV_16SC1) - IPP_FILTER_BOX_BORDER(Ipp16s, ipp16s, 16s_C1R); + // Oct 2014: performance with BORDER_CONSTANT + //else if (stype == CV_16SC1) + // IPP_FILTER_BOX_BORDER(Ipp16s, ipp16s, 16s_C1R); else if (stype == CV_16SC3) IPP_FILTER_BOX_BORDER(Ipp16s, ipp16s, 16s_C3R); else if (stype == CV_16SC4) diff --git a/modules/imgproc/src/thresh.cpp b/modules/imgproc/src/thresh.cpp index 6e0639cbb3..03105dd042 100644 --- a/modules/imgproc/src/thresh.cpp +++ b/modules/imgproc/src/thresh.cpp @@ -986,6 +986,110 @@ getThreshVal_Otsu_8u( const Mat& _src ) return max_val; } +static double +getThreshVal_Triangle_8u( const Mat& _src ) +{ + Size size = _src.size(); + int step = (int) _src.step; + if( _src.isContinuous() ) + { + size.width *= size.height; + size.height = 1; + step = size.width; + } + + const int N = 256; + int i, j, h[N] = {0}; + for( i = 0; i < size.height; i++ ) + { + const uchar* src = _src.ptr() + step*i; + j = 0; + #if CV_ENABLE_UNROLLED + for( ; j <= size.width - 4; j += 4 ) + { + int v0 = src[j], v1 = src[j+1]; + h[v0]++; h[v1]++; + v0 = src[j+2]; v1 = src[j+3]; + h[v0]++; h[v1]++; + } + #endif + for( ; j < size.width; j++ ) + h[src[j]]++; + } + + int left_bound = 0, right_bound = 0, max_ind = 0, max = 0; + int temp; + bool isflipped = false; + + for( i = 0; i < N; i++ ) + { + if( h[i] > 0 ) + { + left_bound = i; + break; + } + } + if( left_bound > 0 ) + left_bound--; + + for( i = N-1; i > 0; i-- ) + { + if( h[i] > 0 ) + { + right_bound = i; + break; + } + } + if( right_bound < N-1 ) + right_bound++; + + for( i = 0; i < N; i++ ) + { + if( h[i] > max) + { + max = h[i]; + max_ind = i; + } + } + + if( max_ind-left_bound < right_bound-max_ind) + { + isflipped = true; + i = 0, j = N-1; + while( i < j ) + { + temp = h[i]; h[i] = h[j]; h[j] = temp; + i++; j--; + } + left_bound = N-1-right_bound; + max_ind = N-1-max_ind; + } + + double thresh = left_bound; + double a, b, dist = 0, tempdist; + + /* + * We do not need to compute precise distance here. Distance is maximized, so some constants can + * be omitted. This speeds up a computation a bit. + */ + a = max; b = left_bound-max_ind; + for( i = left_bound+1; i <= max_ind; i++ ) + { + tempdist = a*i + b*h[i]; + if( tempdist > dist) + { + dist = tempdist; + thresh = i; + } + } + thresh--; + + if( isflipped ) + thresh = N-1-thresh; + + return thresh; +} + class ThresholdRunner : public ParallelLoopBody { public: @@ -1085,13 +1189,19 @@ double cv::threshold( InputArray _src, OutputArray _dst, double thresh, double m ocl_threshold(_src, _dst, thresh, maxval, type), thresh) Mat src = _src.getMat(); - bool use_otsu = (type & THRESH_OTSU) != 0; + int automatic_thresh = (type & ~CV_THRESH_MASK); type &= THRESH_MASK; - if( use_otsu ) + CV_Assert( automatic_thresh != (CV_THRESH_OTSU | CV_THRESH_TRIANGLE) ); + if( automatic_thresh == CV_THRESH_OTSU ) + { + CV_Assert( src.type() == CV_8UC1 ); + thresh = getThreshVal_Otsu_8u( src ); + } + else if( automatic_thresh == CV_THRESH_TRIANGLE ) { CV_Assert( src.type() == CV_8UC1 ); - thresh = getThreshVal_Otsu_8u(src); + thresh = getThreshVal_Triangle_8u( src ); } _dst.create( src.size(), src.type() ); diff --git a/modules/imgproc/test/ocl/test_warp.cpp b/modules/imgproc/test/ocl/test_warp.cpp index 9caefff2b0..ccbdf25f53 100644 --- a/modules/imgproc/test/ocl/test_warp.cpp +++ b/modules/imgproc/test/ocl/test_warp.cpp @@ -121,7 +121,7 @@ OCL_TEST_P(WarpAffine, Mat) { for (int j = 0; j < test_loop_times; j++) { - double eps = depth < CV_32F ? 0.03 : 0.06; + double eps = depth < CV_32F ? 0.04 : 0.06; random_roi(); Mat M = getRotationMatrix2D(Point2f(src_roi.cols / 2.0f, src_roi.rows / 2.0f), diff --git a/modules/imgproc/test/test_histograms.cpp b/modules/imgproc/test/test_histograms.cpp index e9db6fcde0..095b2c1fd9 100644 --- a/modules/imgproc/test/test_histograms.cpp +++ b/modules/imgproc/test/test_histograms.cpp @@ -1100,7 +1100,7 @@ int CV_CompareHistTest::validate_test_results( int /*test_case_idx*/ ) code = cvtest::TS::FAIL_INVALID_OUTPUT; break; } - else if( fabs(v0 - v) > FLT_EPSILON*10*MAX(fabs(v0),0.1) ) + else if( fabs(v0 - v) > FLT_EPSILON*14*MAX(fabs(v0),0.1) ) { ts->printf( cvtest::TS::LOG, "The comparison result using the method #%d (%s)\n\tis inaccurate (=%g, should be =%g)\n", i, method_name, v, v0 ); diff --git a/modules/imgproc/test/test_imgwarp.cpp b/modules/imgproc/test/test_imgwarp.cpp index eb13d35402..34505c4ca4 100644 --- a/modules/imgproc/test/test_imgwarp.cpp +++ b/modules/imgproc/test/test_imgwarp.cpp @@ -1548,9 +1548,28 @@ TEST(Imgproc_GetQuadSubPix, accuracy) { CV_GetQuadSubPixTest test; test.safe_run ////////////////////////////////////////////////////////////////////////// template +struct IntCast +{ + T operator() (WT val) const + { + return cv::saturate_cast(val >> 2); + } +}; + +template +struct FltCast +{ + T operator() (WT val) const + { + return cv::saturate_cast(val * 0.25); + } +}; + +template void resizeArea(const cv::Mat & src, cv::Mat & dst) { int cn = src.channels(); + CastOp castOp; for (int y = 0; y < dst.rows; ++y) { @@ -1565,9 +1584,9 @@ void resizeArea(const cv::Mat & src, cv::Mat & dst) for (int c = 0; c < cn; ++c) { WT sum = WT(sptr0[x1 + c]) + WT(sptr0[x1 + c + cn]); - sum += WT(sptr1[x1 + c]) + WT(sptr1[x1 + c + cn]) + (WT)(2); + sum += WT(sptr1[x1 + c]) + WT(sptr1[x1 + c + cn]) + (WT)(one); - dptr[x + c] = cv::saturate_cast(sum >> 2); + dptr[x + c] = castOp(sum); } } } @@ -1575,32 +1594,38 @@ void resizeArea(const cv::Mat & src, cv::Mat & dst) TEST(Resize, Area_half) { - const int size = 10; - int types[] = { CV_8UC1, CV_8UC4, CV_16UC1, CV_16UC4 }; + const int size = 1000; + int types[] = { CV_8UC1, CV_8UC4, CV_16UC1, CV_16UC4, CV_16SC1, CV_16SC4, CV_32FC1, CV_32FC4 }; cv::RNG rng(17); for (int i = 0, _size = sizeof(types) / sizeof(types[0]); i < _size; ++i) { - int type = types[i], depth = CV_MAT_DEPTH(type); + int type = types[i], depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type); + const float eps = depth <= CV_32S ? 0 : 7e-5f; SCOPED_TRACE(depth); + SCOPED_TRACE(cn); cv::Mat src(size, size, type), dst_actual(size >> 1, size >> 1, type), dst_reference(size >> 1, size >> 1, type); - rng.fill(src, cv::RNG::UNIFORM, 0, 1000, true); + rng.fill(src, cv::RNG::UNIFORM, -1000, 1000, true); if (depth == CV_8U) - resizeArea(src, dst_reference); + resizeArea >(src, dst_reference); else if (depth == CV_16U) - resizeArea(src, dst_reference); + resizeArea >(src, dst_reference); + else if (depth == CV_16S) + resizeArea >(src, dst_reference); + else if (depth == CV_32F) + resizeArea >(src, dst_reference); else CV_Assert(0); cv::resize(src, dst_actual, dst_actual.size(), 0, 0, cv::INTER_AREA); - ASSERT_EQ(0, cvtest::norm(dst_reference, dst_actual, cv::NORM_INF)); + ASSERT_GE(eps, cvtest::norm(dst_reference, dst_actual, cv::NORM_INF)); } } diff --git a/modules/ml/src/ann_mlp.cpp b/modules/ml/src/ann_mlp.cpp index ad40c8a29c..3e7d44e87c 100644 --- a/modules/ml/src/ann_mlp.cpp +++ b/modules/ml/src/ann_mlp.cpp @@ -618,7 +618,7 @@ public: scale[j*2] = mj; scale[j*2+1] = Mj; } - else + else if( !no_scale ) { t = t*inv_scale[j*2] + inv_scale[2*j+1]; if( t < m1 || t > M1 ) diff --git a/modules/photo/include/opencv2/photo.hpp b/modules/photo/include/opencv2/photo.hpp index df0ccbeb34..ee6b12e9dc 100644 --- a/modules/photo/include/opencv2/photo.hpp +++ b/modules/photo/include/opencv2/photo.hpp @@ -315,7 +315,7 @@ CV_EXPORTS_W void illuminationChange(InputArray src, InputArray mask, OutputArra float alpha = 0.2f, float beta = 0.4f); CV_EXPORTS_W void textureFlattening(InputArray src, InputArray mask, OutputArray dst, - double low_threshold = 30, double high_threshold = 45, + float low_threshold = 30, float high_threshold = 45, int kernel_size = 3); CV_EXPORTS_W void edgePreservingFilter(InputArray src, OutputArray dst, int flags = 1, diff --git a/modules/photo/src/fast_nlmeans_denoising_opencl.hpp b/modules/photo/src/fast_nlmeans_denoising_opencl.hpp index ae173905d8..1cdd8fa494 100644 --- a/modules/photo/src/fast_nlmeans_denoising_opencl.hpp +++ b/modules/photo/src/fast_nlmeans_denoising_opencl.hpp @@ -19,7 +19,8 @@ enum { BLOCK_ROWS = 32, BLOCK_COLS = 32, - CTA_SIZE = 256 + CTA_SIZE_INTEL = 64, + CTA_SIZE_DEFAULT = 256 }; static int divUp(int a, int b) @@ -70,6 +71,7 @@ static bool ocl_fastNlMeansDenoising(InputArray _src, OutputArray _dst, float h, int templateWindowSize, int searchWindowSize) { int type = _src.type(), cn = CV_MAT_CN(type); + int ctaSize = ocl::Device::getDefault().isIntel() ? CTA_SIZE_INTEL : CTA_SIZE_DEFAULT; Size size = _src.size(); if ( type != CV_8UC1 && type != CV_8UC2 && type != CV_8UC4 ) @@ -86,12 +88,12 @@ static bool ocl_fastNlMeansDenoising(InputArray _src, OutputArray _dst, float h, String opts = format("-D OP_CALC_FASTNLMEANS -D TEMPLATE_SIZE=%d -D SEARCH_SIZE=%d" " -D uchar_t=%s -D int_t=%s -D BLOCK_COLS=%d -D BLOCK_ROWS=%d" " -D CTA_SIZE=%d -D TEMPLATE_SIZE2=%d -D SEARCH_SIZE2=%d" - " -D convert_int_t=%s -D cn=%d -D CTA_SIZE2=%d -D convert_uchar_t=%s", + " -D convert_int_t=%s -D cn=%d -D convert_uchar_t=%s", templateWindowSize, searchWindowSize, ocl::typeToStr(type), - ocl::typeToStr(CV_32SC(cn)), BLOCK_COLS, BLOCK_ROWS, CTA_SIZE, + ocl::typeToStr(CV_32SC(cn)), BLOCK_COLS, BLOCK_ROWS, ctaSize, templateWindowHalfWize, searchWindowHalfSize, ocl::convertTypeStr(CV_8U, CV_32S, cn, cvt[0]), cn, - CTA_SIZE >> 1, ocl::convertTypeStr(CV_32S, CV_8U, cn, cvt[1])); + ocl::convertTypeStr(CV_32S, CV_8U, cn, cvt[1])); ocl::Kernel k("fastNlMeansDenoising", ocl::photo::nlmeans_oclsrc, opts); if (k.empty()) @@ -120,7 +122,7 @@ static bool ocl_fastNlMeansDenoising(InputArray _src, OutputArray _dst, float h, ocl::KernelArg::PtrReadOnly(almostDist2Weight), ocl::KernelArg::PtrReadOnly(buffer), almostTemplateWindowSizeSqBinShift); - size_t globalsize[2] = { nblocksx * CTA_SIZE, nblocksy }, localsize[2] = { CTA_SIZE, 1 }; + size_t globalsize[2] = { nblocksx * ctaSize, nblocksy }, localsize[2] = { ctaSize, 1 }; return k.run(2, globalsize, localsize, false); } diff --git a/modules/photo/src/opencl/nlmeans.cl b/modules/photo/src/opencl/nlmeans.cl index 67a6ec61f8..152f4ddcfd 100644 --- a/modules/photo/src/opencl/nlmeans.cl +++ b/modules/photo/src/opencl/nlmeans.cl @@ -206,22 +206,11 @@ inline void convolveWindow(__global const uchar * src, int src_step, int src_off weighted_sum += (int_t)(weight) * src_value; } - if (id >= CTA_SIZE2) - { - int id2 = id - CTA_SIZE2; - weights_local[id2] = weights; - weighted_sum_local[id2] = weighted_sum; - } - barrier(CLK_LOCAL_MEM_FENCE); - - if (id < CTA_SIZE2) - { - weights_local[id] += weights; - weighted_sum_local[id] += weighted_sum; - } + weights_local[id] = weights; + weighted_sum_local[id] = weighted_sum; barrier(CLK_LOCAL_MEM_FENCE); - for (int lsize = CTA_SIZE2 >> 1; lsize > 2; lsize >>= 1) + for (int lsize = CTA_SIZE >> 1; lsize > 2; lsize >>= 1) { if (id < lsize) { @@ -252,8 +241,8 @@ __kernel void fastNlMeansDenoising(__global const uchar * src, int src_step, int int block_y = get_group_id(1); int id = get_local_id(0), first; - __local int dists[SEARCH_SIZE_SQ], weights[CTA_SIZE2]; - __local int_t weighted_sum[CTA_SIZE2]; + __local int dists[SEARCH_SIZE_SQ], weights[CTA_SIZE]; + __local int_t weighted_sum[CTA_SIZE]; int x0 = block_x * BLOCK_COLS, x1 = min(x0 + BLOCK_COLS, dst_cols); int y0 = block_y * BLOCK_ROWS, y1 = min(y0 + BLOCK_ROWS, dst_rows); @@ -281,7 +270,6 @@ __kernel void fastNlMeansDenoising(__global const uchar * src, int src_step, int first = (first + 1) % TEMPLATE_SIZE; } - barrier(CLK_LOCAL_MEM_FENCE); convolveWindow(src, src_step, src_offset, dists, almostDist2Weight, dst, dst_step, dst_offset, y, x, id, weights, weighted_sum, almostTemplateWindowSizeSqBinShift); diff --git a/modules/photo/src/seamless_cloning.cpp b/modules/photo/src/seamless_cloning.cpp index 445c6dae74..2564145e58 100644 --- a/modules/photo/src/seamless_cloning.cpp +++ b/modules/photo/src/seamless_cloning.cpp @@ -41,7 +41,6 @@ #include "precomp.hpp" #include "opencv2/photo.hpp" -#include #include "seamless_cloning.hpp" @@ -50,9 +49,9 @@ using namespace cv; void cv::seamlessClone(InputArray _src, InputArray _dst, InputArray _mask, Point p, OutputArray _blend, int flags) { - Mat src = _src.getMat(); - Mat dest = _dst.getMat(); - Mat mask = _mask.getMat(); + const Mat src = _src.getMat(); + const Mat dest = _dst.getMat(); + const Mat mask = _mask.getMat(); _blend.create(dest.size(), CV_8UC3); Mat blend = _blend.getMat(); @@ -87,6 +86,8 @@ void cv::seamlessClone(InputArray _src, InputArray _dst, InputArray _mask, Point int lenx = maxx - minx; int leny = maxy - miny; + Mat patch = Mat::zeros(Size(leny, lenx), CV_8UC3); + int minxd = p.y - lenx/2; int maxxd = p.y + lenx/2; int minyd = p.x - leny/2; @@ -102,12 +103,14 @@ void cv::seamlessClone(InputArray _src, InputArray _dst, InputArray _mask, Point gray(roi_s).copyTo(destinationROI); src(roi_s).copyTo(sourceROI,gray(roi_s)); + src(roi_s).copyTo(patch, gray(roi_s)); destinationROI = cd_mask(roi_d); cs_mask(roi_s).copyTo(destinationROI); + Cloning obj; - obj.normal_clone(dest,cd_mask,dst_mask,blend,flags); + obj.normalClone(dest,cd_mask,dst_mask,blend,flags); } @@ -134,7 +137,7 @@ void cv::colorChange(InputArray _src, InputArray _mask, OutputArray _dst, float src.copyTo(cs_mask,gray); Cloning obj; - obj.local_color_change(src,cs_mask,gray,blend,red,green,blue); + obj.localColorChange(src,cs_mask,gray,blend,red,green,blue); } void cv::illuminationChange(InputArray _src, InputArray _mask, OutputArray _dst, float a, float b) @@ -159,12 +162,12 @@ void cv::illuminationChange(InputArray _src, InputArray _mask, OutputArray _dst, src.copyTo(cs_mask,gray); Cloning obj; - obj.illum_change(src,cs_mask,gray,blend,alpha,beta); + obj.illuminationChange(src,cs_mask,gray,blend,alpha,beta); } void cv::textureFlattening(InputArray _src, InputArray _mask, OutputArray _dst, - double low_threshold, double high_threshold, int kernel_size) + float low_threshold, float high_threshold, int kernel_size) { Mat src = _src.getMat(); @@ -184,5 +187,5 @@ void cv::textureFlattening(InputArray _src, InputArray _mask, OutputArray _dst, src.copyTo(cs_mask,gray); Cloning obj; - obj.texture_flatten(src,cs_mask,gray,low_threshold,high_threshold,kernel_size,blend); + obj.textureFlatten(src,cs_mask,gray,low_threshold,high_threshold,kernel_size,blend); } diff --git a/modules/photo/src/seamless_cloning.hpp b/modules/photo/src/seamless_cloning.hpp index f0713ceb2e..a0f9d6863c 100644 --- a/modules/photo/src/seamless_cloning.hpp +++ b/modules/photo/src/seamless_cloning.hpp @@ -39,546 +39,52 @@ // //M*/ +#ifndef CV_SEAMLESS_CLONING_HPP___ +#define CV_SEAMLESS_CLONING_HPP___ + #include "precomp.hpp" #include "opencv2/photo.hpp" -#include -#include -#include -#include "math.h" - -using namespace std; -using namespace cv; - -class Cloning -{ - - public: - - vector rgb_channel, rgbx_channel, rgby_channel, output; - Mat grx, gry, sgx, sgy, srx32, sry32, grx32, gry32, smask, smask1; - void init_var(Mat &I, Mat &wmask); - void initialization(Mat &I, Mat &mask, Mat &wmask); - void scalar_product(Mat mat, float r, float g, float b); - void array_product(Mat mat1, Mat mat2, Mat mat3); - void poisson(Mat &I, Mat &gx, Mat &gy, Mat &sx, Mat &sy); - void evaluate(Mat &I, Mat &wmask, Mat &cloned); - void getGradientx(const Mat &img, Mat &gx); - void getGradienty(const Mat &img, Mat &gy); - void lapx(const Mat &img, Mat &gxx); - void lapy(const Mat &img, Mat &gyy); - void dst(double *mod_diff, double *sineTransform,int h,int w); - void idst(double *mod_diff, double *sineTransform,int h,int w); - void transpose(double *mat, double *mat_t,int h,int w); - void solve(const Mat &img, double *mod_diff, Mat &result); - void poisson_solver(const Mat &img, Mat &gxx , Mat &gyy, Mat &result); - void normal_clone(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, int num); - void local_color_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float red_mul, float green_mul, float blue_mul); - void illum_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float alpha, float beta); - void texture_flatten(Mat &I, Mat &mask, Mat &wmask, double low_threshold, double high_threhold, int kernel_size, Mat &cloned); -}; - -void Cloning::getGradientx( const Mat &img, Mat &gx) -{ - Mat kernel = Mat::zeros(1, 3, CV_8S); - kernel.at(0,2) = 1; - kernel.at(0,1) = -1; - filter2D(img, gx, CV_32F, kernel); -} - -void Cloning::getGradienty( const Mat &img, Mat &gy) -{ - Mat kernel = Mat::zeros(3, 1, CV_8S); - kernel.at(2,0) = 1; - kernel.at(1,0) = -1; - filter2D(img, gy, CV_32F, kernel); -} - -void Cloning::lapx( const Mat &img, Mat &gxx) -{ - Mat kernel = Mat::zeros(1, 3, CV_8S); - kernel.at(0,0) = -1; - kernel.at(0,1) = 1; - filter2D(img, gxx, CV_32F, kernel); -} - -void Cloning::lapy( const Mat &img, Mat &gyy) -{ - Mat kernel = Mat::zeros(3, 1, CV_8S); - kernel.at(0,0) = -1; - kernel.at(1,0) = 1; - filter2D(img, gyy, CV_32F, kernel); -} - -void Cloning::dst(double *mod_diff, double *sineTransform,int h,int w) -{ - - unsigned long int idx; - - Mat temp = Mat(2*h+2,1,CV_32F); - Mat res = Mat(h,1,CV_32F); - - Mat planes[] = {Mat_(temp), Mat::zeros(temp.size(), CV_32F)}; - - Mat result; - int p=0; - for(int i=0;i(0,0) = 0.0; - - for(int j=0,r=1;j(r,0) = (float) mod_diff[idx]; - } - - temp.at(h+1,0)=0.0; - - for(int j=h-1, r=h+2;j>=0;j--,r++) - { - idx = j*w+i; - temp.at(r,0) = (float) (-1.0 * mod_diff[idx]); - } - - merge(planes, 2, result); - - dft(result,result,0,0); - - Mat planes1[] = {Mat::zeros(result.size(), CV_32F), Mat::zeros(result.size(), CV_32F)}; - - split(result, planes1); - - std::complex two_i = std::sqrt(std::complex(-1)); - - double factor = -2*imag(two_i); - - for(int c=1,z=0;c(z,0) = (float) (planes1[1].at(c,0)/factor); - } - - for(int q=0,z=0;q(z,0); - } - p++; - } -} - -void Cloning::idst(double *mod_diff, double *sineTransform,int h,int w) -{ - int nn = h+1; - unsigned long int idx; - dst(mod_diff,sineTransform,h,w); - for(int i= 0;i(i,j) = (float) mat[idx]; - } - } - Mat tmp_t = tmp.t(); - - for(int i = 0;i < tmp_t.size().height; i++) - for(int j=0;j(i,j); - } -} +#include -void Cloning::solve(const Mat &img, double *mod_diff, Mat &result) +namespace cv { - int w = img.size().width; - int h = img.size().height; - - unsigned long int idx,idx1; - - double *sineTransform = new double[(h-2)*(w-2)]; - double *sineTransform_t = new double[(h-2)*(w-2)]; - double *denom = new double[(h-2)*(w-2)]; - double *invsineTransform = new double[(h-2)*(w-2)]; - double *invsineTransform_t = new double[(h-2)*(w-2)]; - double *img_d = new double[(h)*(w)]; - - dst(mod_diff,sineTransform,h-2,w-2); - - transpose(sineTransform,sineTransform_t,h-2,w-2); - - dst(sineTransform_t,sineTransform,w-2,h-2); - transpose(sineTransform,sineTransform_t,w-2,h-2); - - int cy = 1; - - for(int i = 0 ; i < w-2;i++,cy++) - { - for(int j = 0,cx = 1; j < h-2; j++,cx++) - { - idx = j*(w-2) + i; - denom[idx] = (float) 2*cos(CV_PI*cy/( (double) (w-1))) - 2 + 2*cos(CV_PI*cx/((double) (h-1))) - 2; - - } - } - - for(idx = 0 ; idx < (unsigned)(w-2)*(h-2) ;idx++) + class Cloning { - sineTransform_t[idx] = sineTransform_t[idx]/denom[idx]; - } - - idst(sineTransform_t,invsineTransform,h-2,w-2); - - transpose(invsineTransform,invsineTransform_t,h-2,w-2); - - idst(invsineTransform_t,invsineTransform,w-2,h-2); - - transpose(invsineTransform,invsineTransform_t,w-2,h-2); - - for(int i = 0 ; i < h;i++) - { - for(int j = 0 ; j < w; j++) - { - idx = i*w + j; - img_d[idx] = (double)img.at(i,j); - } - } - for(int i = 1 ; i < h-1;i++) - { - for(int j = 1 ; j < w-1; j++) - { - idx = i*w + j; - img_d[idx] = 0.0; - } - } - for(int i = 1,id1=0 ; i < h-1;i++,id1++) - { - for(int j = 1,id2=0 ; j < w-1; j++,id2++) - { - idx = i*w + j; - idx1= id1*(w-2) + id2; - img_d[idx] = invsineTransform_t[idx1]; - } - } - - for(int i = 0 ; i < h;i++) - { - for(int j = 0 ; j < w; j++) - { - idx = i*w + j; - if(img_d[idx] < 0.0) - result.at(i,j) = 0; - else if(img_d[idx] > 255.0) - result.at(i,j) = 255; - else - result.at(i,j) = (uchar) img_d[idx]; - } - } - - delete [] sineTransform; - delete [] sineTransform_t; - delete [] denom; - delete [] invsineTransform; - delete [] invsineTransform_t; - delete [] img_d; -} - -void Cloning::poisson_solver(const Mat &img, Mat &gxx , Mat &gyy, Mat &result) -{ - - int w = img.size().width; - int h = img.size().height; - - unsigned long int idx; - - Mat lap = Mat(img.size(),CV_32FC1); - - lap = gxx + gyy; - - Mat bound = img.clone(); - - rectangle(bound, Point(1, 1), Point(img.cols-2, img.rows-2), Scalar::all(0), -1); - - double *boundary_point = new double[h*w]; - - for(int i =1;i(i,j) + (int)bound.at(i,(j+1)) + (int)bound.at(i,(j-1)) - + (int)bound.at(i-1,j) + (int)bound.at(i+1,j); - } - - Mat diff = Mat(h,w,CV_32FC1); - for(int i =0;i(i,j) = (float) (lap.at(i,j) - boundary_point[idx]); - } - } - - double *mod_diff = new double[(h-2)*(w-2)]; - for(int i = 0 ; i < h-2;i++) - { - for(int j = 0 ; j < w-2; j++) - { - idx = i*(w-2) + j; - mod_diff[idx] = diff.at(i+1,j+1); - - } - } - ///////////////////////////////////////////////////// Find DST ///////////////////////////////////////////////////// - - solve(img,mod_diff,result); - - delete [] mod_diff; - delete [] boundary_point; -} - -void Cloning::init_var(Mat &I, Mat &wmask) -{ - grx = Mat(I.size(),CV_32FC3); - gry = Mat(I.size(),CV_32FC3); - sgx = Mat(I.size(),CV_32FC3); - sgy = Mat(I.size(),CV_32FC3); - - split(I,rgb_channel); - - smask = Mat(wmask.size(),CV_32FC1); - srx32 = Mat(I.size(),CV_32FC3); - sry32 = Mat(I.size(),CV_32FC3); - smask1 = Mat(wmask.size(),CV_32FC1); - grx32 = Mat(I.size(),CV_32FC3); - gry32 = Mat(I.size(),CV_32FC3); -} - -void Cloning::initialization(Mat &I, Mat &mask, Mat &wmask) -{ - init_var(I,wmask); - - getGradientx(I,grx); - getGradienty(I,gry); - - getGradientx(mask,sgx); - getGradienty(mask,sgy); - - Mat Kernel(Size(3, 3), CV_8UC1); - Kernel.setTo(Scalar(1)); - - erode(wmask, wmask, Kernel, Point(-1,-1), 3); - - wmask.convertTo(smask,CV_32FC1,1.0/255.0); - I.convertTo(srx32,CV_32FC3,1.0/255.0); - I.convertTo(sry32,CV_32FC3,1.0/255.0); -} - -void Cloning::scalar_product(Mat mat, float r, float g, float b) -{ - vector channels; - split(mat,channels); - multiply(channels[2],r,channels[2]); - multiply(channels[1],g,channels[1]); - multiply(channels[0],b,channels[0]); - merge(channels,mat); -} - -void Cloning::array_product(Mat mat1, Mat mat2, Mat mat3) -{ - vector channels_temp1; - vector channels_temp2; - split(mat1,channels_temp1); - split(mat2,channels_temp2); - multiply(channels_temp2[2],mat3,channels_temp1[2]); - multiply(channels_temp2[1],mat3,channels_temp1[1]); - multiply(channels_temp2[0],mat3,channels_temp1[0]); - merge(channels_temp1,mat1); -} - -void Cloning::poisson(Mat &I, Mat &gx, Mat &gy, Mat &sx, Mat &sy) -{ - Mat fx = Mat(I.size(),CV_32FC3); - Mat fy = Mat(I.size(),CV_32FC3); - - fx = gx + sx; - fy = gy + sy; - - Mat gxx = Mat(I.size(),CV_32FC3); - Mat gyy = Mat(I.size(),CV_32FC3); - - lapx(fx,gxx); - lapy(fy,gyy); - - split(gxx,rgbx_channel); - split(gyy,rgby_channel); - - split(I,output); - - poisson_solver(rgb_channel[2],rgbx_channel[2], rgby_channel[2],output[2]); - poisson_solver(rgb_channel[1],rgbx_channel[1], rgby_channel[1],output[1]); - poisson_solver(rgb_channel[0],rgbx_channel[0], rgby_channel[0],output[0]); -} - -void Cloning::evaluate(Mat &I, Mat &wmask, Mat &cloned) -{ - bitwise_not(wmask,wmask); - - wmask.convertTo(smask1,CV_32FC1,1.0/255.0); - I.convertTo(grx32,CV_32FC3,1.0/255.0); - I.convertTo(gry32,CV_32FC3,1.0/255.0); - - array_product(grx32,grx,smask1); - array_product(gry32,gry,smask1); - - poisson(I,grx32,gry32,srx32,sry32); - - merge(output,cloned); -} - -void Cloning::normal_clone(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, int num) -{ - int w = I.size().width; - int h = I.size().height; - int channel = I.channels(); - - - initialization(I,mask,wmask); - - if(num == 1) - { - array_product(srx32,sgx,smask); - array_product(sry32,sgy,smask); - - } - else if(num == 2) - { - - for(int i=0;i < h; i++) - { - for(int j=0; j < w; j++) - { - for(int c=0;c(i,j*channel+c) - sgy.at(i,j*channel+c)) > - abs(grx.at(i,j*channel+c) - gry.at(i,j*channel+c))) - { - - srx32.at(i,j*channel+c) = sgx.at(i,j*channel+c) - * smask.at(i,j); - sry32.at(i,j*channel+c) = sgy.at(i,j*channel+c) - * smask.at(i,j); - } - else - { - srx32.at(i,j*channel+c) = grx.at(i,j*channel+c) - * smask.at(i,j); - sry32.at(i,j*channel+c) = gry.at(i,j*channel+c) - * smask.at(i,j); - } - } - } - } - - } - else if(num == 3) - { - Mat gray = Mat(mask.size(),CV_8UC1); - Mat gray8 = Mat(mask.size(),CV_8UC3); - cvtColor(mask, gray, COLOR_BGR2GRAY ); - vector temp; - split(I,temp); - gray.copyTo(temp[2]); - gray.copyTo(temp[1]); - gray.copyTo(temp[0]); - - merge(temp,gray8); - - getGradientx(gray8,sgx); - getGradienty(gray8,sgy); - - array_product(srx32,sgx,smask); - array_product(sry32,sgy,smask); - - } - - evaluate(I,wmask,cloned); -} - -void Cloning::local_color_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float red_mul=1.0, - float green_mul=1.0, float blue_mul=1.0) -{ - initialization(I,mask,wmask); - - array_product(srx32,sgx,smask); - array_product(sry32,sgy,smask); - scalar_product(srx32,red_mul,green_mul,blue_mul); - scalar_product(sry32,red_mul,green_mul,blue_mul); - - evaluate(I,wmask,cloned); -} - -void Cloning::illum_change(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float alpha, float beta) -{ - initialization(I,mask,wmask); - - array_product(srx32,sgx,smask); - array_product(sry32,sgy,smask); - - Mat mag = Mat(I.size(),CV_32FC3); - magnitude(srx32,sry32,mag); - - Mat multX, multY, multx_temp, multy_temp; - - multiply(srx32,pow(alpha,beta),multX); - pow(mag,-1*beta, multx_temp); - multiply(multX,multx_temp,srx32); - patchNaNs(srx32); - - multiply(sry32,pow(alpha,beta),multY); - pow(mag,-1*beta, multy_temp); - multiply(multY,multy_temp,sry32); - patchNaNs(sry32); - - Mat zeroMask = (srx32 != 0); - - srx32.copyTo(srx32, zeroMask); - sry32.copyTo(sry32, zeroMask); - - evaluate(I,wmask,cloned); -} - -void Cloning::texture_flatten(Mat &I, Mat &mask, Mat &wmask, double low_threshold, - double high_threshold, int kernel_size, Mat &cloned) -{ - initialization(I,mask,wmask); - - Mat out = Mat(mask.size(),CV_8UC1); - Canny(mask,out,low_threshold,high_threshold,kernel_size); - - Mat zeros(sgx.size(), CV_32FC3); - zeros.setTo(0); - Mat zerosMask = (out != 255); - zeros.copyTo(sgx, zerosMask); - zeros.copyTo(sgy, zerosMask); - - array_product(srx32,sgx,smask); - array_product(sry32,sgy,smask); - - evaluate(I,wmask,cloned); -} + public: + void normalClone(const cv::Mat& destination, const cv::Mat &mask, const cv::Mat &wmask, cv::Mat &cloned, int flag); + void illuminationChange(cv::Mat &I, cv::Mat &mask, cv::Mat &wmask, cv::Mat &cloned, float alpha, float beta); + void localColorChange(cv::Mat &I, cv::Mat &mask, cv::Mat &wmask, cv::Mat &cloned, float red_mul, float green_mul, float blue_mul); + void textureFlatten(cv::Mat &I, cv::Mat &mask, cv::Mat &wmask, float low_threshold, float high_threhold, int kernel_size, cv::Mat &cloned); + + protected: + + void initVariables(const cv::Mat &destination, const cv::Mat &binaryMask); + void computeDerivatives(const cv::Mat &destination, const cv::Mat &patch, const cv::Mat &binaryMask); + void scalarProduct(cv::Mat mat, float r, float g, float b); + void poisson(const cv::Mat &destination); + void evaluate(const cv::Mat &I, const cv::Mat &wmask, const cv::Mat &cloned); + void dst(const Mat& src, Mat& dest, bool invert = false); + void idst(const Mat& src, Mat& dest); + void solve(const Mat &img, Mat& mod_diff, Mat &result); + + void poissonSolver(const cv::Mat &img, cv::Mat &gxx , cv::Mat &gyy, cv::Mat &result); + + void arrayProduct(const cv::Mat& lhs, const cv::Mat& rhs, cv::Mat& result) const; + + void computeGradientX(const cv::Mat &img, cv::Mat &gx); + void computeGradientY(const cv::Mat &img, cv::Mat &gy); + void computeLaplacianX(const cv::Mat &img, cv::Mat &gxx); + void computeLaplacianY(const cv::Mat &img, cv::Mat &gyy); + + private: + std::vector rgbx_channel, rgby_channel, output; + cv::Mat destinationGradientX, destinationGradientY; + cv::Mat patchGradientX, patchGradientY; + cv::Mat binaryMaskFloat, binaryMaskFloatInverted; + + std::vector filter_X, filter_Y; + }; +} +#endif \ No newline at end of file diff --git a/modules/photo/src/seamless_cloning_impl.cpp b/modules/photo/src/seamless_cloning_impl.cpp new file mode 100644 index 0000000000..fe2751d143 --- /dev/null +++ b/modules/photo/src/seamless_cloning_impl.cpp @@ -0,0 +1,469 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "seamless_cloning.hpp" + +using namespace cv; +using namespace std; + + +void Cloning::computeGradientX( const Mat &img, Mat &gx) +{ + Mat kernel = Mat::zeros(1, 3, CV_8S); + kernel.at(0,2) = 1; + kernel.at(0,1) = -1; + + if(img.channels() == 3) + { + filter2D(img, gx, CV_32F, kernel); + } + else if (img.channels() == 1) + { + Mat tmp[3]; + for(int chan = 0 ; chan < 3 ; ++chan) + { + filter2D(img, tmp[chan], CV_32F, kernel); + } + merge(tmp, 3, gx); + } +} + +void Cloning::computeGradientY( const Mat &img, Mat &gy) +{ + Mat kernel = Mat::zeros(3, 1, CV_8S); + kernel.at(2,0) = 1; + kernel.at(1,0) = -1; + + if(img.channels() == 3) + { + filter2D(img, gy, CV_32F, kernel); + } + else if (img.channels() == 1) + { + Mat tmp[3]; + for(int chan = 0 ; chan < 3 ; ++chan) + { + filter2D(img, tmp[chan], CV_32F, kernel); + } + merge(tmp, 3, gy); + } +} + +void Cloning::computeLaplacianX( const Mat &img, Mat &laplacianX) +{ + Mat kernel = Mat::zeros(1, 3, CV_8S); + kernel.at(0,0) = -1; + kernel.at(0,1) = 1; + filter2D(img, laplacianX, CV_32F, kernel); +} + +void Cloning::computeLaplacianY( const Mat &img, Mat &laplacianY) +{ + Mat kernel = Mat::zeros(3, 1, CV_8S); + kernel.at(0,0) = -1; + kernel.at(1,0) = 1; + filter2D(img, laplacianY, CV_32F, kernel); +} + +void Cloning::dst(const Mat& src, Mat& dest, bool invert) +{ + Mat temp = Mat::zeros(src.rows, 2 * src.cols + 2, CV_32F); + + int flag = invert ? DFT_ROWS + DFT_SCALE + DFT_INVERSE: DFT_ROWS; + + src.copyTo(temp(Rect(1,0, src.cols, src.rows))); + + for(int j = 0 ; j < src.rows ; ++j) + { + float * tempLinePtr = temp.ptr(j); + const float * srcLinePtr = src.ptr(j); + for(int i = 0 ; i < src.cols ; ++i) + { + tempLinePtr[src.cols + 2 + i] = - srcLinePtr[src.cols - 1 - i]; + } + } + + Mat planes[] = {temp, Mat::zeros(temp.size(), CV_32F)}; + Mat complex; + + merge(planes, 2, complex); + dft(complex, complex, flag); + split(complex, planes); + temp = Mat::zeros(src.cols, 2 * src.rows + 2, CV_32F); + + for(int j = 0 ; j < src.cols ; ++j) + { + float * tempLinePtr = temp.ptr(j); + for(int i = 0 ; i < src.rows ; ++i) + { + float val = planes[1].ptr(i)[j + 1]; + tempLinePtr[i + 1] = val; + tempLinePtr[temp.cols - 1 - i] = - val; + } + } + + Mat planes2[] = {temp, Mat::zeros(temp.size(), CV_32F)}; + + merge(planes2, 2, complex); + dft(complex, complex, flag); + split(complex, planes2); + + temp = planes2[1].t(); + dest = Mat::zeros(src.size(), CV_32F); + temp(Rect( 0, 1, src.cols, src.rows)).copyTo(dest); +} + +void Cloning::idst(const Mat& src, Mat& dest) +{ + dst(src, dest, true); +} + +void Cloning::solve(const Mat &img, Mat& mod_diff, Mat &result) +{ + const int w = img.cols; + const int h = img.rows; + + Mat res; + dst(mod_diff, res); + + for(int j = 0 ; j < h-2; j++) + { + float * resLinePtr = res.ptr(j); + for(int i = 0 ; i < w-2; i++) + { + resLinePtr[i] /= (filter_X[i] + filter_Y[j] - 4); + } + } + + idst(res, mod_diff); + + unsigned char * resLinePtr = result.ptr(0); + const unsigned char * imgLinePtr = img.ptr(0); + const float * interpLinePtr = NULL; + + //first col + for(int i = 0 ; i < w ; ++i) + result.ptr(0)[i] = img.ptr(0)[i]; + + for(int j = 1 ; j < h-1 ; ++j) + { + resLinePtr = result.ptr(j); + imgLinePtr = img.ptr(j); + interpLinePtr = mod_diff.ptr(j-1); + + //first row + resLinePtr[0] = imgLinePtr[0]; + + for(int i = 1 ; i < w-1 ; ++i) + { + //saturate cast is not used here, because it behaves differently from the previous implementation + //most notable, saturate_cast rounds before truncating, here it's the opposite. + float value = interpLinePtr[i-1]; + if(value < 0.) + resLinePtr[i] = 0; + else if (value > 255.0) + resLinePtr[i] = 255; + else + resLinePtr[i] = static_cast(value); + } + + //last row + resLinePtr[w-1] = imgLinePtr[w-1]; + } + + //last col + resLinePtr = result.ptr(h-1); + imgLinePtr = img.ptr(h-1); + for(int i = 0 ; i < w ; ++i) + resLinePtr[i] = imgLinePtr[i]; +} + +void Cloning::poissonSolver(const Mat &img, Mat &laplacianX , Mat &laplacianY, Mat &result) +{ + const int w = img.cols; + const int h = img.rows; + + Mat lap = Mat(img.size(),CV_32FC1); + + lap = laplacianX + laplacianY; + + Mat bound = img.clone(); + + rectangle(bound, Point(1, 1), Point(img.cols-2, img.rows-2), Scalar::all(0), -1); + Mat boundary_points; + Laplacian(bound, boundary_points, CV_32F); + + boundary_points = lap - boundary_points; + + Mat mod_diff = boundary_points(Rect(1, 1, w-2, h-2)); + + solve(img,mod_diff,result); +} + +void Cloning::initVariables(const Mat &destination, const Mat &binaryMask) +{ + destinationGradientX = Mat(destination.size(),CV_32FC3); + destinationGradientY = Mat(destination.size(),CV_32FC3); + patchGradientX = Mat(destination.size(),CV_32FC3); + patchGradientY = Mat(destination.size(),CV_32FC3); + + binaryMaskFloat = Mat(binaryMask.size(),CV_32FC1); + binaryMaskFloatInverted = Mat(binaryMask.size(),CV_32FC1); + + //init of the filters used in the dst + const int w = destination.cols; + filter_X.resize(w - 2); + for(int i = 0 ; i < w-2 ; ++i) + filter_X[i] = 2.0f * std::cos(static_cast(CV_PI) * (i + 1) / (w - 1)); + + const int h = destination.rows; + filter_Y.resize(h - 2); + for(int j = 0 ; j < h - 2 ; ++j) + filter_Y[j] = 2.0f * std::cos(static_cast(CV_PI) * (j + 1) / (h - 1)); +} + +void Cloning::computeDerivatives(const Mat& destination, const Mat &patch, const Mat &binaryMask) +{ + initVariables(destination,binaryMask); + + computeGradientX(destination,destinationGradientX); + computeGradientY(destination,destinationGradientY); + + computeGradientX(patch,patchGradientX); + computeGradientY(patch,patchGradientY); + + Mat Kernel(Size(3, 3), CV_8UC1); + Kernel.setTo(Scalar(1)); + erode(binaryMask, binaryMask, Kernel, Point(-1,-1), 3); + + binaryMask.convertTo(binaryMaskFloat,CV_32FC1,1.0/255.0); +} + +void Cloning::scalarProduct(Mat mat, float r, float g, float b) +{ + vector channels; + split(mat,channels); + multiply(channels[2],r,channels[2]); + multiply(channels[1],g,channels[1]); + multiply(channels[0],b,channels[0]); + merge(channels,mat); +} + +void Cloning::arrayProduct(const cv::Mat& lhs, const cv::Mat& rhs, cv::Mat& result) const +{ + vector lhs_channels; + vector result_channels; + + split(lhs,lhs_channels); + split(result,result_channels); + + for(int chan = 0 ; chan < 3 ; ++chan) + multiply(lhs_channels[chan],rhs,result_channels[chan]); + + merge(result_channels,result); +} + +void Cloning::poisson(const Mat &destination) +{ + Mat laplacianX = Mat(destination.size(),CV_32FC3); + Mat laplacianY = Mat(destination.size(),CV_32FC3); + + laplacianX = destinationGradientX + patchGradientX; + laplacianY = destinationGradientY + patchGradientY; + + computeLaplacianX(laplacianX,laplacianX); + computeLaplacianY(laplacianY,laplacianY); + + split(laplacianX,rgbx_channel); + split(laplacianY,rgby_channel); + + split(destination,output); + + for(int chan = 0 ; chan < 3 ; ++chan) + { + poissonSolver(output[chan], rgbx_channel[chan], rgby_channel[chan], output[chan]); + } +} + +void Cloning::evaluate(const Mat &I, const Mat &wmask, const Mat &cloned) +{ + bitwise_not(wmask,wmask); + + wmask.convertTo(binaryMaskFloatInverted,CV_32FC1,1.0/255.0); + + arrayProduct(destinationGradientX,binaryMaskFloatInverted, destinationGradientX); + arrayProduct(destinationGradientY,binaryMaskFloatInverted, destinationGradientY); + + poisson(I); + + merge(output,cloned); +} + +void Cloning::normalClone(const Mat &destination, const Mat &patch, const Mat &binaryMask, Mat &cloned, int flag) +{ + const int w = destination.cols; + const int h = destination.rows; + const int channel = destination.channels(); + const int n_elem_in_line = w * channel; + + computeDerivatives(destination,patch,binaryMask); + + switch(flag) + { + case NORMAL_CLONE: + arrayProduct(patchGradientX,binaryMaskFloat, patchGradientX); + arrayProduct(patchGradientY,binaryMaskFloat, patchGradientY); + break; + + case MIXED_CLONE: + { + AutoBuffer maskIndices(n_elem_in_line); + for (int i = 0; i < n_elem_in_line; ++i) + maskIndices[i] = i / channel; + + for(int i=0;i < h; i++) + { + float * patchXLinePtr = patchGradientX.ptr(i); + float * patchYLinePtr = patchGradientY.ptr(i); + const float * destinationXLinePtr = destinationGradientX.ptr(i); + const float * destinationYLinePtr = destinationGradientY.ptr(i); + const float * binaryMaskLinePtr = binaryMaskFloat.ptr(i); + + for(int j=0; j < n_elem_in_line; j++) + { + int maskIndex = maskIndices[j]; + + if(abs(patchXLinePtr[j] - patchYLinePtr[j]) > + abs(destinationXLinePtr[j] - destinationYLinePtr[j])) + { + patchXLinePtr[j] *= binaryMaskLinePtr[maskIndex]; + patchYLinePtr[j] *= binaryMaskLinePtr[maskIndex]; + } + else + { + patchXLinePtr[j] = destinationXLinePtr[j] + * binaryMaskLinePtr[maskIndex]; + patchYLinePtr[j] = destinationYLinePtr[j] + * binaryMaskLinePtr[maskIndex]; + } + } + } + } + break; + + case MONOCHROME_TRANSFER: + Mat gray = Mat(patch.size(),CV_8UC1); + cvtColor(patch, gray, COLOR_BGR2GRAY ); + + computeGradientX(gray,patchGradientX); + computeGradientY(gray,patchGradientY); + + arrayProduct(patchGradientX, binaryMaskFloat, patchGradientX); + arrayProduct(patchGradientY, binaryMaskFloat, patchGradientY); + break; + + } + + evaluate(destination,binaryMask,cloned); +} + +void Cloning::localColorChange(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float red_mul=1.0, + float green_mul=1.0, float blue_mul=1.0) +{ + computeDerivatives(I,mask,wmask); + + arrayProduct(patchGradientX,binaryMaskFloat, patchGradientX); + arrayProduct(patchGradientY,binaryMaskFloat, patchGradientY); + scalarProduct(patchGradientX,red_mul,green_mul,blue_mul); + scalarProduct(patchGradientY,red_mul,green_mul,blue_mul); + + evaluate(I,wmask,cloned); +} + +void Cloning::illuminationChange(Mat &I, Mat &mask, Mat &wmask, Mat &cloned, float alpha, float beta) +{ + computeDerivatives(I,mask,wmask); + + arrayProduct(patchGradientX,binaryMaskFloat, patchGradientX); + arrayProduct(patchGradientY,binaryMaskFloat, patchGradientY); + + Mat mag = Mat(I.size(),CV_32FC3); + magnitude(patchGradientX,patchGradientY,mag); + + Mat multX, multY, multx_temp, multy_temp; + + multiply(patchGradientX,pow(alpha,beta),multX); + pow(mag,-1*beta, multx_temp); + multiply(multX,multx_temp, patchGradientX); + patchNaNs(patchGradientX); + + multiply(patchGradientY,pow(alpha,beta),multY); + pow(mag,-1*beta, multy_temp); + multiply(multY,multy_temp,patchGradientY); + patchNaNs(patchGradientY); + + Mat zeroMask = (patchGradientX != 0); + + patchGradientX.copyTo(patchGradientX, zeroMask); + patchGradientY.copyTo(patchGradientY, zeroMask); + + evaluate(I,wmask,cloned); +} + +void Cloning::textureFlatten(Mat &I, Mat &mask, Mat &wmask, float low_threshold, + float high_threshold, int kernel_size, Mat &cloned) +{ + computeDerivatives(I,mask,wmask); + + Mat out = Mat(mask.size(),CV_8UC1); + Canny(mask,out,low_threshold,high_threshold,kernel_size); + + Mat zeros(patchGradientX.size(), CV_32FC3); + zeros.setTo(0); + Mat zerosMask = (out != 255); + zeros.copyTo(patchGradientX, zerosMask); + zeros.copyTo(patchGradientY, zerosMask); + + arrayProduct(patchGradientX,binaryMaskFloat, patchGradientX); + arrayProduct(patchGradientY,binaryMaskFloat, patchGradientY); + + evaluate(I,wmask,cloned); +} diff --git a/modules/photo/test/test_cloning.cpp b/modules/photo/test/test_cloning.cpp index 62fe243954..56d166205c 100644 --- a/modules/photo/test/test_cloning.cpp +++ b/modules/photo/test/test_cloning.cpp @@ -39,6 +39,15 @@ // //M*/ +#define OUTPUT_SAVING 0 +#if OUTPUT_SAVING +#define SAVE(x) std::vector params;\ + params.push_back(16);\ + params.push_back(0);\ + imwrite(folder + "output.png", x ,params); +#else +#define SAVE(x) +#endif #include "test_precomp.hpp" #include "opencv2/photo.hpp" @@ -47,6 +56,7 @@ using namespace cv; using namespace std; +static const double numerical_precision = 1000.; TEST(Photo_SeamlessClone_normal, regression) { @@ -69,8 +79,13 @@ TEST(Photo_SeamlessClone_normal, regression) p.y = destination.size().height/2; seamlessClone(source, destination, mask, p, result, 1); - imwrite(folder + "cloned.png", result); + Mat reference = imread(folder + "reference.png"); + + SAVE(result); + + double error = cvtest::norm(reference, result, NORM_L1); + EXPECT_LE(error, numerical_precision); } TEST(Photo_SeamlessClone_mixed, regression) @@ -94,7 +109,11 @@ TEST(Photo_SeamlessClone_mixed, regression) p.y = destination.size().height/2; seamlessClone(source, destination, mask, p, result, 2); - imwrite(folder + "cloned.png", result); + SAVE(result); + + Mat reference = imread(folder + "reference.png"); + double error = cvtest::norm(reference, result, NORM_L1); + EXPECT_LE(error, numerical_precision); } @@ -119,7 +138,11 @@ TEST(Photo_SeamlessClone_featureExchange, regression) p.y = destination.size().height/2; seamlessClone(source, destination, mask, p, result, 3); - imwrite(folder + "cloned.png", result); + SAVE(result); + + Mat reference = imread(folder + "reference.png"); + double error = cvtest::norm(reference, result, NORM_L1); + EXPECT_LE(error, numerical_precision); } @@ -138,7 +161,11 @@ TEST(Photo_SeamlessClone_colorChange, regression) Mat result; colorChange(source, mask, result, 1.5, .5, .5); - imwrite(folder + "cloned.png", result); + SAVE(result); + + Mat reference = imread(folder + "reference.png"); + double error = cvtest::norm(reference, result, NORM_L1); + EXPECT_LE(error, numerical_precision); } @@ -157,7 +184,11 @@ TEST(Photo_SeamlessClone_illuminationChange, regression) Mat result; illuminationChange(source, mask, result, 0.2f, 0.4f); - imwrite(folder + "cloned.png", result); + SAVE(result); + + Mat reference = imread(folder + "reference.png"); + double error = cvtest::norm(reference, result, NORM_L1); + EXPECT_LE(error, numerical_precision); } @@ -176,6 +207,10 @@ TEST(Photo_SeamlessClone_textureFlattening, regression) Mat result; textureFlattening(source, mask, result, 30, 45, 3); - imwrite(folder + "cloned.png", result); + SAVE(result); + + Mat reference = imread(folder + "reference.png"); + double error = cvtest::norm(reference, result, NORM_L1); + EXPECT_LE(error, numerical_precision); } diff --git a/modules/photo/test/test_decolor.cpp b/modules/photo/test/test_decolor.cpp index bf21f37384..259f7afd10 100644 --- a/modules/photo/test/test_decolor.cpp +++ b/modules/photo/test/test_decolor.cpp @@ -47,6 +47,7 @@ using namespace cv; using namespace std; +static const double numerical_precision = 10.; TEST(Photo_Decolor, regression) { @@ -61,7 +62,11 @@ TEST(Photo_Decolor, regression) Mat grayscale, color_boost; decolor(original, grayscale, color_boost); - imwrite(folder + "grayscale.png",grayscale); - imwrite(folder + "color_boost.png",color_boost); + Mat reference_grayscale = imread(folder + "grayscale_reference.png", 0 /* == grayscale image*/); + double error_grayscale = cvtest::norm(reference_grayscale, grayscale, NORM_L1); + EXPECT_LE(error_grayscale, numerical_precision); + Mat reference_boost = imread(folder + "boost_reference.png"); + double error_boost = cvtest::norm(reference_boost, color_boost, NORM_L1); + EXPECT_LE(error_boost, numerical_precision); } diff --git a/modules/photo/test/test_npr.cpp b/modules/photo/test/test_npr.cpp index 4d1c027ba1..24f6f886ec 100755 --- a/modules/photo/test/test_npr.cpp +++ b/modules/photo/test/test_npr.cpp @@ -47,6 +47,7 @@ using namespace cv; using namespace std; +static const double numerical_precision = 100.; TEST(Photo_NPR_EdgePreserveSmoothing_RecursiveFilter, regression) { @@ -60,8 +61,9 @@ TEST(Photo_NPR_EdgePreserveSmoothing_RecursiveFilter, regression) Mat result; edgePreservingFilter(source,result,1); - imwrite(folder + "smoothened_RF.png", result); - + Mat reference = imread(folder + "smoothened_RF_reference.png"); + double error = cvtest::norm(reference, result, NORM_L1); + EXPECT_LE(error, numerical_precision); } TEST(Photo_NPR_EdgePreserveSmoothing_NormConvFilter, regression) @@ -76,7 +78,9 @@ TEST(Photo_NPR_EdgePreserveSmoothing_NormConvFilter, regression) Mat result; edgePreservingFilter(source,result,2); - imwrite(folder + "smoothened_NCF.png", result); + Mat reference = imread(folder + "smoothened_NCF_reference.png"); + double error = cvtest::norm(reference, result, NORM_L1); + EXPECT_LE(error, numerical_precision); } @@ -92,8 +96,9 @@ TEST(Photo_NPR_DetailEnhance, regression) Mat result; detailEnhance(source,result); - imwrite(folder + "detail_enhanced.png", result); - + Mat reference = imread(folder + "detail_enhanced_reference.png"); + double error = cvtest::norm(reference, result, NORM_L1); + EXPECT_LE(error, numerical_precision); } TEST(Photo_NPR_PencilSketch, regression) @@ -105,12 +110,16 @@ TEST(Photo_NPR_PencilSketch, regression) ASSERT_FALSE(source.empty()) << "Could not load input image " << original_path; - Mat result,result1; - pencilSketch(source,result,result1, 10, 0.1f, 0.03f); + Mat pencil_result, color_pencil_result; + pencilSketch(source,pencil_result, color_pencil_result, 10, 0.1f, 0.03f); - imwrite(folder + "pencil_sketch.png", result); - imwrite(folder + "color_pencil_sketch.png", result1); + Mat pencil_reference = imread(folder + "pencil_sketch_reference.png", 0 /* == grayscale*/); + double pencil_error = norm(pencil_reference, pencil_result, NORM_L1); + EXPECT_LE(pencil_error, numerical_precision); + Mat color_pencil_reference = imread(folder + "color_pencil_sketch_reference.png"); + double color_pencil_error = cvtest::norm(color_pencil_reference, color_pencil_result, NORM_L1); + EXPECT_LE(color_pencil_error, numerical_precision); } TEST(Photo_NPR_Stylization, regression) @@ -125,6 +134,8 @@ TEST(Photo_NPR_Stylization, regression) Mat result; stylization(source,result); - imwrite(folder + "stylized.png", result); + Mat stylized_reference = imread(folder + "stylized_reference.png"); + double stylized_error = cvtest::norm(stylized_reference, result, NORM_L1); + EXPECT_LE(stylized_error, numerical_precision); } diff --git a/modules/python/src2/hdr_parser.py b/modules/python/src2/hdr_parser.py index 3e202fdc07..ea32a17e76 100755 --- a/modules/python/src2/hdr_parser.py +++ b/modules/python/src2/hdr_parser.py @@ -1,7 +1,7 @@ #!/usr/bin/env python from __future__ import print_function -import os, sys, re, string +import os, sys, re, string, io # the list only for debugging. The real list, used in the real OpenCV build, is specified in CMakeLists.txt opencv_hdr_list = [ @@ -734,7 +734,7 @@ class CppHeaderParser(object): """ self.hname = hname decls = [] - f = open(hname, "rt") + f = io.open(hname, 'rt', encoding='utf-8') linelist = list(f.readlines()) f.close() diff --git a/modules/python/test/test.py b/modules/python/test/test.py index e4edc88b5a..cb923ce68b 100644 --- a/modules/python/test/test.py +++ b/modules/python/test/test.py @@ -92,7 +92,7 @@ class Hackathon244Tests(NewOpenCVTests): def test_fast(self): fd = cv2.FastFeatureDetector_create(30, True) - img = self.get_sample("samples/cpp/right02.jpg", 0) + img = self.get_sample("samples/data/right02.jpg", 0) img = cv2.medianBlur(img, 3) imgc = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) keypoints = fd.detect(img) diff --git a/modules/ts/src/ocl_test.cpp b/modules/ts/src/ocl_test.cpp index d429d4bc8c..270dec9145 100644 --- a/modules/ts/src/ocl_test.cpp +++ b/modules/ts/src/ocl_test.cpp @@ -128,6 +128,9 @@ void dumpOpenCLDevice() } const Device& device = Device::getDefault(); + if (!device.available()) + CV_ErrorNoReturn(CV_OpenCLInitError, "OpenCL device is not available"); + DUMP_MESSAGE_STDOUT("Current OpenCL device: "); #if 0 diff --git a/modules/videoio/src/cap_openni2.cpp b/modules/videoio/src/cap_openni2.cpp index 62aacb2faa..8fea1bdb26 100644 --- a/modules/videoio/src/cap_openni2.cpp +++ b/modules/videoio/src/cap_openni2.cpp @@ -646,7 +646,7 @@ bool CvCapture_OpenNI2::setImageGeneratorProperty(int propIdx, double propValue) { case CV_CAP_PROP_OPENNI_OUTPUT_MODE : { - openni::VideoMode mode; + openni::VideoMode mode = color.getVideoMode(); switch( cvRound(propValue) ) { diff --git a/modules/videoio/src/cap_v4l.cpp b/modules/videoio/src/cap_v4l.cpp index efa9a8b44c..a0fe8f10f4 100644 --- a/modules/videoio/src/cap_v4l.cpp +++ b/modules/videoio/src/cap_v4l.cpp @@ -294,7 +294,8 @@ enum PALETTE_TYPE { PALETTE_SBGGR8, PALETTE_SN9C10X, PALETTE_MJPEG, - PALETTE_SGBRG + PALETTE_SGBRG, + PALETTE_RGB24 }; typedef struct CvCaptureCAM_V4L @@ -587,6 +588,10 @@ static int autosetup_capture_mode_v4l2(CvCaptureCAM_V4L* capture) if (try_palette_v4l2(capture, V4L2_PIX_FMT_SGBRG) == 0) { capture->palette = PALETTE_SGBRG; + } + else if (try_palette_v4l2(capture, V4L2_PIX_FMT_RGB24) == 0) + { + capture->palette = PALETTE_RGB24; } else { @@ -1916,6 +1921,18 @@ static void sgbrg2rgb24(long int WIDTH, long int HEIGHT, unsigned char *src, uns } } +static void +rgb24_to_rgb24 (int width, int height, unsigned char *src, unsigned char *dst) +{ + const int size = width * height; + for(int i = 0; i < size; ++i, src += 3, dst += 3) + { + *(dst + 0) = *(src + 2); + *(dst + 1) = *(src + 1); + *(dst + 2) = *(src + 0); + } +} + #define CLAMP(x) ((x)<0?0:((x)>255)?255:(x)) typedef struct { @@ -2219,6 +2236,12 @@ static IplImage* icvRetrieveFrameCAM_V4L( CvCaptureCAM_V4L* capture, int) { (unsigned char*)capture->buffers[(capture->bufferIndex+1) % capture->req.count].start, (unsigned char*)capture->frame.imageData); break; + case PALETTE_RGB24: + rgb24_to_rgb24(capture->form.fmt.pix.width, + capture->form.fmt.pix.height, + (unsigned char*)capture->buffers[(capture->bufferIndex+1) % capture->req.count].start, + (unsigned char*)capture->frame.imageData); + break; } } #endif /* HAVE_CAMV4L2 */ diff --git a/samples/cpp/airplane.jpg b/samples/cpp/airplane.jpg deleted file mode 100644 index a9b465267d..0000000000 Binary files a/samples/cpp/airplane.jpg and /dev/null differ diff --git a/samples/cpp/baboon200.jpg b/samples/cpp/baboon200.jpg deleted file mode 100644 index 1b873e0ce1..0000000000 Binary files a/samples/cpp/baboon200.jpg and /dev/null differ diff --git a/samples/cpp/baboon200_rotated.jpg b/samples/cpp/baboon200_rotated.jpg deleted file mode 100644 index 86160db9ac..0000000000 Binary files a/samples/cpp/baboon200_rotated.jpg and /dev/null differ diff --git a/samples/cpp/bgfg_segm.cpp b/samples/cpp/bgfg_segm.cpp index 94aa4d8387..c02185a655 100644 --- a/samples/cpp/bgfg_segm.cpp +++ b/samples/cpp/bgfg_segm.cpp @@ -23,7 +23,7 @@ const char* keys = "{c camera | | use camera or not}" "{m method |mog2 | method (knn or mog2) }" "{s smooth | | smooth the mask }" - "{fn file_name|tree.avi | movie file }" + "{fn file_name|../data/tree.avi | movie file }" }; //this is a sample for foreground detection functions diff --git a/samples/cpp/cloning_gui.cpp b/samples/cpp/cloning_gui.cpp index 07671ca8a6..668dd2a959 100644 --- a/samples/cpp/cloning_gui.cpp +++ b/samples/cpp/cloning_gui.cpp @@ -65,7 +65,7 @@ float alpha,beta; float red, green, blue; -double low_t, high_t; +float low_t, high_t; void source(int, int, int, int, void*); void destination(int, int, int, int, void*); diff --git a/samples/cpp/connected_components.cpp b/samples/cpp/connected_components.cpp index 32bd0dc053..d1c3411a79 100644 --- a/samples/cpp/connected_components.cpp +++ b/samples/cpp/connected_components.cpp @@ -36,14 +36,14 @@ static void help() { cout << "\n This program demonstrates connected components and use of the trackbar\n" "Usage: \n" - " ./connected_components \n" + " ./connected_components \n" "The image is converted to grayscale and displayed, another image has a trackbar\n" "that controls thresholding and thereby the extracted contours which are drawn in color\n"; } const char* keys = { - "{@image|stuff.jpg|image for converting to a grayscale}" + "{@image|../data/stuff.jpg|image for converting to a grayscale}" }; int main( int argc, const char** argv ) diff --git a/samples/cpp/demhist.cpp b/samples/cpp/demhist.cpp index 033b63d82c..39661f0a88 100644 --- a/samples/cpp/demhist.cpp +++ b/samples/cpp/demhist.cpp @@ -59,12 +59,12 @@ static void updateBrightnessContrast( int /*arg*/, void* ) static void help() { std::cout << "\nThis program demonstrates the use of calcHist() -- histogram creation.\n" - << "Usage: \n" << "demhist [image_name -- Defaults to baboon.jpg]" << std::endl; + << "Usage: \n" << "demhist [image_name -- Defaults to ../data/baboon.jpg]" << std::endl; } const char* keys = { - "{@image|baboon.jpg|input image file}" + "{@image|../data/baboon.jpg|input image file}" }; int main( int argc, const char** argv ) diff --git a/samples/cpp/dft.cpp b/samples/cpp/dft.cpp index c4034e896c..0525d9f4fa 100644 --- a/samples/cpp/dft.cpp +++ b/samples/cpp/dft.cpp @@ -14,12 +14,12 @@ static void help() printf("\nThis program demonstrated the use of the discrete Fourier transform (dft)\n" "The dft of an image is taken and it's power spectrum is displayed.\n" "Usage:\n" - "./dft [image_name -- default lena.jpg]\n"); + "./dft [image_name -- default ../data/lena.jpg]\n"); } const char* keys = { - "{@image|lena.jpg|input image file}" + "{@image|../data/lena.jpg|input image file}" }; int main(int argc, const char ** argv) diff --git a/samples/cpp/distrans.cpp b/samples/cpp/distrans.cpp index 8f0ae57b55..070df3c488 100644 --- a/samples/cpp/distrans.cpp +++ b/samples/cpp/distrans.cpp @@ -91,7 +91,7 @@ static void help() { printf("\nProgram to demonstrate the use of the distance transform function between edge images.\n" "Usage:\n" - "./distrans [image_name -- default image is stuff.jpg]\n" + "./distrans [image_name -- default image is ../data/stuff.jpg]\n" "\nHot keys: \n" "\tESC - quit the program\n" "\tC - use C/Inf metric\n" @@ -107,7 +107,7 @@ static void help() const char* keys = { - "{@image |stuff.jpg|input image file}" + "{@image |../data/stuff.jpg|input image file}" }; int main( int argc, const char** argv ) diff --git a/samples/cpp/edge.cpp b/samples/cpp/edge.cpp index a4c0f5d0bb..4b398e7774 100644 --- a/samples/cpp/edge.cpp +++ b/samples/cpp/edge.cpp @@ -28,12 +28,12 @@ static void help() { printf("\nThis sample demonstrates Canny edge detection\n" "Call:\n" - " /.edge [image_name -- Default is fruits.jpg]\n\n"); + " /.edge [image_name -- Default is ../data/fruits.jpg]\n\n"); } const char* keys = { - "{@image |fruits.jpg|input image name}" + "{@image |../data/fruits.jpg|input image name}" }; int main( int argc, const char** argv ) diff --git a/samples/cpp/facedetect.cpp b/samples/cpp/facedetect.cpp index 0c747d394b..1206245ef6 100644 --- a/samples/cpp/facedetect.cpp +++ b/samples/cpp/facedetect.cpp @@ -118,8 +118,8 @@ int main( int argc, const char** argv ) } else { - image = imread( "lena.jpg", 1 ); - if(image.empty()) cout << "Couldn't read lena.jpg" << endl; + image = imread( "../data/lena.jpg", 1 ); + if(image.empty()) cout << "Couldn't read ../data/lena.jpg" << endl; } cvNamedWindow( "result", 1 ); diff --git a/samples/cpp/ffilldemo.cpp b/samples/cpp/ffilldemo.cpp index 46d08186a3..e099587a11 100644 --- a/samples/cpp/ffilldemo.cpp +++ b/samples/cpp/ffilldemo.cpp @@ -12,7 +12,7 @@ static void help() { cout << "\nThis program demonstrated the floodFill() function\n" "Call:\n" - "./ffilldemo [image_name -- Default: fruits.jpg]\n" << endl; + "./ffilldemo [image_name -- Default: ../data/fruits.jpg]\n" << endl; cout << "Hot keys: \n" "\tESC - quit the program\n" @@ -73,7 +73,7 @@ static void onMouse( int event, int x, int y, int, void* ) int main( int argc, char** argv ) { - char* filename = argc >= 2 ? argv[1] : (char*)"fruits.jpg"; + char* filename = argc >= 2 ? argv[1] : (char*)"../data/fruits.jpg"; image0 = imread(filename, 1); if( image0.empty() ) diff --git a/samples/cpp/filestorage.cpp b/samples/cpp/filestorage.cpp index 519fd2b686..41043d11cc 100644 --- a/samples/cpp/filestorage.cpp +++ b/samples/cpp/filestorage.cpp @@ -85,8 +85,8 @@ int main(int ac, char** av) cout << "writing images\n"; fs << "images" << "["; - fs << "image1.jpg" << "myfi.png" << "baboon.jpg"; - cout << "image1.jpg" << " myfi.png" << " baboon.jpg" << endl; + fs << "image1.jpg" << "myfi.png" << "../data/baboon.jpg"; + cout << "image1.jpg" << " myfi.png" << " ../data/baboon.jpg" << endl; fs << "]"; diff --git a/samples/cpp/fitellipse.cpp b/samples/cpp/fitellipse.cpp index 1e9a85857a..bd6b77d8a6 100644 --- a/samples/cpp/fitellipse.cpp +++ b/samples/cpp/fitellipse.cpp @@ -27,7 +27,7 @@ using namespace std; // "\nThis program is demonstration for ellipse fitting. The program finds\n" // "contours and approximate it by ellipses.\n" // "Call:\n" -// "./fitellipse [image_name -- Default stuff.jpg]\n" << endl; +// "./fitellipse [image_name -- Default ../data/stuff.jpg]\n" << endl; // } int sliderPos = 70; @@ -38,7 +38,7 @@ void processImage(int, void*); int main( int argc, char** argv ) { - const char* filename = argc == 2 ? argv[1] : (char*)"stuff.jpg"; + const char* filename = argc == 2 ? argv[1] : (char*)"../data/stuff.jpg"; image = imread(filename, 0); if( image.empty() ) { diff --git a/samples/cpp/houghcircles.cpp b/samples/cpp/houghcircles.cpp index 2a20b62a76..34a2e6b7e8 100644 --- a/samples/cpp/houghcircles.cpp +++ b/samples/cpp/houghcircles.cpp @@ -11,12 +11,12 @@ static void help() { cout << "\nThis program demonstrates circle finding with the Hough transform.\n" "Usage:\n" - "./houghcircles , Default is pic1.png\n" << endl; + "./houghcircles , Default is ../data/board.jpg\n" << endl; } int main(int argc, char** argv) { - const char* filename = argc >= 2 ? argv[1] : "board.jpg"; + const char* filename = argc >= 2 ? argv[1] : "../data/board.jpg"; Mat img = imread(filename, 0); if(img.empty()) diff --git a/samples/cpp/houghlines.cpp b/samples/cpp/houghlines.cpp index ad472a47cc..ec825ab6b4 100644 --- a/samples/cpp/houghlines.cpp +++ b/samples/cpp/houghlines.cpp @@ -11,12 +11,12 @@ static void help() { cout << "\nThis program demonstrates line finding with the Hough transform.\n" "Usage:\n" - "./houghlines , Default is pic1.png\n" << endl; + "./houghlines , Default is ../data/pic1.png\n" << endl; } int main(int argc, char** argv) { - const char* filename = argc >= 2 ? argv[1] : "pic1.png"; + const char* filename = argc >= 2 ? argv[1] : "../data/pic1.png"; Mat src = imread(filename, 0); if(src.empty()) diff --git a/samples/cpp/image.cpp b/samples/cpp/image.cpp index a9a18e3127..cf97dda259 100644 --- a/samples/cpp/image.cpp +++ b/samples/cpp/image.cpp @@ -14,7 +14,7 @@ static void help() "It shows reading of images, converting to planes and merging back, color conversion\n" "and also iterating through pixels.\n" "Call:\n" - "./image [image-name Default: lena.jpg]\n" << endl; + "./image [image-name Default: ../data/lena.jpg]\n" << endl; } // enable/disable use of mixed API in the code below. @@ -28,7 +28,7 @@ static void help() int main( int argc, char** argv ) { help(); - const char* imagename = argc > 1 ? argv[1] : "lena.jpg"; + const char* imagename = argc > 1 ? argv[1] : "../data/lena.jpg"; #if DEMO_MIXED_API_USE Ptr iplimg(cvLoadImage(imagename)); // Ptr is safe ref-counting pointer class if(!iplimg) diff --git a/samples/cpp/image_alignment.cpp b/samples/cpp/image_alignment.cpp index 85fcc919de..08814b84fd 100644 --- a/samples/cpp/image_alignment.cpp +++ b/samples/cpp/image_alignment.cpp @@ -3,7 +3,7 @@ * findTransformECC that implements the image alignment ECC algorithm * * -* The demo loads an image (defaults to fruits.jpg) and it artificially creates +* The demo loads an image (defaults to ../data/fruits.jpg) and it artificially creates * a template image based on the given motion type. When two images are given, * the first image is the input image and the second one defines the template image. * In the latter case, you can also parse the warp's initialization. @@ -44,7 +44,7 @@ static void draw_warped_roi(Mat& image, const int width, const int height, Mat& const std::string keys = - "{@inputImage | fruits.jpg | input image filename }" + "{@inputImage | ../data/fruits.jpg | input image filename }" "{@templateImage | | template image filename (optional)}" "{@inputWarp | | input warp (matrix) filename (optional)}" "{n numOfIter | 50 | ECC's iterations }" @@ -64,7 +64,7 @@ static void help(void) " are given, the initialization of the warp by command line parsing is possible. " "If inputWarp is missing, the identity transformation initializes the algorithm. \n" << endl; - cout << "\nUsage example (one image): \n./ecc fruits.jpg -o=outWarp.ecc " + cout << "\nUsage example (one image): \n./ecc ../data/fruits.jpg -o=outWarp.ecc " "-m=euclidean -e=1e-6 -N=70 -v=1 \n" << endl; cout << "\nUsage example (two images with initialization): \n./ecc yourInput.png yourTemplate.png " diff --git a/samples/cpp/inpaint.cpp b/samples/cpp/inpaint.cpp index 7d17d0bf9f..55bd91b73b 100644 --- a/samples/cpp/inpaint.cpp +++ b/samples/cpp/inpaint.cpp @@ -14,7 +14,7 @@ static void help() << "with surrounding image areas.\n" "Using OpenCV version %s\n" << CV_VERSION << "\n" "Usage:\n" - "./inpaint [image_name -- Default fruits.jpg]\n" << endl; + "./inpaint [image_name -- Default ../data/fruits.jpg]\n" << endl; cout << "Hot keys: \n" "\tESC - quit the program\n" @@ -47,7 +47,7 @@ static void onMouse( int event, int x, int y, int flags, void* ) int main( int argc, char** argv ) { - char* filename = argc >= 2 ? argv[1] : (char*)"fruits.jpg"; + char* filename = argc >= 2 ? argv[1] : (char*)"../data/fruits.jpg"; Mat img0 = imread(filename, -1); if(img0.empty()) { diff --git a/samples/cpp/letter_recog.cpp b/samples/cpp/letter_recog.cpp index b6a35e338f..66a59318cc 100644 --- a/samples/cpp/letter_recog.cpp +++ b/samples/cpp/letter_recog.cpp @@ -489,7 +489,7 @@ int main( int argc, char *argv[] ) { string filename_to_save = ""; string filename_to_load = ""; - string data_filename = "./letter-recognition.data"; + string data_filename = "../data/letter-recognition.data"; int method = 0; int i; diff --git a/samples/cpp/logistic_regression.cpp b/samples/cpp/logistic_regression.cpp index a30853a819..1aeb42d925 100644 --- a/samples/cpp/logistic_regression.cpp +++ b/samples/cpp/logistic_regression.cpp @@ -83,7 +83,7 @@ static float calculateAccuracyPercent(const Mat &original, const Mat &predicted) int main() { - const String filename = "data01.xml"; + const String filename = "../data/data01.xml"; cout << "**********************************************************************" << endl; cout << filename << " contains digits 0 and 1 of 20 samples each, collected on an Android device" << endl; diff --git a/samples/cpp/logo.png b/samples/cpp/logo.png deleted file mode 100644 index 0263c55988..0000000000 Binary files a/samples/cpp/logo.png and /dev/null differ diff --git a/samples/cpp/logo_in_clutter.png b/samples/cpp/logo_in_clutter.png deleted file mode 100644 index ccc9ee9bc8..0000000000 Binary files a/samples/cpp/logo_in_clutter.png and /dev/null differ diff --git a/samples/cpp/lsd_lines.cpp b/samples/cpp/lsd_lines.cpp index 82842b2548..69497b3871 100644 --- a/samples/cpp/lsd_lines.cpp +++ b/samples/cpp/lsd_lines.cpp @@ -15,8 +15,8 @@ int main(int argc, char** argv) std::string in; if (argc != 2) { - std::cout << "Usage: lsd_lines [input image]. Now loading building.jpg" << std::endl; - in = "building.jpg"; + std::cout << "Usage: lsd_lines [input image]. Now loading ../data/building.jpg" << std::endl; + in = "../data/building.jpg"; } else { diff --git a/samples/cpp/memorial.exr b/samples/cpp/memorial.exr deleted file mode 100644 index 8ea8545056..0000000000 Binary files a/samples/cpp/memorial.exr and /dev/null differ diff --git a/samples/cpp/morphology2.cpp b/samples/cpp/morphology2.cpp index d41265631d..27eb52aee7 100644 --- a/samples/cpp/morphology2.cpp +++ b/samples/cpp/morphology2.cpp @@ -58,7 +58,7 @@ static void ErodeDilate(int, void*) int main( int argc, char** argv ) { - char* filename = argc == 2 ? argv[1] : (char*)"baboon.jpg"; + char* filename = argc == 2 ? argv[1] : (char*)"../data/baboon.jpg"; if( (src = imread(filename,1)).empty() ) return -1; diff --git a/samples/cpp/openni_capture.cpp b/samples/cpp/openni_capture.cpp index 76b092298a..64aa90bc69 100644 --- a/samples/cpp/openni_capture.cpp +++ b/samples/cpp/openni_capture.cpp @@ -192,7 +192,11 @@ int main( int argc, char* argv[] ) if( isVideoReading ) capture.open( filename ); else - capture.open( CAP_OPENNI ); + { + capture.open( CAP_OPENNI2 ); + if( !capture.isOpened() ) + capture.open( CAP_OPENNI ); + } cout << "done." << endl; diff --git a/samples/cpp/puzzle.png b/samples/cpp/puzzle.png deleted file mode 100644 index 499ceacd38..0000000000 Binary files a/samples/cpp/puzzle.png and /dev/null differ diff --git a/samples/cpp/scene_l.bmp b/samples/cpp/scene_l.bmp deleted file mode 100644 index dd3b619e45..0000000000 Binary files a/samples/cpp/scene_l.bmp and /dev/null differ diff --git a/samples/cpp/scene_r.bmp b/samples/cpp/scene_r.bmp deleted file mode 100644 index 2b6c8d63bc..0000000000 Binary files a/samples/cpp/scene_r.bmp and /dev/null differ diff --git a/samples/cpp/shape_example.cpp b/samples/cpp/shape_example.cpp index 42bcffdb96..e1c925f8c7 100644 --- a/samples/cpp/shape_example.cpp +++ b/samples/cpp/shape_example.cpp @@ -17,7 +17,7 @@ static void help() { printf("\n" "This program demonstrates a method for shape comparisson based on Shape Context\n" - "You should run the program providing a number between 1 and 20 for selecting an image in the folder shape_sample.\n" + "You should run the program providing a number between 1 and 20 for selecting an image in the folder ../data/shape_sample.\n" "Call\n" "./shape_example [number between 1 and 20]\n\n"); } @@ -55,7 +55,7 @@ static vector simpleContour( const Mat& currentQuery, int n=300 ) int main(int argc, char** argv) { help(); - string path = "./shape_sample/"; + string path = "../data/shape_sample/"; int indexQuery = 1; if( argc < 2 ) { diff --git a/samples/cpp/squares.cpp b/samples/cpp/squares.cpp index 23d2ad0f13..f53e931e75 100644 --- a/samples/cpp/squares.cpp +++ b/samples/cpp/squares.cpp @@ -142,8 +142,8 @@ static void drawSquares( Mat& image, const vector >& squares ) int main(int /*argc*/, char** /*argv*/) { - static const char* names[] = { "pic1.png", "pic2.png", "pic3.png", - "pic4.png", "pic5.png", "pic6.png", 0 }; + static const char* names[] = { "../data/pic1.png", "../data/pic2.png", "../data/pic3.png", + "../data/pic4.png", "../data/pic5.png", "../data/pic6.png", 0 }; help(); namedWindow( wndname, 1 ); vector > squares; diff --git a/samples/cpp/stereo_calib.cpp b/samples/cpp/stereo_calib.cpp index 667cffcf7e..44edb82589 100644 --- a/samples/cpp/stereo_calib.cpp +++ b/samples/cpp/stereo_calib.cpp @@ -212,7 +212,7 @@ StereoCalib(const vector& imagelist, Size boardSize, bool useCalibrated= cout << "average reprojection err = " << err/npoints << endl; // save intrinsic parameters - FileStorage fs("intrinsics.yml", FileStorage::WRITE); + FileStorage fs("../data/intrinsics.yml", FileStorage::WRITE); if( fs.isOpened() ) { fs << "M1" << cameraMatrix[0] << "D1" << distCoeffs[0] << @@ -382,7 +382,7 @@ int main(int argc, char** argv) if( imagelistfn == "" ) { - imagelistfn = "stereo_calib.xml"; + imagelistfn = "../data/stereo_calib.xml"; boardSize = Size(9, 6); } else if( boardSize.width <= 0 || boardSize.height <= 0 ) diff --git a/samples/cpp/stereo_match.cpp b/samples/cpp/stereo_match.cpp index f5f77cf3dc..fa5ee7bad1 100644 --- a/samples/cpp/stereo_match.cpp +++ b/samples/cpp/stereo_match.cpp @@ -159,7 +159,18 @@ int main(int argc, char** argv) Mat img1 = imread(img1_filename, color_mode); Mat img2 = imread(img2_filename, color_mode); - if( scale != 1.f ) + if (img1.empty()) + { + printf("Command-line parameter error: could not load the first input image file\n"); + return -1; + } + if (img2.empty()) + { + printf("Command-line parameter error: could not load the second input image file\n"); + return -1; + } + + if (scale != 1.f) { Mat temp1, temp2; int method = scale < 1 ? INTER_AREA : INTER_CUBIC; diff --git a/samples/cpp/tsukuba_l.png b/samples/cpp/tsukuba_l.png deleted file mode 100644 index be22fd6942..0000000000 Binary files a/samples/cpp/tsukuba_l.png and /dev/null differ diff --git a/samples/cpp/tsukuba_r.png b/samples/cpp/tsukuba_r.png deleted file mode 100644 index c4acf61bbb..0000000000 Binary files a/samples/cpp/tsukuba_r.png and /dev/null differ diff --git a/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp b/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp index 11843fb08d..9e04dd912e 100644 --- a/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp +++ b/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp @@ -44,8 +44,8 @@ static void on_trackbar( int, void* ) int main( void ) { /// Read image ( same size, same type ) - src1 = imread("../images/LinuxLogo.jpg"); - src2 = imread("../images/WindowsLogo.jpg"); + src1 = imread("../data/LinuxLogo.jpg"); + src2 = imread("../data/WindowsLogo.jpg"); if( src1.empty() ) { printf("Error loading src1 \n"); return -1; } if( src2.empty() ) { printf("Error loading src2 \n"); return -1; } diff --git a/samples/cpp/tutorial_code/ImgProc/AddingImages.cpp b/samples/cpp/tutorial_code/ImgProc/AddingImages.cpp index b7a27d2cab..32ce10f4b2 100644 --- a/samples/cpp/tutorial_code/ImgProc/AddingImages.cpp +++ b/samples/cpp/tutorial_code/ImgProc/AddingImages.cpp @@ -32,8 +32,8 @@ int main( void ) { alpha = input; } /// Read image ( same size, same type ) - src1 = imread("../images/LinuxLogo.jpg"); - src2 = imread("../images/WindowsLogo.jpg"); + src1 = imread("../data/LinuxLogo.jpg"); + src2 = imread("../data/WindowsLogo.jpg"); if( src1.empty() ) { std::cout<< "Error loading src1"< Close program \n \n" ); /// Test image - Make sure it s divisible by 2^{n} - src = imread( "../images/chicky_512.png" ); + src = imread( "../data/chicky_512.png" ); if( src.empty() ) { printf(" No data! -- Exiting the program \n"); return -1; } diff --git a/samples/cpp/tutorial_code/ImgProc/Smoothing.cpp b/samples/cpp/tutorial_code/ImgProc/Smoothing.cpp index 238f921e92..e7ac4d40f5 100644 --- a/samples/cpp/tutorial_code/ImgProc/Smoothing.cpp +++ b/samples/cpp/tutorial_code/ImgProc/Smoothing.cpp @@ -35,7 +35,7 @@ int main( void ) namedWindow( window_name, WINDOW_AUTOSIZE ); /// Load the source image - src = imread( "../images/lena.png", 1 ); + src = imread( "../data/lena.jpg", 1 ); if( display_caption( "Original Image" ) != 0 ) { return 0; } diff --git a/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp b/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp index 581a968246..dbebeea923 100644 --- a/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp +++ b/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp @@ -14,14 +14,14 @@ static void help(char* progName) << "This program demonstrated the use of the discrete Fourier transform (DFT). " << endl << "The dft of an image is taken and it's power spectrum is displayed." << endl << "Usage:" << endl - << progName << " [image_name -- default lena.jpg] " << endl << endl; + << progName << " [image_name -- default ../data/lena.jpg] " << endl << endl; } int main(int argc, char ** argv) { help(argv[0]); - const char* filename = argc >=2 ? argv[1] : "lena.jpg"; + const char* filename = argc >=2 ? argv[1] : "../data/lena.jpg"; Mat I = imread(filename, IMREAD_GRAYSCALE); if( I.empty()) diff --git a/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp b/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp index 388b7744f1..8fc722df78 100644 --- a/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp +++ b/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp @@ -80,7 +80,7 @@ int main(int ac, char** av) fs << "iterationNr" << 100; fs << "strings" << "["; // text - string sequence - fs << "image1.jpg" << "Awesomeness" << "baboon.jpg"; + fs << "image1.jpg" << "Awesomeness" << "../data/baboon.jpg"; fs << "]"; // close sequence fs << "Mapping"; // text - mapping diff --git a/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp b/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp index 1b1c1bc6b3..e18bbeca68 100644 --- a/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp +++ b/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp @@ -17,7 +17,7 @@ static void help( char* progName) << "Also contains example for image read, spliting the planes, merging back and " << endl << " color conversion, plus iterating through pixels. " << endl << "Usage:" << endl - << progName << " [image-name Default: lena.jpg]" << endl << endl; + << progName << " [image-name Default: ../data/lena.jpg]" << endl << endl; } // comment out the define to use only the latest C++ API @@ -31,7 +31,7 @@ static void help( char* progName) int main( int argc, char** argv ) { help(argv[0]); - const char* imagename = argc > 1 ? argv[1] : "lena.jpg"; + const char* imagename = argc > 1 ? argv[1] : "../data/lena.jpg"; #ifdef DEMO_MIXED_API_USE Ptr IplI(cvLoadImage(imagename)); // Ptr is a safe ref-counting pointer class diff --git a/samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp b/samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp index 0cfc5e6932..0a25f15d12 100644 --- a/samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp +++ b/samples/cpp/tutorial_code/core/ippasync/ippasync_sample.cpp @@ -36,7 +36,7 @@ static void help() const char* keys = { "{c camera | | use camera or not}" - "{fn file_name|baboon.jpg | image file }" + "{fn file_name|../data/baboon.jpg | image file }" "{a accel |auto | accelerator type: auto (default), cpu, gpu}" }; diff --git a/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp b/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp index 93e22ceb65..f0cbca1695 100644 --- a/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp +++ b/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp @@ -14,7 +14,7 @@ static void help(char* progName) << "This program shows how to filter images with mask: the write it yourself and the" << "filter2d way. " << endl << "Usage:" << endl - << progName << " [image_name -- default lena.jpg] [G -- grayscale] " << endl << endl; + << progName << " [image_name -- default ../data/lena.jpg] [G -- grayscale] " << endl << endl; } @@ -23,7 +23,7 @@ void Sharpen(const Mat& myImage,Mat& Result); int main( int argc, char* argv[]) { help(argv[0]); - const char* filename = argc >=2 ? argv[1] : "lena.jpg"; + const char* filename = argc >=2 ? argv[1] : "../data/lena.jpg"; Mat I, J, K; diff --git a/samples/cpp/tutorial_code/features2D/AKAZE_match.cpp b/samples/cpp/tutorial_code/features2D/AKAZE_match.cpp index 5662cc9f20..7018b703fb 100755 --- a/samples/cpp/tutorial_code/features2D/AKAZE_match.cpp +++ b/samples/cpp/tutorial_code/features2D/AKAZE_match.cpp @@ -12,11 +12,11 @@ const float nn_match_ratio = 0.8f; // Nearest neighbor matching ratio int main(void) { - Mat img1 = imread("graf1.png", IMREAD_GRAYSCALE); - Mat img2 = imread("graf3.png", IMREAD_GRAYSCALE); + Mat img1 = imread("../data/graf1.png", IMREAD_GRAYSCALE); + Mat img2 = imread("../data/graf3.png", IMREAD_GRAYSCALE); Mat homography; - FileStorage fs("H1to3p.xml", FileStorage::READ); + FileStorage fs("../data/H1to3p.xml", FileStorage::READ); fs.getFirstTopLevelNode() >> homography; vector kpts1, kpts2; diff --git a/samples/cpp/tutorial_code/images/Megamind.png b/samples/cpp/tutorial_code/images/Megamind.png deleted file mode 100644 index a1cc6d178b..0000000000 Binary files a/samples/cpp/tutorial_code/images/Megamind.png and /dev/null differ diff --git a/samples/cpp/tutorial_code/images/Megamind_alt.png b/samples/cpp/tutorial_code/images/Megamind_alt.png deleted file mode 100644 index 4e345f23d5..0000000000 Binary files a/samples/cpp/tutorial_code/images/Megamind_alt.png and /dev/null differ diff --git a/samples/cpp/tutorial_code/images/baboon.jpg b/samples/cpp/tutorial_code/images/baboon.jpg deleted file mode 100644 index 2f98d8359b..0000000000 Binary files a/samples/cpp/tutorial_code/images/baboon.jpg and /dev/null differ diff --git a/samples/cpp/tutorial_code/images/cat.jpg b/samples/cpp/tutorial_code/images/cat.jpg deleted file mode 100755 index df4a907e5f..0000000000 Binary files a/samples/cpp/tutorial_code/images/cat.jpg and /dev/null differ diff --git a/samples/cpp/tutorial_code/images/hand_sample1.jpg b/samples/cpp/tutorial_code/images/hand_sample1.jpg deleted file mode 100644 index 4c42898ec3..0000000000 Binary files a/samples/cpp/tutorial_code/images/hand_sample1.jpg and /dev/null differ diff --git a/samples/cpp/tutorial_code/images/hand_sample2.jpg b/samples/cpp/tutorial_code/images/hand_sample2.jpg deleted file mode 100644 index 8ca11f9fb1..0000000000 Binary files a/samples/cpp/tutorial_code/images/hand_sample2.jpg and /dev/null differ diff --git a/samples/cpp/tutorial_code/images/hand_sample3.jpg b/samples/cpp/tutorial_code/images/hand_sample3.jpg deleted file mode 100644 index bd339a00a0..0000000000 Binary files a/samples/cpp/tutorial_code/images/hand_sample3.jpg and /dev/null differ diff --git a/samples/cpp/tutorial_code/images/lena.png b/samples/cpp/tutorial_code/images/lena.png deleted file mode 100644 index 59ef68aabd..0000000000 Binary files a/samples/cpp/tutorial_code/images/lena.png and /dev/null differ diff --git a/samples/cpp/tutorial_code/images/yellowball.jpg b/samples/cpp/tutorial_code/images/yellowball.jpg deleted file mode 100644 index ac76e08ba1..0000000000 Binary files a/samples/cpp/tutorial_code/images/yellowball.jpg and /dev/null differ diff --git a/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp b/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp index c97ff9e864..133ada6edf 100644 --- a/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp +++ b/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp @@ -1,21 +1,23 @@ #include #include #include + #include +#include using namespace cv; using namespace std; int main( int argc, char** argv ) { - if( argc != 2) + string imageName("../data/HappyFish.jpg"); // by default + if( argc > 1) { - cout <<" Usage: display_image ImageToLoadAndDisplay" << endl; - return -1; + imageName = argv[1]; } Mat image; - image = imread(argv[1], IMREAD_COLOR); // Read the file + image = imread(imageName.c_str(), IMREAD_COLOR); // Read the file if( image.empty() ) // Check for invalid input { diff --git a/samples/cpp/tutorial_code/photo/seamless_cloning/cloning_gui.cpp b/samples/cpp/tutorial_code/photo/seamless_cloning/cloning_gui.cpp index 6edeb3eadb..6ca79a7a04 100644 --- a/samples/cpp/tutorial_code/photo/seamless_cloning/cloning_gui.cpp +++ b/samples/cpp/tutorial_code/photo/seamless_cloning/cloning_gui.cpp @@ -64,7 +64,7 @@ float alpha,beta; float red, green, blue; -double low_t, high_t; +float low_t, high_t; void source(int, int, int, int, void*); void destination(int, int, int, int, void*); diff --git a/samples/cpp/ufacedetect.cpp b/samples/cpp/ufacedetect.cpp index a4a027157a..1e08b3e718 100644 --- a/samples/cpp/ufacedetect.cpp +++ b/samples/cpp/ufacedetect.cpp @@ -111,7 +111,7 @@ int main( int argc, const char** argv ) else { if( inputName.empty() ) - inputName = "lena.jpg"; + inputName = "../data/lena.jpg"; image = imread( inputName, 1 ).getUMat(ACCESS_READ); if( image.empty() ) { diff --git a/samples/cpp/watershed.cpp b/samples/cpp/watershed.cpp index e57c5aa1cf..b92bbf1fd1 100644 --- a/samples/cpp/watershed.cpp +++ b/samples/cpp/watershed.cpp @@ -13,7 +13,7 @@ static void help() { cout << "\nThis program demonstrates the famous watershed segmentation algorithm in OpenCV: watershed()\n" "Usage:\n" - "./watershed [image_name -- default is fruits.jpg]\n" << endl; + "./watershed [image_name -- default is ../data/fruits.jpg]\n" << endl; cout << "Hot keys: \n" @@ -48,7 +48,7 @@ static void onMouse( int event, int x, int y, int flags, void* ) int main( int argc, char** argv ) { - char* filename = argc >= 2 ? argv[1] : (char*)"fruits.jpg"; + char* filename = argc >= 2 ? argv[1] : (char*)"../data/fruits.jpg"; Mat img0 = imread(filename, 1), imgGray; if( img0.empty() ) diff --git a/samples/cpp/waveform.data b/samples/cpp/waveform.data deleted file mode 100644 index 179e51af17..0000000000 --- a/samples/cpp/waveform.data +++ /dev/null @@ -1,5000 +0,0 @@ --1.23,-1.56,-1.75,-0.28,0.60,2.22,0.85,0.21,-0.20,0.89,1.08,4.20,2.89,7.75,4.59,3.15,5.12,3.32,1.20,0.24,-0.56,2 --0.69,2.43,0.61,2.08,2.30,3.25,5.52,4.55,2.97,2.22,2.81,1.61,1.24,1.89,1.88,-1.34,0.83,1.41,1.78,0.60,2.42,1 --0.12,-0.94,1.29,2.59,2.42,3.55,4.94,3.25,1.90,2.07,0.51,1.45,2.50,0.12,1.41,2.78,0.64,0.62,-0.01,-0.79,-0.12,0 -0.86,0.29,2.19,-0.02,1.13,2.51,2.37,5.45,5.45,4.84,4.65,4.05,2.58,1.40,1.24,1.41,1.07,-1.43,2.84,-1.18,1.12,1 -1.16,0.37,0.40,-0.59,2.66,1.00,2.69,4.06,5.34,3.53,4.82,4.79,4.30,1.84,1.73,0.21,-0.18,0.13,-0.21,-0.80,-0.68,1 --0.00,0.77,1.32,0.29,-1.28,0.84,1.60,1.55,2.93,4.76,5.55,4.30,4.89,2.81,2.37,3.68,-0.98,0.69,0.91,-1.80,0.39,2 -0.87,1.07,-0.65,1.46,0.84,2.70,3.67,2.94,3.81,5.20,8.16,3.29,4.24,2.43,0.40,1.60,0.72,0.66,0.05,-0.24,0.67,1 --0.22,-0.91,-1.18,0.35,-1.92,-1.59,1.91,0.75,1.72,2.02,3.63,3.91,2.73,4.29,4.89,2.04,1.13,-0.66,-1.33,0.41,-0.75,2 --1.11,-1.14,-0.89,0.00,0.53,0.44,0.24,2.15,1.64,1.75,3.92,5.68,3.39,4.24,3.81,4.56,3.18,1.51,2.90,0.14,-0.12,2 --0.75,1.10,-1.90,1.43,0.47,0.40,0.86,3.51,2.62,4.50,6.83,6.94,0.75,3.23,1.08,-0.25,0.73,-0.41,-1.50,0.46,1.47,2 -0.14,-1.18,1.42,2.28,3.10,3.15,3.49,4.54,1.40,3.41,3.40,2.83,0.06,0.60,3.61,2.08,-0.83,0.55,-0.55,-0.43,-1.05,0 -1.32,-0.40,-0.69,4.17,3.66,4.00,5.24,3.88,2.17,1.82,3.65,1.01,1.82,1.13,-0.07,0.26,0.50,1.38,1.25,-1.34,0.53,0 --0.93,2.48,1.20,2.97,2.91,3.57,3.68,4.19,3.22,3.53,2.46,2.17,0.77,0.52,2.42,-0.89,0.51,-0.39,0.82,0.14,-0.63,1 --1.06,0.59,1.01,3.33,2.05,3.20,4.70,4.21,4.73,2.22,2.67,2.79,2.05,-1.53,-1.54,0.37,-0.09,1.04,-0.08,-0.27,0.47,1 -1.86,0.37,-0.35,0.74,0.84,0.21,1.97,1.52,1.85,2.39,3.92,3.76,3.27,1.61,3.08,2.78,1.58,1.68,2.61,-0.91,-0.27,2 --0.51,-0.48,0.35,-1.67,0.26,2.45,-0.09,2.03,0.79,1.42,1.13,2.52,2.06,4.50,4.28,4.66,3.30,0.38,0.75,1.76,0.37,0 -1.16,-1.19,-2.26,0.63,0.32,1.51,2.11,2.58,1.03,2.01,4.04,4.55,5.65,2.74,3.12,2.67,2.01,4.12,-0.81,0.07,-0.96,2 --0.09,2.30,-0.43,0.36,0.11,-1.20,1.47,2.25,3.50,2.14,6.68,5.45,2.22,2.79,2.61,1.87,0.48,1.98,1.64,1.32,0.71,2 --1.43,-0.46,-0.52,1.45,-0.00,1.35,1.39,0.81,0.03,1.39,2.55,2.42,3.07,5.46,6.29,6.50,4.60,3.77,1.62,1.01,-1.86,0 --1.09,-0.22,0.11,-1.03,1.09,1.72,1.91,3.61,2.22,4.67,4.02,5.32,1.63,2.02,0.40,1.37,1.80,-0.59,-1.22,-0.10,-1.56,1 --0.95,-1.28,0.68,-0.31,-1.04,1.86,-0.13,0.16,-1.05,-0.24,1.47,2.30,4.23,4.70,7.40,6.18,3.00,3.84,2.33,1.28,0.08,2 -0.97,0.72,-0.64,-0.87,0.66,0.80,-0.47,0.55,0.57,0.30,1.97,2.48,3.13,2.53,6.35,5.24,4.37,3.77,0.47,2.25,-0.30,0 -0.31,-0.34,-1.32,-1.24,-1.28,-0.02,-1.80,0.11,3.29,3.63,3.32,3.75,5.93,5.41,4.94,5.15,2.07,3.62,1.56,0.05,-0.31,2 --1.57,1.23,2.03,2.07,3.88,4.71,4.44,3.76,5.00,4.49,3.59,2.05,1.83,0.64,-0.21,0.79,-1.42,-0.73,-2.04,2.65,-0.26,1 -0.39,0.93,0.19,-0.50,0.39,-0.58,0.13,0.85,2.63,3.32,4.41,4.24,3.59,4.06,3.42,2.33,2.04,0.83,1.16,0.81,0.91,2 --0.96,0.13,0.13,-0.70,2.89,1.26,3.48,4.36,0.59,2.37,2.02,2.62,2.75,2.60,3.66,3.06,1.41,1.09,1.25,-0.29,-0.41,0 -0.36,0.40,0.73,1.91,1.44,3.17,2.72,3.60,1.02,3.27,1.06,1.54,3.44,2.45,2.58,-0.48,1.02,-0.01,2.42,0.71,-0.81,0 -1.22,-0.19,1.38,0.16,0.14,3.07,4.07,5.37,4.33,3.96,6.73,2.16,2.83,1.27,1.57,0.73,0.80,0.15,-0.99,0.60,0.13,1 --1.07,1.18,-0.22,1.13,0.01,0.33,0.76,1.20,2.44,2.32,4.24,3.25,4.78,4.18,3.28,2.91,-0.04,2.57,0.91,1.46,0.39,2 -1.01,0.40,1.01,0.60,2.77,1.70,1.44,4.01,5.26,4.47,4.67,4.55,2.91,0.30,1.62,0.92,-0.46,0.51,1.43,-0.05,-1.80,1 --0.73,-0.31,-1.88,-1.40,0.46,1.44,3.38,2.93,5.07,6.01,6.30,3.41,4.52,4.66,1.06,0.65,0.29,1.26,-1.04,-0.72,-0.71,2 --0.47,0.46,4.50,3.10,3.39,4.79,6.43,3.70,4.09,2.03,0.87,1.78,-0.78,-1.88,-2.09,0.29,0.01,0.06,-0.76,1.50,0.50,0 -0.20,1.35,-0.74,-0.21,4.44,3.82,5.31,4.13,2.85,1.81,-1.38,1.08,0.65,-0.38,0.64,-0.38,0.23,0.75,1.05,2.09,-0.07,0 --0.84,0.96,2.33,4.86,5.01,5.57,6.62,4.60,3.42,2.86,0.31,0.53,0.20,-1.77,-0.41,-0.36,0.56,-0.15,0.26,-0.89,0.86,0 -0.34,1.39,-0.71,-0.03,-1.56,1.10,-0.10,0.95,0.91,0.96,3.23,2.56,2.90,5.67,4.88,6.35,2.10,2.03,-0.43,1.70,1.91,2 -1.66,-0.55,-0.40,-0.63,0.88,0.82,1.45,1.61,1.73,2.70,3.92,0.51,5.15,4.14,4.24,5.35,2.93,4.78,1.77,1.12,-0.94,2 --1.85,0.05,1.25,1.62,0.54,0.22,0.05,-0.19,0.32,3.64,1.91,3.03,2.77,5.21,4.89,3.30,5.68,3.59,0.98,1.46,-0.70,2 -0.93,1.48,1.01,-0.30,0.95,0.73,0.27,3.66,3.02,3.87,2.60,3.15,4.65,3.87,3.37,0.73,2.61,2.16,2.10,1.86,-0.03,2 --0.94,1.51,1.41,2.49,1.54,2.29,4.48,4.10,2.39,1.51,1.09,1.32,0.72,4.28,2.25,0.06,0.76,0.53,-0.01,0.98,-1.48,0 -1.72,1.47,2.62,3.11,1.14,3.17,3.93,4.51,3.11,3.96,2.69,1.27,0.48,1.47,2.20,0.79,2.05,-0.00,0.60,-2.16,-0.59,1 --0.67,0.49,0.55,-1.08,0.84,4.56,2.20,4.51,4.96,4.44,4.92,4.08,1.54,2.31,2.71,2.16,1.59,1.48,0.86,-0.14,2.03,1 -0.25,0.56,2.37,1.03,0.21,-0.72,1.73,0.34,0.64,1.84,2.98,2.30,4.71,5.47,4.83,4.21,2.42,1.78,1.69,-0.18,0.65,0 --0.78,0.02,2.51,2.81,2.37,3.17,4.55,4.02,2.87,3.02,1.45,1.29,1.22,1.22,-1.20,0.91,0.34,-0.32,1.47,-0.29,0.68,1 --2.80,1.05,0.18,2.46,1.19,3.40,4.22,3.53,4.36,4.60,4.28,3.56,1.80,-0.75,-0.00,2.31,0.99,-0.10,1.49,-0.71,1.59,1 -0.08,2.22,2.23,0.41,-0.21,2.27,0.78,0.11,3.39,0.57,-0.18,5.00,4.08,4.03,6.77,4.89,4.26,4.63,1.78,1.87,-0.10,2 -1.91,1.66,1.61,3.71,1.26,4.74,4.57,2.65,4.80,3.47,1.42,2.75,0.33,1.88,1.63,1.42,1.12,0.81,-1.30,0.85,-1.98,0 -0.46,-2.24,-0.01,0.68,1.01,2.45,2.31,0.52,1.40,3.52,2.97,1.87,5.68,6.38,4.48,4.96,0.66,1.91,0.88,0.45,-0.22,2 -0.60,-0.30,-2.65,-0.49,0.18,-1.13,0.22,1.48,3.13,1.90,2.91,3.86,4.04,3.76,3.69,2.70,0.46,2.11,-0.45,1.73,-0.61,2 --0.59,0.11,-0.90,2.62,5.15,2.82,6.70,4.69,5.16,3.29,3.26,1.24,1.65,1.99,-1.25,2.59,0.70,1.97,0.56,-0.51,1.90,1 --0.18,0.22,1.68,-0.98,-0.57,1.41,-0.66,0.21,1.69,2.01,2.17,2.11,4.98,4.81,4.42,4.10,3.65,2.80,0.44,-0.51,0.70,2 --0.80,0.75,1.73,1.09,0.71,3.20,1.87,-0.52,0.96,0.72,2.15,3.32,2.91,4.37,2.58,4.32,0.83,0.60,1.60,1.17,1.64,0 --0.17,-0.50,1.34,0.48,2.20,2.14,3.50,2.95,4.29,6.32,7.48,4.49,5.40,3.45,1.62,0.77,-0.38,0.46,-0.47,-0.05,1.60,1 --1.41,1.77,1.92,3.66,2.74,1.89,3.16,2.97,2.30,3.65,2.66,0.68,2.29,1.32,2.07,2.72,1.44,0.86,-0.00,-0.96,-0.18,0 -0.25,-1.88,-1.40,0.57,0.92,1.25,0.30,1.20,1.69,1.70,3.78,3.27,3.43,4.58,6.73,3.83,0.77,1.68,1.41,0.02,0.31,2 -0.42,0.46,1.63,2.56,3.17,4.02,4.41,5.08,1.83,4.73,4.16,3.88,0.64,0.57,0.31,-1.56,1.45,-0.61,0.02,1.30,-2.42,1 --0.61,-1.42,-0.93,-1.90,0.56,0.50,0.62,1.64,3.26,1.83,4.37,6.80,3.99,2.43,3.96,4.23,2.52,2.34,1.49,-0.93,-0.31,2 -0.50,-0.74,0.69,1.21,-0.47,1.26,1.35,0.32,1.78,1.95,3.35,4.37,3.82,2.05,5.28,2.65,3.04,1.67,2.44,0.52,0.53,2 --1.80,0.00,0.69,1.16,1.68,2.34,2.54,2.06,3.74,3.56,3.88,5.12,3.81,4.15,1.78,2.24,0.15,1.43,0.92,0.95,-0.21,2 -1.11,-1.25,0.16,0.62,0.90,0.18,0.64,1.88,-0.02,1.57,2.95,4.32,3.30,4.65,5.54,4.40,1.25,4.69,1.70,1.80,0.31,0 -0.16,0.95,0.32,1.58,0.95,1.30,2.71,-0.02,0.07,2.09,1.50,1.09,3.44,4.96,2.85,2.92,2.50,1.87,-0.01,3.13,0.58,0 -0.53,0.45,-0.12,0.22,-0.50,0.92,2.03,2.71,4.53,2.59,6.93,4.56,2.32,4.60,1.36,1.75,0.24,0.14,2.50,-0.90,0.06,2 --1.57,-0.68,1.36,0.55,3.18,1.99,2.46,1.30,-0.09,1.26,2.86,1.69,1.38,3.57,2.91,1.78,0.59,1.45,1.57,2.57,0.15,0 --0.20,0.41,1.57,-0.29,1.92,0.61,0.68,1.87,1.39,2.13,3.67,3.92,5.49,4.65,4.65,6.61,2.75,3.45,2.40,1.28,-0.14,2 -0.13,0.37,1.83,4.13,2.16,2.85,4.13,2.95,2.17,2.58,2.89,2.21,3.09,0.28,2.20,3.00,2.68,0.22,1.35,1.22,-0.03,0 --0.63,0.23,0.08,1.80,1.95,1.66,3.23,2.69,4.34,2.76,5.99,3.48,3.12,0.77,0.95,2.14,-1.31,-0.18,0.21,-1.14,0.76,1 -0.46,1.21,0.65,1.05,4.47,4.46,5.10,2.55,4.23,3.77,1.94,1.34,1.01,0.84,0.55,1.77,1.93,2.21,1.50,1.35,0.09,0 --0.03,0.87,0.97,-0.78,0.41,2.06,2.95,1.96,2.45,1.12,2.64,1.76,1.27,3.13,2.76,2.33,0.96,1.53,2.40,0.64,-1.45,0 --0.70,-1.25,3.31,2.24,4.60,2.67,5.56,1.96,1.91,1.38,2.71,2.69,1.36,2.48,0.24,2.42,1.05,0.97,0.12,0.47,-1.67,0 -0.68,-0.21,-1.23,-0.28,1.08,0.47,3.29,1.48,1.45,0.07,0.71,3.49,2.34,2.95,3.88,3.46,1.33,1.15,2.09,0.63,0.12,0 --1.58,2.09,1.38,2.14,4.06,3.92,4.74,4.37,4.93,1.20,1.65,1.80,0.53,1.89,-0.03,1.04,0.98,0.55,1.11,0.30,-0.19,0 --0.78,-0.38,-0.35,-1.00,0.37,1.72,1.42,3.55,2.94,6.02,7.17,5.13,5.17,2.41,3.24,-0.41,-1.02,0.71,-0.10,0.13,0.41,2 -0.26,-0.15,0.02,1.86,0.65,1.99,2.87,2.30,4.90,3.00,4.86,2.23,0.74,0.48,2.53,1.33,0.28,0.82,1.14,1.83,0.32,1 -0.38,0.65,2.83,1.74,2.58,3.79,4.67,4.82,4.89,4.10,2.15,2.19,1.60,2.19,2.54,0.44,-0.49,-0.26,0.36,-0.69,0.74,0 --0.02,-0.70,0.98,1.78,2.42,3.65,5.38,4.89,4.35,3.69,3.01,1.08,0.72,-1.40,-0.09,0.09,0.32,-0.21,-1.83,-1.49,1.12,1 -1.66,-0.02,-0.63,-0.00,-0.19,-0.03,1.90,4.74,5.17,3.09,6.10,5.10,4.14,2.61,3.32,1.56,1.39,-1.18,0.64,0.38,-0.56,1 -0.83,0.33,0.86,1.37,3.17,3.93,4.04,2.46,3.33,3.45,3.13,-0.90,2.70,1.74,1.28,1.73,0.98,0.96,1.13,-0.07,-1.27,0 -0.05,-0.46,2.11,1.94,-0.49,1.38,-0.39,-0.47,1.32,2.53,2.85,3.20,2.53,5.19,6.11,4.67,3.35,3.21,2.63,1.19,0.77,2 --0.41,1.48,1.83,3.34,2.29,1.52,3.99,4.97,3.42,5.05,4.72,1.09,1.21,2.17,1.30,2.04,-1.70,1.63,-0.26,-1.16,-0.05,1 -0.55,1.79,1.36,3.26,2.49,3.77,4.66,5.24,3.94,2.76,2.73,2.14,1.32,1.22,2.49,1.74,0.20,0.60,-0.28,0.40,-0.44,1 -0.52,0.29,-1.01,2.66,3.63,3.30,3.92,4.35,5.33,4.78,2.78,1.27,1.10,2.81,-0.19,-1.27,0.09,-0.67,0.94,-2.07,-0.52,1 --0.15,0.97,1.41,2.51,3.57,3.79,6.19,5.09,1.99,2.79,2.79,1.43,0.48,-0.80,1.54,0.91,1.51,0.97,0.59,0.03,0.50,0 -1.32,0.73,-0.86,-1.23,0.36,0.95,0.69,0.10,0.01,2.14,3.16,1.69,3.21,2.77,5.38,5.67,1.12,2.90,1.02,4.65,-0.90,2 --1.28,0.44,0.28,-0.30,2.41,-0.81,0.93,0.50,1.85,1.53,1.28,4.19,2.47,2.76,5.49,3.28,3.00,1.40,2.39,2.04,-0.63,0 --0.28,-0.11,-0.18,0.73,-0.74,1.32,0.43,-0.05,1.56,2.63,2.24,2.48,3.31,3.83,7.12,3.69,3.45,1.17,1.35,0.70,1.92,2 -0.51,2.16,0.87,1.81,-0.07,3.58,5.03,2.52,3.61,4.97,5.62,2.96,1.13,2.47,1.18,0.12,-0.35,1.00,0.17,-1.01,1.12,1 -0.66,0.83,1.29,-0.59,1.40,0.33,3.06,4.39,5.13,3.66,5.46,2.66,5.22,4.59,2.32,-0.30,1.33,2.16,2.17,0.05,-0.23,1 --0.57,0.61,0.61,0.48,-0.88,-0.38,0.81,3.13,2.79,5.24,4.54,5.49,4.87,3.15,2.14,1.88,1.59,0.81,0.23,1.66,-1.08,2 -1.15,1.16,-0.92,-0.02,0.86,0.63,-0.78,2.03,0.66,3.90,4.92,4.53,4.61,2.77,3.18,2.82,1.40,3.32,0.16,1.09,-0.76,2 --1.36,0.39,-0.71,1.50,4.03,4.61,6.23,3.01,3.63,3.54,4.01,0.69,1.29,0.83,1.25,-0.70,1.86,0.52,-0.63,1.90,-0.37,0 --0.40,-0.50,0.40,0.43,-0.43,-1.68,0.04,2.46,2.44,2.28,4.00,3.96,2.31,3.14,4.16,2.95,0.02,0.50,-0.32,2.79,0.45,2 -2.37,1.24,1.04,1.86,2.81,2.34,2.05,2.34,2.76,1.06,2.33,1.34,2.20,3.68,2.70,1.52,3.16,0.51,2.27,1.70,-0.79,0 -0.58,-0.18,0.97,2.94,2.35,3.19,4.18,0.68,2.31,2.65,1.63,2.06,1.79,1.62,2.04,2.82,3.27,1.42,1.76,2.12,0.18,0 -0.65,0.05,0.53,5.66,3.01,6.64,5.15,4.12,4.56,3.35,3.02,-0.53,1.26,-1.11,-1.57,-0.84,1.26,-0.22,-1.75,-0.14,0.39,0 -0.36,1.66,1.59,1.11,2.99,4.20,5.10,3.31,4.01,3.76,4.41,3.56,0.89,1.65,0.85,0.59,-0.69,0.60,0.20,0.64,-0.16,1 --0.61,0.10,0.48,0.08,0.29,3.30,2.18,4.83,5.02,3.19,5.01,2.65,2.25,2.59,-0.23,0.65,0.36,-0.33,1.49,-0.66,1.32,1 -0.96,0.28,1.14,0.87,-1.34,1.36,2.24,2.16,3.21,3.56,8.38,6.84,4.30,1.79,2.99,2.46,-1.25,0.62,-1.96,0.48,-0.28,2 -0.49,-0.12,-0.42,0.54,1.93,2.98,3.66,4.78,1.80,2.11,3.33,2.14,2.65,0.84,3.16,2.70,2.41,1.30,0.77,0.97,0.26,0 --0.31,1.49,0.86,0.36,3.01,2.81,3.42,1.63,2.30,0.89,0.62,1.72,2.32,3.16,3.85,2.83,1.75,1.71,0.21,1.28,0.78,0 --1.75,-0.77,-0.25,1.36,-0.70,0.76,2.84,1.15,2.16,-1.77,3.13,0.52,3.78,4.55,6.07,4.65,4.26,5.18,0.80,1.54,0.33,2 --1.20,1.14,0.01,-0.07,-0.48,1.63,2.70,0.24,1.49,1.11,2.87,4.98,4.76,4.33,2.20,4.01,2.60,1.24,-0.97,0.84,1.33,2 --1.17,0.42,0.06,3.27,1.24,2.11,2.86,3.14,5.32,4.45,5.71,4.64,3.08,3.29,1.62,0.57,-0.28,0.01,-1.24,-0.52,0.89,1 -0.62,2.03,2.53,1.19,3.24,5.13,5.51,5.25,4.80,4.86,2.64,0.92,-0.24,-0.26,0.79,-1.30,0.24,0.20,-0.73,1.36,0.93,1 -2.51,0.00,0.85,2.12,1.42,2.59,3.14,2.38,3.23,2.58,2.59,1.93,2.35,1.90,2.20,3.97,2.13,3.49,2.31,1.86,0.26,0 --0.82,-0.19,0.27,1.45,1.50,0.49,-0.88,0.74,0.40,2.38,2.07,3.24,4.84,5.42,5.67,4.68,4.96,2.56,1.36,1.32,0.12,0 -0.39,2.67,0.38,2.08,3.48,2.20,3.79,4.28,3.86,6.00,3.38,5.30,2.89,1.02,1.18,1.89,-1.76,0.46,0.40,0.51,-0.25,1 --0.82,0.14,0.17,0.81,0.18,2.40,1.87,2.61,0.23,2.52,2.30,2.67,-0.01,3.52,1.22,2.72,3.19,3.37,3.12,1.60,-0.33,0 --1.87,3.15,-0.08,0.78,2.66,1.62,4.64,1.59,2.65,-0.72,2.21,3.64,2.78,4.79,5.28,1.10,3.34,1.78,1.32,1.15,-0.71,0 --2.56,0.18,3.45,1.68,4.09,3.85,5.51,5.19,3.02,4.09,1.91,2.24,2.56,1.07,-0.97,1.20,-0.65,-0.68,-0.25,-0.71,0.65,1 --0.27,-0.26,2.37,1.79,2.48,3.46,3.16,2.99,0.62,2.06,2.24,2.87,2.36,0.44,3.42,-0.44,1.31,1.58,0.30,1.31,-0.20,0 --0.69,-0.87,-0.19,0.58,2.31,2.80,4.65,2.68,3.10,4.74,5.24,3.67,3.38,0.30,1.35,-0.02,-1.67,-1.33,-1.28,-0.47,0.66,1 -0.61,-0.46,1.77,-0.14,-1.54,0.64,3.73,2.81,2.75,4.78,6.39,5.63,3.18,3.09,4.21,1.15,-0.20,1.40,-1.42,-1.89,-0.75,2 --0.72,-0.01,2.10,1.42,3.22,3.18,5.91,4.89,4.16,2.93,1.67,-0.36,1.56,2.55,-0.02,0.42,0.46,1.59,0.11,1.51,-1.80,0 --0.68,1.57,1.30,1.09,2.93,3.20,3.93,2.08,4.01,3.37,3.05,2.25,2.10,1.24,1.12,-0.16,1.75,1.24,-0.12,2.17,0.98,1 -0.08,-0.27,0.38,1.11,1.29,1.05,0.11,0.77,2.61,2.65,2.33,3.81,2.56,4.45,4.82,3.30,3.18,3.33,0.73,0.17,-0.53,2 --2.52,0.11,0.38,1.98,-0.66,1.06,0.32,1.93,3.23,2.51,3.89,4.52,2.85,3.91,3.25,3.14,2.75,3.13,1.89,2.45,0.96,2 -0.68,-0.03,1.99,0.14,-1.35,0.05,0.52,1.25,2.01,2.46,1.73,4.17,2.10,4.78,4.04,3.31,3.45,1.00,2.30,-0.66,0.28,2 --0.83,1.43,-1.59,0.75,0.29,0.67,1.74,3.94,5.03,6.47,5.80,5.49,2.37,3.77,2.89,3.40,1.47,-1.16,-0.36,-0.04,-0.37,1 --0.05,0.59,1.44,0.10,4.25,4.25,4.13,4.05,2.52,2.94,2.05,2.24,0.37,1.32,0.16,1.60,1.41,1.18,1.56,-0.37,0.08,0 -0.09,0.96,2.55,4.53,4.35,3.15,6.64,4.79,4.24,3.57,1.47,0.95,0.61,0.42,1.13,1.36,1.19,-1.43,0.06,0.37,0.24,0 -0.77,1.89,-0.10,2.99,1.75,3.01,4.46,5.44,4.76,3.40,4.53,3.02,4.18,3.12,0.40,0.81,1.19,-3.19,-0.45,0.90,-2.61,1 --1.98,0.24,3.63,2.20,1.72,4.81,5.48,3.55,3.55,1.84,1.89,1.90,0.66,2.05,3.07,1.88,1.90,1.30,0.24,1.33,1.91,0 -0.88,2.71,0.26,0.02,1.03,1.73,2.08,3.31,4.33,5.97,5.40,4.19,4.20,4.14,1.82,-1.13,1.85,0.05,-0.21,0.56,-0.43,1 --2.01,1.38,3.15,-0.22,3.47,3.10,3.79,2.16,3.65,3.17,0.72,2.08,3.26,1.92,3.76,3.12,2.42,2.79,0.80,0.43,1.67,0 -1.12,0.42,-1.31,-0.08,0.01,0.47,2.48,1.76,1.66,3.73,5.05,6.68,4.68,5.16,3.30,0.41,0.58,-1.02,-0.22,0.68,-0.74,2 --1.10,-1.88,0.51,-1.04,0.59,0.47,1.64,0.16,4.27,3.84,5.36,5.28,2.16,2.72,2.47,0.07,1.94,0.29,-1.29,1.45,0.24,2 -0.71,2.71,1.82,4.07,4.94,4.04,5.71,6.08,3.56,3.66,4.21,0.55,0.33,-0.91,-0.29,-0.52,0.18,0.46,-0.51,0.50,-0.57,1 -1.56,0.24,-1.22,0.09,-0.53,1.41,1.44,3.50,4.03,4.80,4.88,6.36,4.25,3.35,1.23,1.75,-0.16,0.91,-0.38,0.75,1.54,2 -0.57,0.18,2.14,1.46,1.91,0.90,3.17,2.30,0.73,2.20,2.68,0.53,2.42,3.52,3.69,3.26,1.62,3.77,1.40,0.03,2.64,0 --1.32,-1.20,0.53,-0.55,1.50,1.98,3.63,3.60,4.16,5.06,4.38,4.19,2.05,1.09,2.70,1.43,-1.10,-1.21,-0.28,0.51,0.15,1 -1.09,-0.13,-0.81,0.56,1.35,0.33,-0.06,2.48,4.75,2.92,5.27,5.45,2.80,2.60,4.70,1.78,1.15,1.27,0.41,0.15,-0.05,2 -0.82,0.69,-1.22,2.28,1.71,3.50,3.76,4.00,5.63,3.37,1.66,1.94,1.39,1.93,0.68,-0.18,0.13,-0.20,-1.08,0.38,-0.06,1 -0.28,0.63,1.61,-0.98,-0.13,1.03,-1.43,1.60,3.49,3.35,5.01,3.22,4.90,5.22,3.65,2.95,3.66,2.50,1.12,0.11,-0.60,2 --0.15,2.14,2.24,2.05,3.22,6.64,3.96,6.34,5.18,3.21,2.57,2.00,-0.96,-0.44,2.24,0.27,-2.85,0.39,-0.03,0.56,-0.28,1 -0.60,0.10,-0.14,0.22,-1.43,1.17,3.52,2.21,6.55,5.02,5.42,6.23,2.66,2.66,2.79,2.69,-0.86,0.43,1.22,-2.12,1.21,2 -0.08,-0.49,0.71,1.11,-0.23,3.33,2.11,3.32,4.67,4.24,5.55,4.19,2.84,-0.34,1.86,0.66,-0.24,0.50,-0.83,-0.43,-0.13,1 -0.59,-0.76,0.20,-0.59,0.75,0.59,4.30,2.42,3.00,4.64,5.32,5.06,2.61,3.88,1.40,2.16,-0.02,0.89,0.19,-0.59,1.38,1 --0.50,-1.34,1.57,0.44,-0.40,-0.33,-1.20,0.30,1.16,2.71,1.06,3.41,5.26,3.74,4.81,3.72,2.67,1.71,1.73,0.04,0.42,2 -1.16,1.72,2.54,1.15,4.04,5.30,4.34,4.18,4.67,2.61,0.62,1.81,0.19,0.87,-0.14,0.72,0.93,-0.77,-0.08,0.74,0.38,0 --0.86,-0.72,-0.63,0.01,-0.26,-1.11,0.02,0.80,-0.19,-0.02,0.48,3.66,3.39,4.68,5.35,5.38,2.94,2.07,-0.10,0.41,-1.53,0 -1.51,1.37,0.53,-0.64,1.74,2.34,-0.26,2.12,0.11,3.81,4.84,4.72,5.59,2.92,5.48,2.08,2.08,-0.87,2.29,0.00,0.08,2 -0.36,0.74,-0.80,1.13,0.12,1.46,2.42,3.60,4.00,3.95,5.29,4.57,1.52,0.48,1.92,2.09,1.72,-0.34,-0.49,0.95,-0.53,1 --2.03,0.06,-0.17,-0.32,0.74,0.59,0.58,3.33,1.02,1.61,3.92,2.61,4.49,4.04,3.12,3.56,2.59,2.68,2.31,0.34,-0.37,2 --0.28,-0.40,0.96,0.87,1.70,3.45,4.67,4.61,6.03,3.54,2.62,1.39,1.18,3.81,0.29,-0.16,-0.13,-0.22,-0.67,-0.71,0.38,1 --0.15,-2.35,-2.02,1.30,-1.29,1.20,0.63,0.81,-0.77,3.50,3.69,2.23,1.86,4.90,6.27,5.50,1.46,3.11,1.53,-0.16,-0.32,2 --0.51,0.50,2.06,1.46,-0.09,1.97,3.13,3.39,6.10,4.67,3.60,2.44,2.07,1.43,2.18,0.70,-0.18,-2.39,1.28,1.24,-1.13,1 -0.79,0.22,1.49,2.36,3.48,2.95,3.56,1.90,3.71,3.64,2.18,3.97,1.42,2.90,1.76,1.10,1.29,2.45,-1.05,0.47,0.57,0 -0.42,-1.19,0.29,2.24,3.14,1.86,3.78,2.83,2.92,4.86,5.03,2.76,1.57,0.55,-0.09,2.07,0.46,-0.80,0.14,0.27,-0.06,1 -1.03,0.86,1.52,0.62,1.17,0.80,4.10,4.07,2.35,2.40,0.36,1.80,2.34,2.12,4.02,2.26,1.16,3.61,0.25,0.33,-0.20,0 --2.02,-1.17,-0.41,-0.41,0.03,1.36,1.97,-0.10,1.28,2.89,4.78,2.86,5.63,4.89,3.97,2.43,1.50,2.76,0.13,0.05,-1.24,2 --0.38,3.15,-1.61,1.81,3.03,3.24,3.15,3.25,2.41,5.26,4.09,2.54,3.59,3.18,2.49,-0.09,-0.09,-0.46,-0.46,-1.16,0.27,1 --0.20,0.57,1.40,1.54,3.76,2.92,4.43,3.76,5.14,3.00,6.02,2.36,4.51,0.86,1.28,-0.22,1.76,0.26,-0.19,0.12,0.40,1 -2.10,0.03,0.85,1.77,2.39,1.23,4.82,4.11,2.02,3.32,5.01,4.46,1.17,0.40,0.16,1.07,0.43,0.57,-0.29,1.64,-0.28,1 --0.23,0.39,0.82,-0.27,0.17,-0.25,2.70,2.43,3.96,4.01,6.30,4.97,4.49,3.73,1.88,0.65,1.06,0.21,1.50,1.38,1.65,2 -2.50,0.68,-0.20,0.02,2.07,-0.59,1.12,0.71,1.07,3.27,4.01,2.32,2.96,5.33,4.86,2.82,2.05,1.15,-0.31,0.66,1.96,2 --0.16,0.47,0.85,-0.57,0.50,1.83,2.03,1.61,5.16,3.97,7.89,5.56,3.72,2.42,1.23,0.55,0.77,-0.02,0.26,-1.02,0.77,1 --1.20,0.93,1.76,2.67,3.89,2.39,3.67,4.89,4.06,2.62,2.73,1.61,2.47,1.18,2.21,0.91,3.01,0.20,-0.63,1.44,1.29,0 -1.93,0.65,0.54,0.50,-0.47,0.65,-0.72,-0.90,1.11,2.15,2.75,3.66,5.37,6.06,5.40,5.14,3.84,3.98,1.71,0.33,0.33,2 -1.47,-1.08,1.98,0.91,1.01,1.25,2.74,2.17,5.25,3.76,4.67,2.97,2.19,2.95,2.11,0.76,-2.13,0.53,0.20,2.16,0.16,1 -0.14,0.65,-0.79,0.71,0.93,0.79,2.81,2.22,4.06,6.43,6.56,4.81,2.58,3.71,2.32,2.48,-1.76,2.34,0.23,0.09,-0.48,2 -1.03,1.29,1.47,0.39,3.09,3.51,5.46,6.32,5.08,4.48,-0.03,-0.29,-0.48,1.13,0.56,0.97,-1.05,1.03,-0.05,-0.86,-0.01,1 --0.14,0.38,1.34,3.57,2.93,4.58,3.67,2.82,3.15,3.80,1.70,2.58,-0.84,0.63,-1.00,2.16,0.87,0.69,-0.34,-0.12,-0.04,0 -0.06,1.10,-0.55,1.49,0.94,4.29,5.37,5.09,5.39,3.85,4.14,0.47,0.95,-0.36,1.59,0.08,-0.23,0.26,-0.41,-0.26,1.39,1 -0.56,0.65,1.17,0.80,1.52,-0.02,-0.32,-1.25,1.80,-0.07,1.83,4.37,3.79,2.84,6.07,3.79,2.48,1.72,2.06,0.77,-0.19,0 --0.38,-0.61,0.51,0.85,-1.10,1.02,-0.32,0.79,2.94,1.72,2.02,3.54,3.43,3.84,5.55,3.45,3.75,1.75,1.76,0.73,0.69,2 --0.75,0.45,0.06,1.21,2.98,2.04,5.44,3.18,4.33,2.92,3.04,2.59,0.71,0.26,0.89,0.22,-1.50,-1.16,1.18,0.51,-0.35,1 --0.64,-1.38,-2.45,-1.48,-0.25,-0.54,2.96,2.67,2.75,3.02,5.12,2.97,4.22,3.57,4.54,2.71,1.46,0.13,0.87,-0.56,0.40,2 -0.93,-1.39,1.24,1.24,-2.03,0.56,-0.42,-0.12,1.50,0.61,4.70,3.11,4.00,6.22,7.22,4.76,5.32,0.81,2.03,1.17,-0.75,2 --0.85,0.96,-0.70,-0.61,-0.67,0.01,1.85,1.64,4.17,2.52,4.54,3.57,3.52,4.92,6.22,1.49,1.88,0.09,0.46,-0.58,-0.85,2 --0.28,1.52,1.96,1.12,0.06,1.39,3.82,2.74,4.58,4.23,7.46,3.46,2.26,2.73,1.04,0.87,2.13,2.01,0.70,-1.50,0.19,1 --0.03,0.93,1.59,2.99,3.42,4.39,3.81,3.15,1.83,1.02,2.37,2.28,0.89,0.42,0.58,1.73,1.61,-0.70,1.19,0.49,-0.15,0 -0.40,0.29,-0.19,-0.46,-1.76,-0.26,1.72,2.26,0.31,3.17,4.12,4.31,4.07,4.25,1.13,3.95,2.41,0.41,0.62,1.02,-0.91,2 --0.03,2.54,2.62,2.44,3.41,5.67,3.71,6.12,3.09,2.68,2.22,0.83,1.69,0.43,-0.68,-0.12,0.85,0.32,-0.62,-0.24,-0.75,0 -1.74,1.49,-0.09,2.15,1.73,2.46,5.13,3.10,0.94,4.32,2.62,2.39,0.71,1.94,1.33,1.09,0.52,1.44,0.17,0.94,-1.68,0 --0.38,-0.09,-0.17,0.32,0.27,1.34,1.93,-0.92,2.02,3.64,2.10,1.69,3.67,3.69,4.74,3.13,3.06,1.25,1.22,0.85,0.50,2 --0.53,0.56,2.06,-1.11,0.43,1.05,0.92,0.71,1.11,0.76,1.41,2.54,5.32,5.38,5.77,2.04,1.65,1.39,1.42,0.19,0.28,2 -0.01,-0.90,1.22,0.31,-1.16,1.55,1.51,2.07,1.15,3.30,3.64,6.11,4.02,2.19,3.28,1.68,0.15,1.54,1.46,0.21,0.84,2 -1.47,-0.95,1.05,0.20,0.16,0.24,0.83,1.11,2.11,2.27,2.73,2.68,4.52,3.79,4.50,3.15,3.18,1.61,1.31,0.61,0.03,2 -1.98,-0.58,0.06,2.05,1.95,-1.45,0.45,-0.65,2.08,0.52,2.84,3.31,4.14,4.54,5.95,5.14,3.00,1.50,3.67,-0.60,-0.27,2 --0.62,0.75,0.20,0.48,0.89,0.98,1.85,3.40,3.76,4.47,6.78,3.69,3.29,2.07,1.47,1.54,-2.18,-1.56,-0.21,-0.41,2.10,1 -0.27,2.67,0.96,2.67,3.44,5.53,6.85,5.59,3.14,2.79,1.49,0.23,-0.13,0.35,0.92,-1.29,0.81,-0.04,0.20,-2.02,-1.57,1 -0.76,1.14,-0.18,-1.52,1.31,1.33,-1.13,3.87,3.76,5.35,5.83,4.79,3.72,4.54,1.61,0.85,0.07,0.06,-0.02,-0.17,-1.53,2 --0.67,1.67,1.55,4.06,3.58,5.12,4.88,3.94,4.76,3.84,2.58,1.61,1.51,0.74,0.81,0.85,0.09,1.20,1.44,-1.33,-1.26,1 -1.42,-0.14,0.61,1.17,2.70,1.35,3.66,2.17,1.65,3.00,3.70,3.19,0.66,1.95,4.26,-0.35,1.60,1.95,-0.70,1.17,-1.39,0 -0.19,-0.39,-0.96,0.09,2.04,-0.37,-1.30,1.19,2.95,3.59,1.89,5.61,2.85,3.97,5.30,3.68,3.61,0.64,2.65,1.93,0.36,2 -1.11,-0.89,-2.79,-0.41,0.59,0.15,3.55,3.48,5.43,6.22,5.21,2.81,3.61,0.62,2.58,1.02,0.50,0.16,0.33,1.72,1.36,1 --0.53,1.14,0.41,1.68,2.59,0.25,3.57,2.34,1.79,1.89,1.40,3.26,3.32,1.65,2.50,1.61,2.42,2.18,2.99,1.37,0.02,0 --0.94,1.39,1.69,0.60,3.45,2.99,5.45,4.05,2.39,4.87,3.18,0.35,3.02,-0.07,-0.95,-0.09,0.76,-0.59,-2.90,-0.72,0.26,1 --0.99,-0.48,0.99,-0.38,0.25,-0.07,3.08,2.28,2.70,5.66,5.40,5.19,2.96,4.58,2.87,2.07,0.84,1.24,1.87,0.21,1.25,2 -0.16,0.81,0.72,2.32,-0.26,2.43,4.33,3.89,4.25,5.60,3.89,4.37,2.82,1.99,0.65,1.96,0.38,0.44,0.83,1.86,0.65,1 -2.52,-0.32,-1.89,1.29,0.25,-0.26,-1.45,0.49,2.38,2.52,1.68,2.61,2.39,6.71,3.88,2.99,4.42,2.88,0.76,2.77,0.18,2 --0.79,2.45,0.70,0.20,0.54,0.61,0.88,3.22,1.53,4.12,6.56,4.69,3.91,5.31,2.53,-1.34,1.55,-0.73,-0.39,-0.34,-0.55,2 -1.96,-0.52,0.12,0.64,0.83,1.04,2.93,3.55,4.61,4.70,5.30,3.49,2.69,2.31,-0.05,0.01,-1.90,0.03,0.74,-2.09,0.47,1 --0.21,1.78,0.10,-0.36,1.20,2.75,0.68,3.51,2.00,2.27,3.51,2.72,2.56,2.11,3.73,3.45,1.64,2.62,2.88,2.10,-0.18,0 -0.25,2.29,2.25,0.82,2.50,4.56,4.39,4.96,2.99,4.19,0.91,0.74,0.23,3.16,-1.45,-1.22,-0.21,-1.40,-1.67,0.53,0.58,1 --0.71,1.57,0.26,-0.75,1.27,0.28,1.10,4.92,3.50,3.69,5.03,5.30,2.98,5.05,3.80,2.56,-0.98,1.17,-0.10,-1.80,-0.69,2 -0.16,1.43,0.74,2.47,0.81,0.99,2.54,3.63,2.56,1.09,2.56,2.99,1.04,3.61,4.43,1.94,2.16,0.11,0.99,0.24,-1.64,0 --0.76,0.51,0.82,0.83,2.20,3.88,4.26,3.97,3.61,4.50,3.39,1.21,2.22,0.12,-0.20,0.35,2.44,-0.43,-0.50,1.15,0.07,1 -1.27,-0.36,-0.15,3.61,3.10,3.13,6.50,2.48,2.65,3.96,3.37,3.68,0.59,0.39,0.33,1.08,0.52,-0.29,0.08,-1.59,-2.10,1 -0.97,0.97,1.69,1.92,4.20,3.22,5.18,2.77,2.43,3.46,-0.12,1.07,1.65,0.68,2.02,2.69,-0.02,1.49,-0.73,1.61,-0.19,0 -0.74,1.20,2.28,2.44,0.99,4.74,3.25,3.33,4.86,3.78,5.15,3.35,0.97,1.22,-1.16,-0.33,0.71,-0.68,0.81,-0.17,-0.14,1 --0.32,1.58,-0.91,2.38,0.50,0.67,-0.46,0.45,1.25,2.76,1.26,5.33,3.20,2.99,3.32,2.96,1.11,1.70,1.10,1.04,-0.36,2 -1.08,1.21,0.84,2.83,4.13,3.80,5.58,3.46,3.65,4.25,2.78,1.56,0.49,1.52,1.18,1.64,-1.63,-0.57,0.25,-0.52,1.00,1 --1.35,0.93,1.37,2.13,1.44,1.51,3.39,3.74,3.95,3.23,4.49,4.43,3.43,3.20,1.37,-0.46,-1.48,2.16,0.28,-0.45,2.36,1 --1.00,0.04,0.24,-0.39,-1.02,0.14,-0.26,0.51,-0.75,0.59,3.74,1.81,2.93,5.06,5.23,4.25,0.37,2.98,2.86,1.63,0.46,0 --0.62,-0.73,-1.33,0.57,1.24,1.26,2.26,2.70,2.00,1.58,3.32,1.62,3.04,3.31,4.42,3.72,2.27,0.92,2.04,-0.19,-2.13,0 --0.63,0.96,-0.60,1.58,-0.06,1.36,2.67,3.84,5.79,5.37,6.00,4.48,1.74,4.65,1.63,1.60,0.85,-2.67,0.50,-0.45,1.93,1 --1.82,1.99,1.33,2.37,2.53,5.14,3.51,3.69,4.71,2.12,2.23,2.81,1.21,2.43,2.92,0.85,1.43,3.11,-0.25,0.62,0.23,0 -0.57,0.23,3.42,2.97,2.68,2.61,3.67,1.95,2.61,2.91,1.45,1.18,1.20,2.87,1.24,-0.05,0.52,0.51,1.03,-0.23,-0.27,0 --0.98,0.67,0.09,0.88,0.91,-0.45,0.95,1.47,0.28,1.46,3.51,2.90,3.69,3.52,5.32,3.85,2.70,0.92,2.65,2.34,-1.05,2 --0.61,-0.73,-0.30,2.10,0.59,3.51,5.82,6.14,3.71,3.42,4.91,1.85,2.47,1.46,1.73,2.04,-2.09,0.45,2.07,0.58,0.32,1 --0.00,-0.30,0.33,1.77,-0.12,1.09,1.11,2.01,1.68,2.93,4.53,2.93,3.51,3.23,2.63,1.01,1.75,1.15,1.60,0.45,-1.19,2 -0.10,-0.10,1.60,3.49,4.42,6.39,5.44,4.98,3.87,2.34,2.42,-0.49,0.11,1.36,-0.58,-0.21,-0.49,-0.40,-0.40,1.58,-0.60,1 --0.48,0.28,1.19,3.06,4.61,5.92,4.69,5.65,5.79,1.74,1.85,1.08,-1.60,-0.46,0.26,-0.64,-0.61,-0.28,0.90,-0.62,1.17,1 --0.21,1.10,2.30,2.74,2.03,4.21,3.68,1.73,4.48,4.54,1.83,-1.04,1.45,1.95,1.74,0.20,3.14,0.62,-0.51,-0.24,-0.44,0 -2.23,-0.09,1.10,0.49,-0.50,0.30,-0.96,0.80,0.52,1.45,3.50,4.83,3.90,3.17,5.20,4.02,2.71,2.77,2.24,1.12,-1.28,2 -0.68,1.19,1.86,0.73,4.91,2.82,6.46,5.29,4.45,2.91,3.81,1.34,0.83,1.54,1.10,-0.52,0.23,-0.16,-0.75,-0.29,0.29,1 -0.65,3.40,1.86,2.36,3.22,3.22,6.83,3.59,4.24,3.14,1.68,3.12,2.03,0.21,1.58,-0.33,0.16,-0.59,1.41,-2.55,0.53,1 -1.91,-0.68,0.93,2.01,2.62,3.04,3.18,3.16,0.65,0.83,2.56,0.86,1.09,2.33,2.75,2.36,1.93,2.86,1.30,0.50,-0.86,0 -0.39,1.67,-0.35,2.28,0.82,2.52,1.30,4.00,3.73,4.19,3.82,4.66,1.31,3.91,3.66,0.29,1.52,0.72,0.14,1.62,-0.53,1 --0.54,2.21,2.91,3.18,4.54,6.26,4.96,3.52,6.88,2.19,3.82,1.51,1.22,1.74,0.81,0.02,-1.14,2.31,1.04,-1.11,0.26,1 --0.16,1.57,-0.64,-0.05,0.36,-0.04,-0.45,2.54,4.02,4.61,6.04,5.78,3.30,3.25,3.22,0.94,0.67,0.98,-0.31,1.16,0.38,2 --1.01,0.31,2.02,2.87,1.21,1.08,3.26,1.33,1.91,1.13,0.81,0.96,2.34,1.54,3.12,3.53,3.86,0.56,0.08,-0.16,-0.10,0 -2.08,-0.78,1.20,0.15,2.26,2.66,5.25,5.21,3.87,3.97,2.69,2.08,3.04,-0.40,1.57,-0.12,1.17,-0.63,-0.31,-1.39,0.20,1 -1.47,0.84,1.14,3.23,4.50,2.05,3.98,5.03,3.90,3.01,4.43,1.75,0.38,-1.08,0.36,0.75,-1.70,-0.38,-0.51,-0.51,1.41,1 --0.22,2.00,2.09,0.66,4.74,3.42,6.67,4.17,5.56,2.43,2.55,2.49,0.43,0.57,2.36,0.73,0.49,0.31,-0.79,0.74,0.41,1 --0.93,-0.23,-0.40,3.04,-1.71,1.80,1.58,0.97,-1.48,2.48,1.94,3.82,4.59,3.88,7.68,4.11,4.28,3.67,1.22,-0.03,1.06,0 --0.61,0.33,-0.15,0.53,3.37,1.33,4.13,4.74,3.40,2.82,5.11,2.95,2.78,3.04,-0.14,1.87,0.06,0.56,-0.36,-0.83,0.49,1 --1.51,0.13,-0.34,-0.18,0.36,-0.58,2.10,2.26,2.53,4.15,4.13,4.14,3.19,3.97,2.75,3.76,2.70,0.05,0.98,1.07,1.75,2 --0.29,-1.69,2.18,1.98,2.78,3.96,4.40,1.86,2.43,2.15,2.64,1.92,1.71,0.91,1.99,1.49,1.25,1.21,1.44,0.27,-0.25,0 -0.12,0.59,-0.72,0.14,-1.51,0.61,2.73,1.01,2.93,3.90,4.65,5.97,3.36,4.17,2.92,4.70,-0.06,0.75,0.95,-0.14,0.55,2 --0.01,2.75,1.20,-0.20,4.05,2.76,4.97,4.43,2.21,3.51,1.24,0.71,2.45,1.16,2.36,2.19,2.60,0.04,0.11,0.76,2.95,0 -0.46,0.30,-0.03,-0.03,-0.07,2.75,3.81,2.44,3.77,2.49,4.71,5.67,3.03,2.36,1.47,-0.36,-0.08,0.32,-0.70,-0.47,-0.48,1 --0.08,-1.16,2.75,2.20,0.06,1.94,5.98,2.30,3.61,2.79,4.23,3.06,4.62,-1.00,0.83,1.17,-1.00,-0.40,-1.22,-0.03,-0.06,1 -0.44,-0.42,1.08,0.23,0.69,0.81,0.55,-0.36,0.87,0.45,3.48,3.70,3.83,4.68,6.35,3.51,3.29,2.73,1.41,-1.01,-0.59,2 -0.37,-0.37,0.86,-0.93,-0.62,-0.57,2.14,0.69,2.69,1.99,2.97,5.59,4.53,4.94,5.63,2.84,0.91,0.67,1.50,-0.15,1.04,2 --1.76,-0.29,0.68,0.05,1.21,1.18,1.74,3.30,4.67,5.06,5.20,5.51,3.56,2.12,1.13,0.35,1.31,-0.13,0.05,-0.79,0.95,1 -0.54,-0.17,-0.46,-0.19,0.12,-0.61,1.87,2.85,2.34,4.39,5.62,3.97,4.34,1.56,2.16,2.97,0.05,1.79,1.33,-0.16,-0.58,2 --1.16,1.27,1.42,-0.60,1.09,0.35,0.27,-0.39,0.26,2.23,2.87,3.77,4.49,2.68,5.25,2.91,0.82,2.51,2.28,0.66,-0.60,0 --1.03,-0.20,0.94,1.09,0.99,1.66,3.42,3.06,2.70,5.57,5.08,3.81,3.47,2.05,1.28,-1.02,0.55,0.53,-0.86,0.99,0.12,1 --0.11,0.30,2.74,0.96,4.59,7.62,6.19,5.73,1.41,1.20,2.52,2.02,0.63,0.74,1.60,0.84,-1.23,0.70,-0.12,-0.62,0.98,0 -0.72,0.16,-0.13,0.79,0.01,-0.13,1.51,0.50,0.92,3.46,5.26,4.37,4.39,2.85,3.03,3.97,1.54,0.75,1.01,1.29,-0.23,2 -0.45,0.03,-0.96,-2.38,0.36,1.70,1.30,1.95,2.47,3.33,4.78,3.37,3.64,3.96,4.01,2.72,1.35,3.37,1.62,-0.12,-1.60,2 --0.02,0.79,-1.32,-0.17,0.95,2.31,0.12,1.00,0.26,1.69,1.72,2.97,2.20,4.61,6.44,4.66,5.46,3.55,1.55,0.67,0.27,0 -0.74,0.91,0.90,1.69,3.48,3.75,5.29,4.05,3.31,5.81,2.16,5.23,2.76,1.07,0.32,-0.85,1.70,1.45,-0.74,0.49,1.35,1 -0.55,-0.79,0.62,-0.34,-0.89,-0.47,0.76,2.69,3.58,3.18,3.57,3.95,3.03,5.44,3.49,2.55,1.30,1.91,1.30,1.50,1.47,2 --0.19,1.57,0.10,-0.54,0.12,1.19,2.21,-0.33,1.95,4.02,4.54,5.13,4.26,1.75,4.96,1.02,1.02,1.20,0.95,-0.77,-0.15,2 -0.08,1.83,2.13,5.75,4.72,5.40,5.86,5.09,3.76,3.34,3.72,1.95,1.17,-1.48,-1.32,0.76,-1.40,0.07,-0.68,0.32,-0.24,1 -0.79,0.86,-0.68,-0.92,-1.60,-0.11,2.09,2.18,4.40,5.69,4.87,5.55,5.16,3.20,1.73,0.24,1.39,-1.42,-0.25,-1.83,0.70,1 --1.28,1.03,0.38,0.67,2.87,0.40,2.42,1.55,2.24,1.13,0.56,4.12,2.13,3.23,3.27,2.22,2.82,-0.13,1.23,-0.82,-0.33,0 --1.25,2.03,-2.25,0.48,-1.13,0.84,0.22,4.18,4.45,4.50,5.95,5.29,3.82,3.47,1.99,0.64,0.71,-2.95,-1.72,-0.32,0.35,2 -0.67,0.59,0.26,-0.34,-0.19,1.07,-0.66,-0.02,0.76,2.57,4.75,3.89,3.34,3.67,5.66,3.81,4.23,2.11,1.06,0.27,0.58,2 --0.24,-0.73,0.12,1.46,2.68,5.14,4.40,3.02,3.53,4.94,3.57,2.69,1.15,0.84,0.96,-0.28,-0.73,-1.03,-0.49,0.68,0.05,1 --0.42,0.37,-0.18,2.25,0.42,-0.16,1.24,2.76,4.30,4.47,6.78,5.78,2.99,4.35,3.88,1.18,-1.37,0.52,-0.72,-0.13,0.77,2 -1.68,-0.38,0.32,0.90,-1.13,2.88,1.52,0.02,2.01,0.80,2.53,1.79,3.48,4.95,5.64,5.96,2.56,3.80,1.59,1.18,-0.79,0 -1.23,-0.48,0.70,0.06,0.51,-0.42,0.87,1.18,0.87,3.76,5.74,3.52,3.16,5.51,4.25,1.69,1.23,1.78,2.95,0.07,-0.33,2 -0.36,0.82,1.26,1.82,1.86,1.61,2.36,0.81,1.77,2.53,2.75,2.87,3.37,2.23,5.16,5.43,2.98,4.22,2.27,0.97,-0.86,0 -0.12,0.74,-1.08,-0.03,-1.70,-1.74,0.85,1.36,-0.83,2.39,2.52,3.42,6.13,4.18,7.16,1.99,4.58,4.24,-0.21,0.24,0.43,2 --0.91,-0.47,0.65,0.74,-0.24,-0.19,2.44,2.35,1.64,0.79,0.53,3.16,5.25,1.85,5.55,3.86,3.63,2.80,1.51,0.47,0.36,0 --0.88,0.51,0.51,0.64,0.71,-1.33,-0.20,0.48,0.51,1.66,1.32,4.89,3.38,5.64,5.27,5.89,2.71,3.92,0.23,1.15,-0.09,2 --0.63,-0.58,1.36,1.85,0.98,0.44,1.91,1.50,1.37,1.16,1.72,2.48,3.48,3.02,3.88,2.95,3.37,1.58,-0.74,2.03,-0.33,0 -1.23,1.31,1.16,0.07,1.66,0.65,2.01,1.79,2.31,2.91,3.18,4.34,4.07,4.51,3.61,4.02,1.00,2.45,0.09,-0.14,-0.78,2 --0.10,-0.07,-0.21,1.73,-0.68,-1.09,1.25,1.13,-1.66,2.26,2.61,3.30,3.36,5.06,5.91,6.05,1.19,0.42,3.33,2.30,-0.51,2 -0.55,-1.26,0.64,-0.93,-0.08,0.85,-1.05,1.45,2.21,2.16,4.50,3.62,3.28,3.04,4.12,3.66,1.50,1.44,1.92,1.49,-0.30,2 --0.68,-0.96,0.12,0.08,-0.34,1.02,0.43,3.65,2.84,2.72,4.83,4.98,4.65,1.29,3.54,4.38,2.42,1.92,1.32,2.05,-1.59,2 -0.25,0.70,4.14,1.24,4.36,4.93,5.60,5.50,4.58,3.51,-0.03,0.63,0.79,0.47,-1.11,1.27,0.24,1.82,1.10,-0.94,0.22,1 --0.19,1.21,1.95,2.82,3.37,4.26,6.37,3.41,2.18,1.90,3.37,0.13,1.83,1.88,1.01,0.74,0.24,-0.41,0.58,1.84,0.07,1 -1.51,-0.88,1.61,1.47,0.60,2.12,2.75,4.48,4.93,4.11,5.22,4.60,1.75,1.17,1.50,1.29,-0.96,-0.68,0.40,-0.25,-1.31,1 -0.89,-0.61,0.18,2.46,-0.43,1.13,1.35,3.04,4.48,4.17,5.15,4.53,4.62,4.37,2.27,1.75,1.11,-1.87,-0.37,1.67,0.59,2 -0.32,-0.78,0.47,1.65,1.42,2.76,3.20,3.20,2.43,0.32,2.67,1.94,2.57,2.27,2.24,2.83,0.45,0.84,-0.59,-0.29,0.32,0 -0.37,0.44,1.32,2.31,2.20,0.40,2.43,3.88,4.41,3.67,4.27,4.47,2.18,2.45,-1.28,1.36,-0.30,0.90,-0.51,0.31,0.01,1 --0.97,2.05,1.00,2.00,1.59,3.26,5.11,4.98,3.12,4.13,2.68,1.81,1.86,0.63,1.10,1.08,0.62,-1.02,-0.52,-1.76,1.26,1 --0.81,-0.36,3.08,3.45,3.41,4.99,4.51,4.04,3.60,3.24,2.67,2.83,-1.08,-1.22,-0.61,0.16,0.14,1.04,-1.89,0.81,-0.27,0 --0.81,0.20,1.88,1.45,3.47,2.96,5.51,4.42,4.52,2.51,2.71,0.91,1.96,-0.58,1.80,-0.68,-0.53,1.99,-0.42,0.18,1.29,0 --1.79,-0.05,1.03,3.34,3.51,2.05,4.07,2.24,3.71,1.54,1.41,1.30,-0.04,1.82,2.21,2.91,1.74,-0.17,-0.27,-1.56,0.44,0 -1.06,0.66,0.15,1.36,-2.14,1.62,-0.61,4.11,1.71,3.69,4.04,6.06,3.93,5.35,3.13,2.67,3.59,0.70,0.07,-1.09,-1.03,2 -3.31,0.29,1.60,-1.46,-1.16,1.06,-0.98,-0.87,3.22,3.17,3.21,2.53,5.38,2.65,4.88,4.89,2.67,1.46,0.79,-0.08,1.32,2 --0.71,0.15,0.85,-0.21,0.77,0.92,1.00,5.47,4.07,4.54,2.89,4.50,4.62,2.97,2.24,1.62,0.30,0.08,-0.09,0.81,-0.49,1 --0.83,-0.10,1.62,-1.39,0.78,0.06,1.99,-1.11,1.23,1.19,2.26,3.62,1.59,4.91,4.32,3.50,3.62,2.31,-0.45,-0.12,-0.16,2 --0.14,-0.26,-0.67,0.73,-0.13,1.05,1.49,-0.46,-0.33,2.23,1.02,2.91,4.70,4.84,4.21,4.16,2.52,1.41,2.13,2.46,-1.02,2 --1.60,1.41,-1.31,1.88,2.40,2.42,3.85,4.03,3.42,5.80,4.82,4.61,1.25,2.16,0.69,0.71,-1.28,0.51,-0.24,-0.04,-1.20,1 -0.59,-0.65,1.84,2.68,0.82,2.21,3.77,0.47,1.96,1.80,1.06,2.35,4.51,3.32,2.34,2.86,2.44,2.37,2.33,0.24,-0.82,0 -0.35,-0.29,-0.21,-2.05,-0.55,1.22,3.09,3.37,4.01,5.72,3.68,3.46,4.15,3.52,0.96,1.32,-0.40,-0.46,2.95,1.30,0.78,2 -0.91,-1.83,1.53,0.59,1.44,3.21,2.59,3.79,3.01,2.11,1.58,-0.72,1.88,2.47,3.66,1.41,2.80,0.36,1.58,-0.14,0.45,0 -1.90,0.24,1.22,2.24,1.92,1.18,5.09,3.67,1.42,1.78,-0.11,1.76,0.54,0.62,1.14,1.48,3.21,0.08,-0.48,1.36,-0.72,0 --0.73,0.33,-0.81,-0.26,-0.45,0.39,-0.70,0.76,2.02,1.37,2.20,2.85,4.67,5.25,6.76,5.24,3.61,1.99,-0.41,2.19,-0.57,2 --0.60,0.27,-0.21,0.65,1.10,0.68,1.91,0.85,-0.82,0.25,0.99,2.86,5.59,1.97,5.69,4.35,4.91,1.74,0.57,-0.46,0.44,0 -1.59,0.35,0.92,0.82,-1.63,-0.77,-1.31,1.38,0.87,1.55,1.04,2.89,3.56,4.77,7.41,4.27,6.61,2.47,2.01,1.36,-0.48,0 --1.10,0.48,1.25,0.36,-0.95,-0.75,0.61,3.21,2.79,1.94,3.89,2.91,4.18,3.14,2.12,2.91,1.90,0.15,1.26,-0.06,-1.52,2 -0.42,-0.37,-0.91,-1.92,0.38,0.46,1.36,1.74,1.96,3.70,6.82,4.77,4.60,3.89,2.46,2.39,2.46,0.28,3.47,-0.60,-1.00,2 --0.29,0.58,1.13,-0.92,2.32,0.41,-0.59,0.08,-0.85,1.17,2.70,3.60,4.11,4.38,4.87,2.44,3.26,2.66,2.28,1.23,0.61,2 -0.95,-0.79,1.64,2.23,4.72,2.83,5.75,4.06,3.47,4.63,2.89,3.08,0.33,0.16,0.67,0.20,-0.34,-1.11,1.58,0.68,-0.65,1 --0.99,-0.56,-0.06,-1.86,0.53,-1.72,1.05,1.92,2.27,2.90,4.87,4.31,5.09,3.62,2.72,-0.71,2.78,2.31,1.92,0.31,-0.61,2 --1.11,1.13,1.41,1.70,-1.69,0.86,1.19,1.57,2.49,3.56,4.17,3.94,5.09,3.78,3.87,3.68,1.42,0.44,0.97,0.96,1.48,2 --0.73,-0.15,0.19,-0.90,0.84,2.28,4.00,1.22,3.49,4.37,5.16,4.22,3.90,3.57,2.23,-0.69,-1.05,0.61,1.29,-1.12,-0.77,1 --0.40,0.52,3.01,2.40,4.43,3.41,4.21,5.09,2.93,2.61,1.15,0.79,0.36,2.20,0.61,1.91,-0.02,2.48,0.75,0.24,-0.08,0 -1.27,1.25,0.04,4.49,3.97,4.58,6.10,4.64,4.26,3.93,1.37,1.15,-1.04,-0.24,1.26,0.00,2.04,-0.29,-2.15,-0.16,0.00,1 --0.25,0.08,0.04,-0.27,-0.16,0.44,0.49,-0.43,1.31,1.93,3.25,2.51,5.14,3.14,5.20,2.36,2.61,2.87,0.53,0.43,0.20,2 --0.03,0.76,0.38,1.69,-0.69,0.80,3.00,2.11,3.25,6.14,4.81,3.56,1.66,3.01,1.22,0.36,-0.45,0.06,-0.06,1.38,0.54,1 --1.67,1.78,0.86,-0.51,0.75,0.32,0.93,3.55,3.84,5.44,5.58,5.37,5.41,4.99,3.84,2.92,-0.58,-1.44,-0.90,0.46,-2.07,2 -0.69,0.98,1.99,2.13,3.37,6.43,6.22,5.30,3.58,1.59,0.48,1.53,1.16,1.27,-0.07,0.24,0.25,-1.10,0.54,0.46,-0.03,0 -0.26,-0.13,-2.48,0.96,1.97,3.61,3.00,3.32,5.09,5.57,4.74,5.49,3.19,2.70,1.77,1.17,-1.01,-0.26,0.31,-1.24,0.17,1 -1.19,1.69,1.24,-0.69,0.20,0.79,0.15,-1.26,0.78,0.54,1.94,3.15,4.85,4.79,4.55,4.55,3.70,2.77,2.97,0.06,-0.21,2 -0.16,0.52,-0.30,0.96,3.66,0.43,1.74,2.48,1.46,0.36,0.78,2.29,2.56,4.24,5.15,2.98,3.27,2.60,2.98,1.01,0.07,0 -0.09,-1.78,0.87,1.50,3.21,2.98,4.59,3.90,2.92,3.66,2.45,1.54,0.13,1.47,2.90,-0.94,1.12,0.63,1.03,0.13,1.47,0 -0.51,1.02,-0.21,0.41,-1.22,-0.44,1.31,0.69,1.24,-0.07,3.29,3.63,4.53,5.30,7.01,6.56,4.38,3.14,1.14,1.41,-0.15,0 --1.65,1.39,1.00,2.58,1.21,2.56,1.71,1.85,1.67,0.47,1.01,2.46,1.31,3.58,4.13,3.54,3.67,2.43,1.16,-0.02,0.84,0 -0.43,0.62,0.45,0.98,2.51,4.62,6.21,3.13,1.54,3.68,4.03,0.99,-0.41,0.82,1.26,0.98,1.96,-1.15,-0.66,-0.28,-0.21,0 -0.07,2.13,2.11,-0.27,1.91,3.85,2.07,2.14,1.97,2.16,-0.12,0.87,2.15,1.80,4.64,2.92,2.15,1.22,3.65,-1.45,-0.55,0 --0.22,1.06,-0.72,-1.02,0.79,2.14,1.81,2.60,3.46,3.93,5.57,5.87,4.34,5.69,1.94,-0.29,-0.53,0.40,0.28,-0.63,0.98,1 --2.14,-0.08,-0.08,0.54,-2.75,1.47,0.72,2.82,3.31,2.02,5.74,3.89,5.87,3.39,5.23,2.87,2.93,1.11,-0.21,-0.42,-1.02,2 -0.20,2.53,0.59,1.96,0.15,1.87,3.57,-0.10,1.28,1.48,3.40,3.57,4.83,3.79,3.68,3.65,2.23,0.65,0.92,1.85,2.14,0 --1.90,-0.63,1.45,1.57,2.68,1.61,4.00,4.21,2.54,4.72,4.05,1.22,3.61,1.26,1.76,0.05,-0.08,-1.04,-1.70,-0.42,-0.47,1 --1.23,0.06,0.95,0.25,-1.13,2.59,0.72,1.10,1.99,1.17,2.25,3.67,4.62,6.77,6.26,5.78,4.54,2.88,2.11,-0.63,0.52,0 --0.41,-0.28,1.23,2.41,-1.49,0.02,0.18,1.58,1.17,2.15,1.79,4.72,4.54,3.41,5.55,2.90,2.00,1.97,2.09,-0.13,1.43,2 -0.46,0.67,-1.47,0.85,1.48,1.22,3.59,3.28,4.78,5.31,4.32,3.41,3.19,3.78,1.46,1.09,0.04,0.48,-0.27,0.27,1.62,1 --1.48,1.45,-1.07,-0.39,-0.16,1.04,2.74,2.33,2.05,4.75,6.38,5.76,0.83,2.06,1.26,3.44,1.66,0.10,-0.40,-0.50,-0.19,1 --0.51,0.47,1.31,0.05,0.88,0.41,2.76,0.90,0.50,3.33,1.12,3.23,1.70,2.04,5.80,2.98,3.15,0.44,3.11,2.84,-1.93,0 --0.40,-0.77,0.48,-0.44,1.01,-0.21,3.40,3.27,1.84,3.87,6.48,5.29,2.73,2.09,1.63,0.44,1.42,1.40,-0.17,1.33,0.01,1 --1.20,0.93,1.67,3.74,2.67,5.66,3.90,1.77,3.44,0.79,2.01,2.23,2.96,1.37,-0.02,1.85,-1.89,1.36,-0.11,-0.73,0.10,0 -0.07,0.06,0.83,2.18,4.38,5.63,6.98,4.79,4.33,3.67,2.59,0.47,-0.34,0.71,1.26,0.22,-0.68,-1.36,0.15,-1.53,0.50,1 --0.49,0.92,-1.58,-0.10,-1.81,2.28,0.41,-0.28,-0.94,1.45,2.14,3.08,4.49,5.60,6.41,2.35,3.73,3.46,-0.34,2.07,-1.53,2 --0.24,-1.56,0.91,3.27,3.97,4.47,4.95,5.65,3.26,2.13,2.96,3.31,1.25,3.46,0.12,-0.80,-0.50,0.54,-0.62,0.91,-1.13,1 -0.02,-1.22,-1.07,1.04,-1.58,1.33,1.03,3.79,3.75,5.23,5.82,4.45,2.88,3.29,4.66,1.24,-0.09,-0.61,0.53,1.45,0.57,1 --0.37,-1.37,0.14,-0.26,0.49,0.90,1.05,0.31,1.88,0.59,4.57,2.87,5.00,2.94,3.16,3.33,1.22,0.47,2.02,1.15,0.63,2 -0.61,-0.10,-0.53,-0.81,-1.10,2.35,-0.56,1.21,2.36,4.29,3.86,5.06,4.48,3.87,4.86,1.78,1.09,1.02,1.34,1.10,-0.79,2 -0.84,2.55,0.75,0.74,2.62,1.93,1.84,4.11,0.72,1.08,3.10,2.13,1.97,3.12,4.72,2.36,1.73,0.93,1.86,0.09,0.60,0 --0.70,1.88,1.93,0.42,2.28,0.22,2.05,1.32,2.90,0.58,1.41,3.08,0.99,2.18,3.17,3.93,2.03,2.83,1.31,-0.27,0.33,0 --1.05,-0.43,-0.13,-0.61,2.25,1.13,1.78,1.05,3.28,4.12,5.08,4.76,3.67,0.72,1.95,1.60,-0.17,-0.01,1.57,1.06,-1.36,1 --0.71,-0.43,-0.78,-1.02,-0.89,0.79,-0.37,1.45,1.80,3.60,2.61,3.54,2.12,3.71,4.85,2.80,2.06,2.03,-0.24,2.26,0.16,2 --1.61,-0.00,1.17,0.59,-1.59,-0.13,1.98,1.29,1.50,4.20,3.64,3.63,2.12,3.34,5.29,2.77,2.42,0.82,0.40,0.30,-0.59,2 -0.09,1.73,2.03,1.87,2.88,4.58,6.25,5.61,3.63,4.22,1.10,1.31,-0.14,2.40,0.90,-1.93,0.48,-0.26,0.95,0.51,1.25,1 -0.63,-0.82,0.49,3.51,1.97,1.86,4.30,5.42,3.59,3.72,2.70,4.35,2.19,1.77,2.32,1.10,0.49,-0.75,-0.07,0.15,-0.37,1 --0.17,0.03,1.01,-1.03,-1.08,1.22,1.18,3.08,1.54,4.47,4.01,3.26,3.13,4.00,2.39,-0.11,1.31,2.46,1.41,-1.73,-0.46,2 --0.71,1.80,1.52,-1.11,1.38,1.64,0.89,0.21,0.64,1.32,2.15,3.88,3.32,4.08,5.48,2.87,2.36,3.64,1.76,0.63,0.30,0 -0.86,0.19,0.09,-2.54,0.12,0.44,2.56,2.15,2.83,3.47,4.55,4.87,4.40,3.02,3.00,2.91,1.91,0.48,0.38,-0.05,0.86,2 --1.24,0.14,-0.62,-0.76,-0.33,0.49,2.19,2.92,3.81,4.92,5.63,5.53,2.43,2.03,1.73,1.81,2.04,1.69,-1.65,0.31,1.28,1 --1.10,0.83,1.86,-0.27,1.95,1.29,3.48,4.25,2.60,3.82,3.37,2.36,-0.54,1.47,2.70,-0.81,1.52,-1.58,-0.81,1.94,-1.57,1 --0.67,-1.12,-2.86,0.64,1.32,1.01,-0.59,2.00,4.05,2.45,3.39,3.64,3.65,3.02,4.75,2.77,3.29,1.01,0.90,0.85,-1.19,2 --0.08,1.80,2.73,3.10,4.00,2.37,4.94,5.52,4.40,2.86,1.75,2.52,2.02,0.38,0.39,1.97,0.61,0.88,0.67,-2.31,-1.75,1 --0.67,-0.40,0.55,0.92,0.92,0.74,2.42,0.08,1.46,0.56,1.96,1.14,2.48,3.04,4.82,4.27,3.66,2.18,-0.13,2.61,-0.87,0 -1.66,1.29,3.29,4.21,3.67,3.95,6.10,2.80,5.25,1.45,0.79,2.30,-0.62,0.15,0.57,-0.04,0.74,0.89,-0.03,-1.42,-1.76,1 --0.06,1.00,1.35,-0.64,0.98,2.95,2.18,4.40,2.78,3.63,5.15,1.18,1.82,0.97,1.84,0.42,1.76,1.26,2.34,-0.50,-0.57,1 -0.68,1.33,0.27,-0.00,-0.81,1.70,0.75,0.85,3.07,3.41,5.03,5.20,5.06,4.08,5.11,3.76,1.53,2.62,0.96,-0.70,2.47,2 --0.62,1.09,-0.55,0.54,0.52,1.24,0.37,-0.51,1.17,3.65,2.12,4.93,3.57,3.34,5.38,5.12,3.06,2.47,3.40,-0.23,0.26,2 --0.05,-0.34,-1.22,-1.05,-1.47,-0.30,2.37,1.73,3.83,2.53,3.62,5.79,4.19,3.71,2.00,1.02,-1.16,1.51,1.33,0.18,0.17,2 -1.01,2.75,-0.56,0.60,0.82,0.48,2.33,2.08,6.47,5.22,3.96,6.18,3.19,4.33,1.29,1.45,-0.48,1.51,-0.85,-0.64,0.51,1 -0.28,1.43,-0.28,1.65,3.11,3.36,5.49,6.04,4.03,3.97,3.06,1.45,1.68,1.18,-0.62,-0.09,0.82,0.52,1.30,0.85,-0.54,1 --0.35,0.98,1.07,3.52,3.14,4.20,5.41,3.76,1.02,2.41,2.70,2.22,1.07,1.91,0.60,1.27,0.85,1.12,0.42,0.42,1.08,0 -1.77,-0.44,1.07,3.49,0.72,2.50,2.81,3.38,1.69,1.14,1.36,3.15,2.76,1.64,2.19,2.51,0.70,0.15,0.03,2.13,0.25,0 -0.63,0.71,1.18,0.23,0.11,4.37,5.97,2.71,3.01,4.34,4.30,4.34,2.41,-0.64,1.23,2.33,-0.77,-0.47,0.42,0.07,-0.70,1 --0.40,-0.42,1.18,1.49,3.07,2.79,4.44,3.65,3.59,2.15,1.81,3.56,0.33,2.77,1.15,1.71,1.55,1.45,0.42,-0.15,0.34,0 --1.91,-0.19,-0.76,-0.01,0.11,0.92,-0.24,2.01,2.20,4.33,5.53,5.51,4.43,2.63,1.62,0.59,0.73,1.49,0.18,-0.90,0.96,2 -0.73,0.51,-0.07,0.57,0.65,1.28,-1.31,1.09,-1.86,0.55,1.64,2.62,3.30,4.16,6.17,5.50,4.38,4.47,2.14,0.33,0.06,0 -0.51,-0.41,-0.17,1.39,2.36,2.41,3.64,4.20,4.54,4.90,5.38,3.99,3.63,1.36,-0.44,1.94,-0.30,-1.05,-0.05,0.51,-0.91,1 --2.84,0.75,1.21,2.19,3.53,4.65,5.70,6.23,4.89,2.07,2.27,0.49,2.12,0.58,1.03,0.38,0.33,-0.41,-0.53,-0.49,-0.09,1 --1.72,1.04,1.77,3.57,4.21,3.52,3.44,4.13,2.21,2.71,3.78,2.24,-1.33,0.16,-0.50,-0.26,-0.49,-1.13,1.26,-0.40,1.54,0 -0.03,-1.45,-0.45,-0.63,-0.86,1.77,-0.44,-0.78,3.71,4.34,5.00,3.60,4.85,2.75,4.07,3.48,0.75,2.59,0.52,2.29,-0.10,2 --0.12,-0.73,-0.37,1.16,2.01,0.25,2.20,-0.07,-0.09,1.18,3.31,1.79,3.82,5.08,5.84,5.75,6.74,4.23,0.45,0.02,1.42,0 --0.81,-0.10,0.07,1.43,-0.02,1.79,3.65,2.57,2.59,2.39,1.01,1.61,1.64,1.35,4.03,3.67,2.87,2.77,0.33,1.39,0.51,0 -0.26,0.89,2.00,2.04,2.84,3.90,1.29,3.06,3.05,2.94,3.21,1.53,0.51,2.65,0.49,2.09,1.91,0.62,-0.96,-0.24,0.99,0 --0.88,-1.90,-0.26,1.66,-0.52,0.26,2.21,4.98,5.54,4.98,4.49,3.55,1.81,1.63,-0.63,0.63,-0.77,0.95,-2.14,0.62,1.10,1 --0.95,2.83,0.90,0.19,1.18,-2.06,0.60,0.30,-0.44,-0.47,0.64,2.68,5.47,4.46,6.35,4.81,3.63,3.09,1.40,1.64,-1.63,0 --0.20,0.49,-0.10,0.69,-0.10,-0.60,0.80,0.20,1.42,2.01,3.10,3.95,3.40,4.19,2.98,2.68,2.09,0.96,1.35,2.71,1.72,2 --0.76,1.04,-0.63,0.42,-0.82,-0.27,2.06,1.95,0.96,2.28,2.50,4.17,3.49,3.50,3.96,4.01,0.95,1.29,1.64,-0.24,0.36,2 --1.13,0.28,2.59,0.92,3.02,3.62,1.34,1.83,2.18,4.12,0.95,0.84,2.99,0.19,2.50,2.80,1.41,1.89,1.66,0.73,1.02,0 --0.11,1.49,0.75,1.90,3.53,5.70,4.04,2.27,0.35,2.20,0.11,0.79,-1.30,-0.71,0.55,0.88,0.82,-1.66,0.71,1.40,0.11,0 --0.50,1.62,3.09,1.12,3.36,5.30,5.34,4.79,1.58,1.90,2.85,-0.55,-0.24,1.26,2.05,2.32,-0.83,-0.85,-0.85,-0.94,0.12,0 -0.46,0.27,1.54,2.75,4.47,4.97,4.66,5.54,1.62,2.64,1.32,1.65,0.06,1.73,0.19,-0.74,-0.09,0.38,1.47,0.98,-0.37,0 --0.97,0.52,1.23,2.49,3.52,5.08,4.57,3.16,3.21,2.59,1.26,0.52,0.67,1.17,0.06,0.47,-0.19,0.04,-0.19,-0.84,-2.22,0 --2.06,1.10,1.98,2.03,4.15,3.11,5.82,3.20,4.28,4.49,3.06,1.26,1.33,1.67,0.92,-1.65,1.16,0.55,0.15,1.30,0.36,1 --0.59,-0.02,0.72,3.06,2.45,4.01,6.30,3.51,2.31,3.98,3.44,0.65,0.65,-0.05,1.32,0.12,0.50,-1.84,-0.07,0.45,0.31,1 -0.41,1.85,1.51,1.60,2.45,2.89,5.45,3.17,3.01,3.73,2.86,1.87,0.35,3.15,-0.30,3.09,2.48,2.66,0.62,0.09,0.93,0 -0.84,-0.63,0.86,0.57,1.17,1.61,3.44,3.06,3.25,3.33,6.04,3.23,3.33,2.75,1.24,2.16,0.39,0.14,-0.14,0.29,-0.96,1 -0.09,0.30,0.12,0.86,1.13,3.00,2.23,4.04,3.79,1.53,1.39,3.41,0.14,0.73,2.03,0.76,1.41,-0.66,0.41,0.78,-0.38,0 -0.72,-1.39,0.19,-0.73,-0.32,-0.02,0.15,2.65,2.40,1.27,6.34,3.65,3.13,4.37,3.18,2.32,0.52,1.45,-0.62,1.01,0.68,2 --0.18,1.38,0.91,2.57,2.25,3.61,2.78,3.70,3.15,3.79,0.95,0.68,0.75,0.08,3.71,1.01,1.53,-0.07,1.11,0.27,0.82,0 -0.74,0.22,-1.22,0.53,0.99,1.46,3.03,2.42,3.59,6.10,5.94,4.10,3.84,2.98,0.99,0.88,1.37,0.97,0.07,-0.88,0.66,2 -0.28,-0.19,1.95,2.01,2.54,4.64,3.90,3.63,2.11,1.48,0.49,0.66,1.17,3.08,1.82,-0.12,1.57,1.29,1.43,0.71,-1.47,0 --0.30,0.37,3.16,2.05,3.89,2.86,7.74,7.25,2.79,2.82,2.85,0.64,0.65,0.66,0.41,-1.15,-0.47,-0.71,-0.45,-0.45,-0.16,1 --1.17,-1.60,-1.60,-0.00,1.32,0.65,0.40,0.62,0.93,0.31,1.92,2.55,4.59,6.23,5.59,4.76,4.06,3.41,1.77,1.09,-0.23,0 -0.91,0.46,-0.32,-1.08,-0.81,0.00,0.79,3.93,3.33,4.01,3.49,3.46,4.04,3.27,4.25,2.89,2.07,2.15,-1.36,1.19,-0.52,2 --0.35,2.38,1.35,3.64,3.35,5.47,6.22,5.04,3.43,2.91,1.01,0.37,-0.73,-0.53,0.39,0.21,-0.71,-1.01,-0.79,0.34,-0.70,0 -0.09,-1.20,1.08,0.49,1.09,-1.30,0.77,-0.20,2.14,3.64,1.71,4.51,4.02,3.76,5.11,2.45,2.50,1.70,1.56,1.64,0.42,2 -1.56,0.26,-0.56,-0.45,-0.09,1.59,0.90,-0.54,-2.60,0.75,0.86,1.31,2.41,5.23,4.33,3.92,3.98,1.50,2.24,-0.81,0.95,0 --2.01,0.76,-0.16,0.27,-0.63,-1.14,0.55,0.78,1.06,2.98,3.02,3.62,3.29,5.42,4.08,3.57,5.27,4.00,2.28,-0.25,1.31,2 -0.15,-0.09,1.02,0.34,1.00,0.16,0.46,3.68,2.62,5.95,7.57,5.55,5.50,0.58,2.92,0.37,-1.25,-0.16,-1.60,0.47,0.19,1 -0.16,3.38,1.29,3.19,3.73,3.90,5.19,3.65,2.21,3.96,2.19,2.55,0.68,-1.22,0.47,-1.93,-0.04,0.01,1.42,1.48,-1.36,0 --2.95,0.22,-1.43,1.88,1.35,5.11,3.13,5.36,4.13,4.41,3.15,2.77,3.17,1.20,1.05,-0.94,-0.23,-1.39,-1.19,-0.62,-1.07,1 -0.07,1.73,-0.30,0.92,1.84,2.71,1.15,-0.23,1.73,2.13,3.33,3.11,4.10,3.91,4.31,3.20,2.71,2.54,2.23,1.14,0.76,0 -0.87,0.00,-0.51,0.05,-0.07,1.81,1.57,2.27,2.18,1.57,5.06,4.83,4.48,2.53,3.18,3.56,1.13,0.49,-0.09,0.31,0.72,2 --2.13,0.60,-0.51,-0.71,-0.74,-0.79,1.42,3.01,-0.37,2.58,3.92,3.11,5.12,4.17,5.00,3.74,1.94,1.83,2.92,0.80,1.84,2 -1.86,0.03,0.84,1.81,2.35,1.95,3.78,3.25,3.73,4.22,3.64,3.78,1.60,2.25,2.39,1.63,-1.35,-1.09,0.57,0.43,-0.31,1 --1.66,-0.13,1.12,1.53,3.71,2.42,6.84,6.06,2.33,2.07,2.91,0.67,-0.86,-0.02,2.30,0.37,1.50,1.11,1.31,0.61,-2.05,0 -0.61,-0.26,3.00,1.77,1.66,2.22,3.76,2.84,1.25,2.52,1.54,3.52,0.91,0.69,-0.29,0.96,0.27,1.00,0.16,1.46,-0.93,0 --0.86,0.73,0.89,-1.59,-1.45,1.42,2.07,2.61,3.57,2.31,4.74,4.73,5.69,2.52,3.21,-1.26,0.05,-0.08,-0.27,1.29,-0.22,2 --0.60,0.08,2.31,0.94,2.45,6.63,7.52,4.68,3.61,2.25,0.78,1.81,-0.08,-0.08,0.14,2.29,1.81,1.80,-0.81,1.26,0.70,0 -1.42,1.35,-0.14,-1.02,0.66,-1.49,1.65,2.59,4.11,4.11,5.16,3.60,4.51,1.99,1.83,0.49,2.90,-0.90,0.76,-1.72,0.84,2 -0.31,1.74,0.16,1.97,2.13,3.33,2.47,1.42,2.80,1.19,3.41,2.16,2.62,3.14,1.51,3.85,2.66,1.36,2.01,0.33,-0.04,0 --0.07,0.48,0.01,-0.91,0.51,0.93,-0.59,1.48,1.74,0.50,4.47,2.71,3.59,4.90,4.47,3.00,2.54,2.25,0.26,0.89,-1.58,2 --1.31,-0.43,1.57,-0.74,-0.22,2.15,2.18,3.03,4.33,6.20,5.80,3.84,2.43,4.49,1.13,0.20,-0.64,0.92,0.17,-0.57,1.58,1 --1.10,2.56,2.08,3.01,3.90,6.13,5.34,4.56,4.83,2.59,2.60,0.93,-1.05,-1.71,1.02,-0.42,-0.46,-0.28,-0.08,-0.81,0.77,0 -0.21,1.25,0.04,0.34,0.40,-0.10,-0.01,0.07,0.40,1.33,1.59,3.57,2.86,6.60,6.54,3.94,2.26,3.44,0.42,0.25,0.61,0 -0.20,1.35,1.44,2.29,0.79,3.52,3.91,4.18,3.88,4.44,4.16,1.16,2.08,0.25,0.39,0.49,0.23,-0.32,-1.17,0.71,0.64,1 -0.94,1.27,1.53,-0.15,1.48,4.42,1.82,6.19,4.28,4.95,3.50,4.50,2.06,1.19,0.83,-1.08,-0.52,0.99,-2.08,-0.46,0.01,1 --1.19,0.58,-0.72,-0.99,0.92,1.74,0.17,3.54,3.79,4.23,5.28,3.68,4.37,2.69,1.19,1.29,0.74,-0.58,0.81,1.04,-0.87,1 --0.01,-1.21,0.61,-0.02,0.38,3.04,3.31,3.84,3.47,6.62,3.80,4.45,3.98,1.11,0.24,0.67,-0.84,2.49,0.33,0.95,0.61,1 --0.33,-1.88,-1.13,1.78,1.25,0.78,-0.03,0.59,-0.74,1.73,0.94,3.07,3.32,4.85,4.37,4.07,3.71,3.32,2.52,-0.85,-0.54,2 --0.64,0.47,1.24,-0.05,-0.08,0.91,0.92,1.77,0.19,2.57,2.63,3.91,3.88,5.56,5.37,3.20,2.13,1.78,1.11,1.38,-0.52,2 -0.36,-0.21,0.46,-0.23,-0.24,-0.01,-0.71,0.59,-0.52,2.86,2.24,3.49,4.05,5.00,3.21,4.50,1.38,1.42,1.16,0.68,-0.29,2 -1.67,1.70,0.39,-0.28,0.85,0.39,3.66,5.51,2.54,4.47,5.18,1.05,1.65,2.10,0.23,0.65,-0.79,0.17,0.27,0.62,-0.32,1 --0.80,0.40,-0.16,1.39,0.54,2.86,2.12,2.42,0.82,3.31,-0.34,2.87,4.23,4.84,6.34,3.76,1.52,1.71,2.50,0.57,-1.53,0 --0.88,0.45,0.01,-1.89,3.25,-0.36,0.69,-0.47,1.26,0.98,2.28,3.07,3.46,4.77,4.30,4.72,3.19,1.65,0.88,0.86,-1.80,2 -0.58,-0.24,0.24,-0.75,-1.41,1.07,1.78,3.54,1.97,3.02,2.46,2.12,3.56,2.78,4.16,5.30,2.85,3.00,1.63,1.79,-0.98,2 --0.03,0.14,2.00,3.27,0.34,2.14,2.02,1.22,1.82,0.47,4.74,2.33,2.28,2.63,3.81,1.69,2.82,2.03,1.30,-0.67,0.57,0 -0.18,1.25,2.09,0.72,1.22,2.69,3.77,3.21,6.49,3.71,3.72,3.42,3.62,0.35,1.69,1.23,0.22,0.16,-1.07,0.73,-1.02,1 -0.43,-0.60,0.15,-1.02,-0.28,2.95,3.55,2.02,3.16,4.90,3.49,5.97,5.00,3.39,2.88,1.21,1.55,0.45,1.45,-1.23,0.32,2 -0.80,-0.43,0.57,-0.21,0.79,0.81,1.81,-0.65,0.84,1.12,2.69,2.79,3.38,5.35,5.28,3.25,5.05,2.24,2.05,0.56,0.81,0 --1.04,0.59,1.07,-0.39,0.46,-0.92,1.43,4.87,4.33,6.03,4.70,5.71,2.75,2.61,2.68,1.54,1.44,-0.62,-0.25,1.47,-0.39,2 -1.31,-0.25,2.02,-0.27,0.92,-0.82,-0.75,1.76,-1.13,1.29,1.93,3.09,4.78,5.07,5.00,2.97,4.80,3.70,3.30,1.29,-1.06,2 -0.29,1.66,0.33,0.97,1.72,2.57,2.61,2.01,1.19,3.02,2.56,2.37,0.93,1.40,2.72,4.01,2.11,1.81,0.51,-0.25,0.55,0 --1.61,-0.29,1.24,2.58,3.28,2.94,4.13,4.52,2.56,1.88,2.84,1.94,1.79,-0.14,1.86,0.46,-0.36,0.23,-0.09,0.05,2.40,0 -1.01,1.25,1.59,0.86,1.65,2.51,3.98,4.47,3.43,5.26,4.47,3.10,1.60,1.43,0.10,1.63,-1.15,1.73,-1.53,-0.13,-1.68,1 --0.22,-1.58,-0.18,0.46,0.54,0.93,1.70,-0.27,1.33,0.24,3.13,3.49,2.67,2.56,5.88,2.91,2.79,1.61,1.97,2.36,-0.76,0 --1.74,0.98,2.28,1.64,1.74,6.35,4.11,3.80,3.80,3.61,1.89,3.43,0.78,0.59,-0.69,-0.31,0.29,0.76,-0.60,-1.44,1.43,0 --0.42,0.42,-0.43,0.60,-1.05,0.34,1.75,0.71,1.09,-0.79,1.17,5.27,3.49,3.54,4.50,4.08,3.38,2.72,0.21,2.36,0.83,0 --0.11,2.26,0.23,-1.10,-2.40,1.97,2.00,3.45,3.65,4.96,5.88,4.77,1.84,2.69,1.56,1.28,-0.31,1.93,0.42,-0.04,-1.07,2 -0.90,0.26,1.19,1.08,3.97,3.40,6.14,4.82,3.67,3.38,3.05,1.16,0.21,1.32,0.18,0.26,0.08,1.96,0.02,0.18,-0.16,1 -0.10,-0.14,0.41,0.05,0.64,1.45,-0.41,-0.21,0.07,0.96,2.69,0.25,3.03,1.95,4.40,4.65,4.97,0.84,1.43,2.76,-0.78,0 --0.64,1.04,0.98,1.59,1.70,1.95,4.82,1.72,4.82,2.46,4.39,4.01,2.63,2.54,0.45,1.51,-0.82,1.15,2.60,-0.99,0.17,1 --0.95,0.49,1.01,-1.76,-0.54,0.37,1.15,-0.66,0.73,1.46,2.04,2.04,4.05,4.19,7.38,5.78,5.80,4.35,1.59,2.63,0.17,2 -0.40,0.09,-0.13,-0.07,2.09,2.28,2.21,1.75,1.95,0.82,-0.19,2.39,3.25,3.51,4.30,4.77,3.11,1.96,1.73,0.52,-1.31,0 --0.50,0.52,-0.94,2.29,0.46,0.44,1.58,3.03,3.70,3.41,4.13,3.48,2.28,2.88,1.82,0.85,0.08,0.04,0.09,-0.03,1.27,1 --1.18,1.94,0.02,3.15,4.62,5.18,6.21,4.26,4.88,1.52,0.71,1.01,1.14,-0.66,0.57,0.59,1.01,0.59,0.26,2.29,-1.69,0 --2.55,0.64,0.10,0.75,1.05,2.26,3.05,3.05,3.33,3.42,2.79,1.69,3.21,1.74,3.14,1.41,2.31,1.01,-0.18,0.79,-1.35,0 --0.46,-0.62,1.18,2.84,2.27,5.11,5.06,3.43,4.26,3.72,2.04,-0.79,0.39,0.68,-0.75,0.47,0.44,0.19,0.49,0.12,1.47,1 --0.16,0.79,-0.01,0.17,-0.90,-0.03,0.36,1.42,1.65,3.77,4.04,3.60,2.44,4.48,5.12,3.46,2.65,2.43,0.28,1.91,0.34,2 --0.57,-0.57,0.29,2.54,0.82,3.68,3.33,3.68,4.84,3.39,3.08,3.57,1.37,0.08,0.87,1.73,-0.90,-0.75,0.88,-0.35,0.84,1 -2.85,-1.73,1.03,1.57,-0.30,1.99,2.04,-0.15,0.93,2.85,3.39,4.61,5.12,4.87,4.20,2.60,2.15,0.73,1.90,0.42,0.35,2 --0.52,2.01,2.39,4.21,3.57,4.13,6.00,4.77,6.54,3.34,3.17,3.50,1.08,0.19,-0.68,0.07,-1.22,0.03,0.89,0.94,-1.11,1 -0.28,0.42,1.03,1.04,-0.31,1.58,-0.15,-0.18,0.85,2.16,0.90,0.71,3.43,6.82,5.30,4.90,3.87,2.13,1.83,1.05,-1.06,2 --0.08,-0.16,-1.09,0.06,1.86,0.60,0.46,1.78,2.71,4.96,4.94,5.57,3.29,2.61,2.63,2.20,1.76,-0.12,0.64,-0.55,1.07,2 --1.99,-0.94,1.58,1.48,1.66,2.10,2.55,1.89,0.39,1.59,1.27,2.61,-0.66,3.42,2.75,3.11,3.86,2.15,0.60,0.66,-0.59,0 -0.82,1.43,2.18,2.10,3.16,4.66,4.20,5.64,3.15,3.91,1.67,1.06,1.87,0.40,0.62,-0.67,0.99,-0.42,2.06,-0.38,0.97,0 --1.97,0.71,0.46,-0.60,2.79,2.63,2.84,4.40,3.13,1.98,-0.06,0.93,0.58,2.47,-0.27,1.46,0.65,1.65,0.35,-0.21,0.81,0 -0.60,0.20,0.09,0.30,1.46,3.99,4.12,4.03,4.54,4.47,5.10,4.49,1.62,1.23,1.17,0.76,-0.23,-0.80,-1.70,-0.27,1.42,1 -0.57,2.50,0.87,1.84,2.72,4.53,4.27,3.69,2.84,3.13,2.33,-0.15,1.53,1.24,1.77,0.62,1.42,0.42,-0.15,-1.25,0.58,0 --0.53,-1.98,-0.77,-0.18,0.06,0.44,1.75,0.02,1.50,4.72,4.28,4.89,5.50,5.48,4.29,4.76,3.01,3.16,0.91,0.86,-1.24,2 -0.50,-0.73,-1.06,-0.08,1.39,-0.33,1.13,-1.50,-0.49,0.41,3.04,2.40,2.27,3.97,5.83,4.64,5.30,3.02,3.01,1.10,0.70,0 --0.00,1.46,0.17,-0.15,0.89,2.05,2.38,3.30,2.75,1.49,2.89,3.18,2.67,3.87,0.60,2.08,4.81,0.67,0.27,3.19,2.04,0 --0.13,-0.36,2.00,2.33,5.48,2.57,3.24,4.77,4.90,2.15,1.12,3.49,1.72,1.84,0.42,0.25,1.96,2.60,-0.26,-0.44,1.13,0 --0.78,0.84,2.53,1.91,1.02,2.49,3.16,1.95,1.64,-0.14,-1.48,1.69,1.69,2.48,4.23,4.36,1.77,1.99,2.47,-0.75,-1.00,0 -1.04,0.13,2.29,2.31,2.39,1.94,5.73,3.89,2.57,2.48,1.75,2.03,0.14,2.72,2.01,0.76,0.98,1.01,0.04,-0.56,-1.35,0 -0.19,0.38,2.21,1.85,0.35,-0.44,1.83,4.35,2.88,4.04,7.01,4.40,4.65,4.15,3.11,1.09,2.20,0.43,1.45,0.83,0.40,2 -1.14,-0.25,1.49,-0.90,0.16,0.86,1.07,3.43,3.60,5.30,5.80,5.34,5.37,4.44,2.16,1.83,1.79,-0.43,-0.94,-0.60,-0.24,2 --1.20,0.63,1.57,0.58,1.85,-0.18,2.09,1.48,0.68,1.61,2.71,1.12,3.52,3.19,3.93,3.56,2.24,0.79,0.61,2.32,0.52,0 -0.56,-0.31,2.92,-0.29,1.70,2.84,3.88,3.65,4.24,3.65,5.26,3.10,1.85,1.20,0.35,1.51,0.30,0.99,0.47,-0.23,-0.59,1 --0.56,1.25,2.74,1.25,2.76,3.09,3.19,5.03,4.20,5.05,2.69,3.96,1.48,-0.83,-0.73,-0.05,-0.30,-1.30,-0.21,0.19,-0.93,1 -1.48,-0.48,0.15,-0.98,0.56,0.86,0.31,1.95,2.16,3.80,3.61,4.76,3.40,3.28,3.22,4.22,2.30,4.14,0.85,2.83,0.81,2 -0.56,0.18,1.00,0.49,2.49,-0.66,0.36,0.43,0.13,2.01,-0.08,1.67,3.56,3.97,5.59,3.33,2.80,2.36,2.35,-0.29,-0.95,0 --0.63,-0.34,-1.44,0.15,1.04,-0.05,0.12,1.28,2.51,3.33,4.53,3.75,3.59,6.15,4.41,2.66,1.01,0.84,1.25,0.81,0.31,2 -0.89,0.16,0.35,2.58,3.95,3.88,3.00,2.83,2.15,1.46,3.05,3.18,1.91,0.63,0.86,0.41,1.58,2.92,0.57,-0.18,-0.68,0 -1.14,0.62,0.99,0.91,-0.31,3.40,2.77,2.80,4.94,3.13,7.17,3.69,3.55,0.57,2.54,1.10,0.97,-1.90,2.08,0.64,0.75,1 --0.87,0.79,1.40,-0.08,2.37,3.18,2.80,6.67,4.41,3.41,3.34,4.61,2.16,2.12,0.18,2.48,-0.13,1.54,0.45,0.77,1.25,1 --0.36,1.11,1.24,1.45,1.53,3.71,4.97,4.01,2.81,2.50,1.38,2.90,0.53,1.05,1.20,1.57,1.32,-0.92,2.36,0.98,-1.63,0 -1.31,0.71,0.13,-1.85,0.61,1.80,1.65,2.51,2.28,4.06,3.55,5.77,3.48,1.73,4.34,1.65,1.10,0.81,-0.15,0.60,0.60,2 --0.84,-2.25,0.41,-0.70,-0.66,1.37,1.44,1.07,4.63,3.31,3.27,3.58,4.90,3.36,2.97,2.92,-0.60,2.16,0.45,1.26,0.73,2 -1.47,0.24,2.17,0.84,1.73,2.41,4.14,4.43,4.49,4.71,4.63,3.12,1.46,1.11,1.86,-1.35,0.39,-0.07,-0.27,-0.99,0.54,1 -0.69,-0.06,0.69,1.70,1.37,1.11,1.51,0.81,0.32,1.90,3.48,1.40,1.41,1.32,5.20,4.61,1.76,0.17,0.42,2.73,0.56,0 -1.26,0.33,1.46,1.14,3.89,3.51,2.18,1.89,3.55,2.14,2.92,3.52,1.22,1.41,2.60,4.82,1.00,1.45,1.72,0.04,-0.26,0 --1.90,1.48,2.08,3.02,2.17,1.30,2.47,1.78,4.10,2.26,2.46,1.86,2.53,3.75,2.27,1.87,3.95,1.20,3.76,0.11,-1.12,0 --0.66,-0.55,0.02,0.62,-0.50,3.01,1.26,3.24,2.93,5.64,4.59,5.28,5.42,2.80,3.20,3.10,1.84,1.80,0.19,-0.83,-0.71,2 --0.23,-2.67,-2.30,0.64,-1.31,-1.51,1.12,3.11,2.28,4.82,3.94,3.62,4.44,3.16,2.83,3.12,0.29,1.28,2.02,-0.27,1.44,2 --0.41,0.64,0.39,1.16,3.50,1.65,4.49,2.27,1.85,1.99,1.45,1.46,1.36,4.00,4.40,3.35,1.62,0.99,2.05,2.19,0.69,0 -0.92,1.23,4.58,3.71,3.85,5.22,6.01,3.97,4.83,2.15,1.88,-0.05,1.22,0.99,1.33,-1.04,0.16,1.23,-1.16,1.05,0.78,0 --0.54,-0.73,-0.54,1.81,-0.72,1.23,-0.24,0.76,-0.57,3.28,4.52,4.93,3.83,3.41,3.75,4.63,3.19,3.33,0.25,1.36,-0.32,2 -0.43,0.14,2.58,1.75,1.25,3.52,3.61,4.63,5.41,2.38,3.25,2.85,2.28,0.01,-0.33,-0.47,0.89,0.36,1.08,-0.76,0.94,1 --1.22,0.76,0.34,1.19,-0.99,1.20,3.14,4.38,4.34,4.79,4.95,5.06,3.54,2.67,2.34,1.58,0.46,0.29,0.08,-1.80,-1.70,1 -2.23,2.14,-0.08,1.03,2.30,2.88,3.97,3.47,4.59,3.81,6.09,3.31,2.18,2.85,1.11,0.43,0.26,0.21,-2.22,1.04,-1.07,1 -0.07,-0.01,0.58,-1.18,2.74,2.97,3.84,5.57,4.04,4.65,4.59,3.19,1.99,0.57,1.64,0.94,-1.27,-0.12,-1.06,-1.29,2.36,1 -0.28,0.07,1.74,0.11,2.69,3.62,3.18,4.72,2.60,2.92,4.82,2.23,2.10,1.84,1.60,-0.48,-0.47,-1.25,-0.14,1.33,-0.38,1 --0.53,-0.78,0.20,1.76,1.36,0.41,-0.78,1.62,0.59,-0.05,0.26,2.33,4.52,5.08,5.62,3.59,3.43,5.35,3.74,-0.01,-0.02,2 --0.54,0.72,-0.37,-0.23,1.20,2.11,3.16,2.06,2.13,1.76,1.63,1.79,4.00,3.60,4.02,4.53,1.72,1.57,0.83,0.09,1.12,0 --1.03,0.82,1.02,-0.10,-0.91,1.73,0.92,1.60,-1.25,3.59,2.95,3.69,3.40,5.08,5.07,4.12,4.37,2.06,2.25,2.08,0.33,2 --0.58,0.55,1.43,4.31,3.22,3.40,6.88,3.56,4.03,1.80,0.75,4.27,1.51,2.03,1.60,1.07,1.99,1.20,0.21,0.80,0.95,0 -0.84,-0.81,-0.85,1.75,0.80,0.32,2.59,3.71,5.51,3.89,7.69,5.23,3.42,2.12,2.68,1.82,-0.87,-1.64,-0.63,0.18,-1.82,1 -0.13,-0.77,-0.34,0.25,0.76,-1.95,1.43,1.38,1.57,4.16,4.52,3.49,4.48,4.50,4.39,3.98,1.98,0.84,0.32,0.18,-0.45,2 -0.85,0.07,0.28,-1.99,-0.12,-0.31,0.95,1.35,2.71,0.36,2.80,3.92,3.83,4.09,5.55,4.50,3.24,4.19,3.30,1.60,-1.24,2 -1.77,1.21,-0.81,1.49,1.40,0.30,0.77,1.07,-0.30,4.06,2.36,4.13,3.75,3.68,6.34,2.71,2.57,2.63,-0.62,1.11,1.02,2 -1.05,-1.34,0.42,2.75,0.34,2.54,3.86,4.70,4.72,2.45,2.72,3.56,0.57,0.19,0.00,0.70,-0.59,-0.70,-0.55,1.35,-0.36,1 -0.18,-1.31,0.59,2.25,4.42,3.84,3.48,1.81,2.81,3.08,1.63,0.48,2.17,0.99,4.25,3.85,1.16,1.18,1.79,0.53,-0.52,0 -0.79,2.77,1.14,1.63,2.74,4.96,5.70,5.59,3.30,3.34,2.97,2.31,0.35,0.69,-0.98,0.98,2.93,1.33,0.82,-0.04,0.61,0 --0.55,0.55,0.46,0.36,-1.05,-1.40,1.03,0.22,0.93,1.09,2.69,3.61,4.46,4.55,5.38,5.63,5.52,2.15,0.96,0.14,0.41,2 --0.08,2.40,-0.19,-0.48,-2.21,0.92,0.55,1.41,1.75,2.65,4.28,3.29,3.77,1.62,4.41,4.07,3.55,2.52,1.61,0.95,0.43,2 -1.04,1.79,0.88,-0.24,1.06,1.14,0.85,2.31,3.91,4.94,6.60,2.97,4.33,2.39,3.03,3.15,1.60,0.53,-0.08,-0.66,1.37,2 --0.31,0.14,-1.47,-0.30,0.04,1.32,-0.51,1.55,1.74,2.69,3.26,3.75,4.61,5.37,4.25,3.61,2.92,2.92,2.74,-1.01,-1.01,2 --0.32,-1.20,1.36,2.54,3.83,3.44,4.39,3.84,5.33,2.88,2.62,2.46,1.36,1.52,0.23,0.87,-0.49,-1.49,0.87,-0.64,0.96,1 --3.25,1.27,0.88,3.12,2.78,4.03,4.71,3.12,4.15,2.55,1.32,2.71,1.82,1.78,0.77,2.78,1.62,0.24,0.74,-0.60,1.62,0 -1.45,1.20,1.02,1.66,0.53,1.10,3.61,2.23,3.27,5.19,5.95,3.19,4.31,2.18,1.90,2.49,-0.84,-0.34,0.40,-0.40,-1.00,1 --0.56,-0.19,0.99,-0.70,0.36,0.24,1.71,3.07,1.77,3.41,5.85,4.57,3.50,2.00,5.51,0.36,2.50,3.81,1.40,0.65,0.12,2 -0.38,1.31,2.41,1.36,2.16,2.38,5.04,6.97,1.85,2.06,1.78,1.67,2.05,0.17,0.96,1.41,-1.49,1.67,0.32,1.04,-0.42,0 -0.76,-0.86,1.93,0.30,0.46,2.19,-0.75,0.99,0.71,2.15,1.02,2.94,6.06,5.25,4.84,4.45,2.66,4.41,2.87,0.86,-1.20,2 -1.39,0.18,0.45,-0.77,-0.60,-0.20,1.13,1.52,3.59,4.55,6.53,4.61,3.29,2.87,4.24,0.67,0.88,3.54,1.45,0.84,-1.18,2 -1.27,0.82,0.76,1.03,0.19,4.95,3.85,6.06,4.22,4.64,3.75,1.32,1.66,1.87,2.04,-0.61,-0.18,-0.76,-0.27,-0.15,-1.56,1 -0.51,-0.82,-2.37,-2.23,-0.80,-0.13,-0.59,0.68,0.89,1.79,2.36,2.27,2.84,4.55,4.38,5.34,3.58,2.09,1.35,0.16,1.01,2 --1.41,-1.19,0.22,0.68,3.01,3.10,2.45,3.29,2.33,3.41,5.43,3.83,2.58,0.34,1.74,-0.39,1.38,0.80,0.97,0.09,1.22,1 --0.90,0.35,2.71,1.99,2.29,3.76,4.97,5.25,3.71,2.79,2.82,-0.52,-1.27,1.15,-0.09,-0.87,0.71,-0.90,1.63,-0.88,-0.69,0 --0.41,0.63,0.34,0.58,2.88,1.86,2.95,3.81,1.55,2.05,-0.50,1.11,1.84,2.84,3.07,1.13,1.36,-0.42,1.15,1.35,-0.58,0 -0.67,0.49,1.82,1.23,1.72,1.95,4.37,3.92,4.71,5.83,3.02,5.45,1.53,4.66,1.69,1.74,-0.99,0.44,0.63,2.45,-0.31,1 --0.32,2.81,-0.15,1.97,2.64,2.32,3.15,4.03,4.81,3.23,3.62,5.34,1.69,1.73,0.72,-0.01,1.83,0.04,-1.17,-1.44,0.55,1 -0.25,-0.75,0.47,-0.35,1.38,0.25,0.95,1.19,0.67,0.26,3.47,2.76,4.16,4.61,5.35,4.89,2.97,3.79,1.96,-1.50,0.61,2 --1.66,1.30,1.30,0.96,3.39,4.20,3.90,3.98,2.23,1.06,0.94,2.82,2.77,1.55,2.73,4.40,-0.17,2.08,-0.95,0.04,0.64,0 --1.31,1.39,0.01,1.30,1.98,1.71,1.50,2.64,2.27,1.84,1.04,2.24,2.75,3.13,4.30,2.20,3.52,0.52,2.75,0.17,-1.11,0 --1.56,0.51,0.83,-0.20,0.22,-0.52,0.61,2.57,5.65,3.15,7.23,6.81,4.75,4.17,3.15,0.70,0.72,0.12,0.47,-1.67,0.18,2 --0.36,0.17,2.55,1.00,1.55,4.43,5.31,3.62,2.66,4.28,2.87,1.57,0.94,0.36,1.01,0.31,0.70,1.01,0.48,-0.52,-0.25,1 -0.98,1.40,0.07,-0.73,-1.57,-0.68,1.41,2.26,0.09,1.59,3.70,3.64,4.96,3.74,5.91,4.34,4.40,2.20,1.35,0.55,-2.10,2 --1.56,1.57,1.07,3.05,3.79,4.41,7.25,5.77,4.23,4.87,3.43,1.01,1.76,-0.19,1.60,0.16,-0.57,0.60,-0.19,0.98,0.18,1 -0.39,0.33,-0.34,1.96,1.90,3.32,4.35,3.37,4.04,3.57,3.13,0.74,0.72,1.67,1.76,0.00,-0.10,1.38,-0.96,-0.08,-1.22,1 -1.18,0.20,0.40,-1.24,0.60,1.20,1.33,4.27,2.66,5.16,4.33,4.58,4.26,1.96,1.52,-0.84,-1.68,0.94,-0.17,0.38,-1.13,1 --1.16,-0.49,0.83,-0.29,0.79,-0.21,1.02,-0.38,0.05,1.68,1.26,3.70,3.55,3.80,5.50,4.43,4.05,2.94,0.34,-1.31,0.33,2 -1.14,-1.18,1.32,-1.19,0.84,0.08,0.99,1.24,3.40,4.59,5.06,4.69,4.29,2.96,2.27,3.91,1.08,0.37,-1.61,0.60,0.32,2 -0.55,0.74,2.00,2.13,3.74,4.65,4.78,4.13,3.61,2.20,3.87,1.67,0.14,0.66,-1.86,0.81,-1.04,0.98,-0.06,-0.58,0.71,1 -0.37,2.00,1.04,0.65,1.12,1.24,0.99,0.05,0.43,0.89,3.87,3.54,2.43,4.29,5.65,5.83,2.22,1.70,1.21,2.78,-0.83,2 --0.26,-1.00,0.06,1.04,1.22,0.52,-0.03,2.01,0.78,1.79,3.17,0.51,3.35,6.95,5.11,3.25,1.17,2.04,0.75,-0.64,-0.87,0 --1.61,0.87,-0.54,-0.30,1.77,-2.65,-2.11,0.29,0.52,0.82,3.09,1.93,3.91,4.63,5.88,3.90,4.15,3.59,1.98,-1.50,-1.15,0 --0.44,-1.33,0.21,-0.56,1.02,2.03,2.47,2.13,2.03,-0.23,4.15,3.77,3.68,4.80,4.84,5.33,2.93,2.97,0.10,0.70,-0.35,0 -0.17,-1.12,2.29,-0.14,1.52,1.19,4.35,5.48,5.71,6.17,5.43,6.28,2.87,3.63,1.36,0.42,-1.55,1.64,-0.26,-1.54,0.40,1 --0.05,-0.81,0.76,2.55,0.90,2.21,2.27,5.65,4.81,5.72,5.71,4.41,2.00,2.33,1.20,0.57,-1.64,0.47,1.27,-1.57,-1.61,1 -0.21,-0.19,2.27,1.08,-1.18,2.19,-0.04,2.20,3.20,2.40,4.96,2.74,4.83,3.30,2.39,1.33,2.49,1.23,-1.53,-0.01,-0.66,2 -0.34,-0.94,-0.98,0.31,-1.37,1.75,0.28,1.39,3.46,3.73,3.24,2.94,5.66,2.63,3.79,2.60,1.57,3.00,-1.10,2.42,-1.56,2 -0.77,0.73,2.25,3.20,3.14,2.91,2.83,2.36,2.13,3.66,4.20,1.46,0.47,-0.24,1.79,1.18,1.99,1.27,0.10,-0.46,-3.82,0 -0.70,0.76,0.24,0.04,-1.26,-0.45,0.95,0.96,1.47,1.19,3.63,3.81,3.12,4.13,4.57,3.79,3.42,1.52,0.72,1.03,1.30,2 -0.17,0.94,1.10,1.48,2.41,3.73,2.79,1.40,3.64,5.37,5.25,3.97,3.55,0.37,-0.13,0.50,0.55,-1.31,1.66,-1.22,-0.87,1 -1.68,2.26,1.00,-0.16,0.76,2.67,1.79,2.86,4.28,3.07,5.12,4.90,3.13,5.17,2.76,2.44,2.38,0.33,-0.21,-0.65,0.81,2 --0.42,1.09,0.30,2.52,0.91,2.05,2.48,2.11,1.30,1.17,2.56,2.67,3.03,3.56,3.66,1.86,2.08,4.02,1.59,1.92,-0.40,0 -1.11,1.33,3.00,3.37,3.60,3.97,5.93,3.99,6.07,4.01,1.79,2.33,0.74,0.65,-0.24,0.61,-0.09,-0.02,-0.82,-0.17,0.01,1 -0.21,3.04,0.82,1.95,3.97,1.61,2.12,3.18,4.25,4.27,1.09,1.06,2.11,0.74,2.62,2.99,1.23,0.61,1.79,2.76,0.50,0 --0.80,0.19,-0.88,-0.50,1.42,0.07,3.37,1.66,2.35,3.29,2.75,3.11,4.25,3.66,3.14,1.15,1.59,0.65,0.92,1.44,-0.58,2 -0.85,-2.44,1.37,1.24,2.75,3.48,3.97,5.02,2.39,2.88,1.36,2.47,0.10,2.76,2.48,2.31,1.75,0.43,-0.26,0.88,-0.35,0 --1.79,-0.81,1.41,-0.51,-1.75,1.11,2.81,2.19,4.04,3.41,5.77,5.15,5.96,2.22,5.06,2.65,1.75,1.64,-0.94,1.75,-1.17,2 -0.02,0.68,1.61,2.03,1.73,3.55,3.26,4.97,4.77,4.93,3.60,3.40,1.58,0.19,0.21,0.62,-0.81,0.06,0.20,0.98,0.80,1 --0.73,1.43,0.10,-0.22,-1.17,1.96,2.32,1.66,3.46,3.69,5.11,4.93,4.55,1.30,2.60,2.11,-0.17,0.03,1.57,-0.08,0.89,2 --0.91,-1.78,0.30,2.37,2.32,0.29,0.65,-0.60,1.09,4.25,2.95,5.70,4.10,4.49,5.31,4.76,3.90,1.71,2.35,0.22,-1.53,2 -0.28,1.50,-0.11,-0.57,-0.22,0.75,1.56,0.10,2.93,1.50,4.50,3.74,3.30,4.80,3.61,4.17,4.31,1.84,1.15,2.44,0.70,2 -1.41,-0.87,-0.91,-0.79,-1.22,0.17,0.24,-1.38,0.14,3.33,5.98,4.96,4.86,3.45,4.46,1.84,1.92,0.20,1.24,-1.62,-0.21,2 --0.34,1.84,1.28,3.67,5.06,5.60,4.98,6.10,4.12,3.01,2.22,1.45,1.11,1.43,0.57,-0.73,0.09,0.21,-0.15,1.61,0.45,0 --0.95,1.15,0.64,1.76,-0.64,2.97,2.42,2.18,4.21,5.03,5.72,2.01,4.07,2.74,4.34,0.87,-0.17,1.70,-1.53,-0.39,1.18,2 -1.08,-0.68,-1.31,0.12,-0.65,3.19,1.49,3.09,4.32,3.50,5.05,3.58,6.10,2.81,2.27,2.64,0.17,0.54,-0.32,1.38,0.69,2 -1.59,0.32,0.74,-0.68,0.00,-1.30,-0.49,2.47,2.68,3.14,1.88,5.40,3.88,4.55,3.26,3.43,2.03,2.10,0.39,2.27,-1.64,2 --0.58,0.86,1.82,0.40,2.13,1.11,2.59,2.65,2.21,3.43,2.88,1.58,1.84,3.20,1.60,2.89,2.46,2.39,0.48,0.77,0.23,0 --0.81,-0.92,-0.47,-0.03,0.37,1.12,3.56,2.26,5.38,3.90,5.33,5.27,5.25,3.00,0.85,0.27,0.68,1.30,0.33,1.89,2.34,1 -0.53,-0.51,0.46,2.64,1.88,2.81,1.55,2.43,3.74,4.34,2.74,3.06,3.27,1.37,-1.12,1.97,-0.04,-0.85,-0.14,0.25,1.31,1 -0.29,0.70,-0.08,1.40,-1.41,0.83,3.73,1.47,0.50,1.11,3.16,4.45,3.79,3.90,4.68,5.05,0.88,1.71,0.90,-0.12,-0.84,2 --0.70,0.45,0.82,4.32,5.74,2.50,6.80,3.68,2.44,4.57,2.45,2.20,-0.90,-1.10,1.34,1.34,0.90,-1.05,-0.73,-1.14,-2.04,1 --0.66,2.16,1.77,2.34,2.25,2.65,2.79,0.86,3.01,-0.57,-0.41,2.43,3.06,2.90,5.26,2.92,3.23,0.91,1.42,1.76,-0.36,0 --0.30,0.42,-0.13,2.97,-0.51,2.66,3.57,3.02,4.43,4.19,3.64,3.58,2.69,1.77,-0.68,-0.04,-2.71,1.29,0.54,0.83,0.27,1 -0.19,0.62,-1.18,1.24,0.85,0.59,2.18,2.83,4.15,6.74,5.38,5.85,2.69,2.54,2.51,0.87,0.03,-0.32,-0.54,-0.80,1.27,1 -0.61,0.08,-1.08,-1.20,1.43,-0.26,1.31,2.83,1.55,2.65,4.12,4.60,4.05,4.46,3.64,2.37,0.44,-1.49,-0.49,-0.77,0.24,2 -0.94,-1.05,0.05,0.48,0.11,2.61,3.84,3.74,6.13,2.31,5.86,4.38,2.38,1.14,0.32,2.69,0.42,1.55,1.37,-1.10,0.00,1 -0.65,1.01,-1.88,1.78,1.06,1.75,1.47,1.52,2.94,4.56,4.98,3.14,3.95,3.17,3.26,1.34,0.47,0.46,0.99,1.75,-0.75,2 --0.50,1.31,-0.95,-0.39,0.61,1.21,1.14,0.02,1.52,1.79,4.26,3.00,3.18,4.38,4.89,3.85,3.49,3.20,0.67,0.11,1.52,2 -0.68,1.57,0.58,2.63,1.57,3.16,4.90,4.31,1.91,4.01,4.67,2.83,1.44,0.77,1.47,-0.63,-0.80,1.47,0.76,-0.34,0.33,1 --0.83,-0.19,0.48,0.39,0.81,-1.26,0.16,0.32,-0.79,0.04,2.85,4.45,4.77,4.77,6.02,4.45,3.88,3.43,-0.19,0.63,-0.34,0 --0.98,0.14,2.91,0.76,2.79,5.80,4.88,3.43,3.77,4.04,1.27,0.83,0.15,-0.25,1.84,2.05,-0.49,-1.06,0.90,1.07,-0.88,0 -0.17,-2.75,0.36,-0.06,-0.46,-0.35,0.11,0.04,1.42,0.75,2.04,6.11,4.11,4.97,4.38,4.73,3.07,1.81,2.26,-0.52,-1.53,2 -0.49,-0.87,1.25,-1.04,-0.21,1.37,-0.85,1.89,2.34,3.06,3.04,4.59,3.55,4.61,3.87,3.81,2.21,1.92,0.48,0.46,2.54,2 --0.50,-0.21,3.41,-0.24,-0.16,1.62,1.16,2.83,1.60,2.46,5.28,4.29,5.65,4.63,2.93,1.13,1.53,0.74,-1.39,0.07,-0.24,2 -0.72,-1.23,0.01,-1.14,-1.49,-1.55,3.71,4.11,4.65,5.85,6.10,4.50,3.74,3.05,2.11,1.73,0.48,-0.41,-1.11,-0.66,1.69,2 --0.51,0.31,0.98,-0.33,5.28,5.82,4.12,5.50,3.04,3.32,1.49,1.52,0.16,0.15,-0.78,1.22,-0.45,1.02,0.56,0.69,1.05,1 -2.30,-2.02,1.14,0.03,1.03,-0.19,1.47,0.41,2.14,2.34,3.56,3.42,3.60,2.60,3.44,3.73,3.81,2.81,1.35,2.01,-0.90,2 --0.83,0.22,-0.66,1.84,0.95,1.41,0.23,1.52,1.10,1.09,1.92,2.33,4.44,4.79,3.93,3.30,3.70,0.92,2.59,0.44,-0.94,0 -1.64,1.24,2.10,0.46,-1.97,-0.38,-0.73,2.88,1.79,2.28,3.09,3.26,4.78,4.99,5.04,3.71,3.50,3.19,4.11,1.24,-0.18,2 -0.71,-0.85,-0.62,1.41,-1.15,-2.48,1.49,-0.51,0.15,2.16,2.79,1.69,6.05,4.44,5.76,3.84,2.82,2.47,0.91,0.63,-0.04,2 -0.30,2.06,0.37,1.63,0.79,3.18,3.27,4.48,4.61,3.06,3.26,5.22,1.58,1.87,0.63,1.18,-0.33,-1.25,0.93,-0.14,1.99,1 -0.57,-1.04,-1.11,0.57,-0.68,1.23,1.65,1.54,1.65,2.30,5.15,4.44,3.09,2.67,4.34,2.68,2.46,1.37,1.40,1.12,0.18,2 -1.51,-0.26,2.98,1.31,2.31,3.58,2.75,1.39,2.65,2.62,1.41,1.37,2.12,1.95,2.17,2.01,4.44,-0.13,0.42,0.68,1.41,0 -1.70,1.59,1.30,1.86,0.18,0.33,-0.27,0.34,0.49,2.19,1.84,2.64,5.72,5.60,6.19,3.76,3.40,0.13,1.87,0.12,-1.22,2 -0.06,0.15,-1.12,0.95,-2.62,-0.14,1.00,1.36,3.47,3.00,3.73,4.24,3.90,3.34,4.25,3.62,2.76,1.44,3.02,-0.26,-0.07,2 --1.32,-0.16,0.43,-1.17,1.16,1.50,1.26,0.59,1.16,2.19,3.02,5.65,3.86,4.75,3.89,3.10,1.90,-0.00,1.58,-0.97,-1.58,2 --0.57,-1.29,1.25,0.98,-0.68,0.81,0.78,0.58,-0.21,1.41,1.75,1.84,4.21,5.60,4.73,5.56,3.53,1.88,2.36,0.60,-0.69,0 --0.58,-1.94,1.51,2.21,-0.15,1.56,0.60,-1.45,-1.18,2.81,1.64,2.46,3.33,4.48,4.44,2.93,4.01,2.45,0.80,-1.21,-1.33,0 --1.64,-0.27,0.28,-0.83,-2.02,0.00,3.92,2.57,2.28,2.76,5.04,6.52,3.76,4.17,1.50,3.37,1.28,-0.63,-0.44,0.67,1.28,2 --0.76,-0.52,-1.26,0.07,0.61,0.00,0.45,-0.49,-0.48,0.01,1.50,4.40,2.92,3.17,4.86,3.76,2.61,0.74,3.16,0.82,1.40,2 --1.15,1.39,2.78,-0.17,-0.70,-0.38,0.98,-0.27,1.07,2.34,2.70,2.93,4.58,4.17,5.93,5.63,3.74,3.26,2.15,1.69,-1.59,2 --0.13,1.72,0.26,2.37,2.30,3.42,3.19,2.88,2.39,2.21,1.48,3.16,2.13,2.94,2.02,2.56,0.72,1.12,0.31,-0.31,0.70,0 -0.17,-0.70,-0.73,0.71,0.40,0.67,1.74,0.97,1.62,3.55,4.96,4.58,5.87,3.85,3.05,4.13,2.84,2.26,0.45,2.92,2.59,2 --0.38,1.34,1.23,1.89,2.18,1.28,2.88,3.69,1.91,1.32,0.96,0.33,0.91,1.59,2.91,1.93,2.76,0.04,2.06,0.43,2.24,0 --1.71,2.05,0.66,-0.06,-1.05,-1.27,1.83,2.19,1.36,1.91,3.89,3.37,4.63,5.50,4.32,5.57,5.59,3.07,1.49,2.31,2.52,2 --0.05,-0.56,0.65,1.00,-0.54,-0.02,0.31,1.06,0.96,3.00,3.28,3.02,5.49,4.54,7.66,4.09,1.05,2.82,0.94,1.74,1.72,2 --0.83,-0.58,0.00,1.41,-2.40,0.05,2.21,1.96,0.96,4.03,5.02,3.73,4.34,4.37,1.28,3.97,3.57,0.61,1.76,0.27,-0.42,2 -0.77,0.33,2.07,0.26,0.61,2.60,5.44,2.53,3.25,3.71,3.56,2.32,3.53,0.43,1.88,1.09,-0.45,1.00,1.58,0.11,0.84,1 --0.35,0.57,0.91,1.28,-0.01,1.11,2.28,2.30,3.08,4.82,7.28,6.21,4.76,3.18,1.66,0.08,0.66,-1.25,-0.06,-0.81,0.77,1 -1.72,1.33,2.48,1.62,3.76,4.48,5.45,6.05,3.18,2.56,3.83,1.89,-0.14,0.90,-0.47,0.11,1.22,-0.58,-0.99,-0.73,-1.39,1 --2.10,0.67,-0.92,0.73,0.89,-0.60,2.44,3.31,1.93,2.96,4.20,5.22,2.51,4.19,4.35,3.99,0.24,1.60,0.00,1.14,-0.14,2 --0.04,1.43,0.84,-0.63,-0.76,1.06,1.20,0.76,4.39,4.18,4.78,3.13,4.43,5.51,2.77,2.23,3.27,1.16,2.07,0.07,0.49,2 -0.86,0.27,0.13,0.07,-0.67,1.48,2.14,2.88,3.17,3.61,4.08,4.32,3.99,3.92,1.40,2.05,0.91,-1.61,0.79,1.40,0.80,2 --0.56,1.96,1.78,0.60,1.18,-0.33,0.09,3.07,1.92,2.76,2.07,3.02,3.76,2.84,5.70,3.88,3.43,2.08,0.73,0.35,0.91,2 --0.13,-1.82,0.57,0.51,-0.12,2.69,2.98,1.05,4.90,4.55,4.87,5.87,4.20,3.85,3.84,2.18,0.96,0.89,1.03,0.71,-2.72,2 --0.89,-1.06,-0.56,1.66,2.97,3.80,5.21,4.70,3.12,2.99,4.10,1.89,1.36,0.89,0.09,-0.23,-1.40,0.29,0.38,-0.99,0.62,1 --0.98,1.05,-1.22,2.34,-1.89,1.20,-0.62,0.41,-0.58,-1.24,0.75,3.35,4.19,5.91,6.12,5.02,3.93,3.87,0.58,0.47,-0.63,2 --0.99,0.19,3.51,1.51,3.50,3.92,5.31,5.37,3.96,2.13,4.89,1.57,-1.33,3.19,0.60,0.15,0.19,0.92,-0.29,1.16,-0.49,1 --0.30,1.20,0.10,2.85,0.96,3.46,3.87,3.46,4.20,3.50,2.76,0.82,-0.14,0.83,1.98,0.29,-0.19,0.42,0.91,0.89,-1.54,1 -0.71,0.23,-1.21,0.97,1.29,0.96,3.21,1.77,4.70,5.45,5.69,5.30,4.63,4.64,2.64,1.45,-2.88,0.24,0.52,1.01,-1.50,2 --1.18,0.04,0.26,0.99,2.23,3.67,2.15,2.44,2.59,1.87,1.49,1.05,2.95,1.39,3.35,3.35,2.73,1.87,2.29,0.16,0.54,0 -1.48,-0.36,2.30,1.46,1.95,3.71,4.81,4.34,5.64,4.05,3.32,2.35,0.73,-0.03,1.07,0.06,0.60,1.06,-2.36,1.86,2.22,1 -0.47,0.43,2.12,3.17,0.83,2.88,3.70,4.87,1.78,3.10,3.46,2.32,2.46,1.67,-0.46,-0.07,1.38,-1.82,1.67,-0.48,0.09,1 -0.06,1.28,0.74,-0.03,2.52,2.23,3.00,3.74,1.22,1.98,1.55,2.87,1.46,1.91,3.57,3.34,2.72,1.29,0.25,0.58,0.06,0 -0.56,-0.36,-0.46,-0.38,1.12,0.82,0.67,3.41,2.64,5.06,5.37,5.05,3.08,4.44,2.86,3.11,0.73,-0.11,0.60,0.23,0.18,2 --1.00,2.37,1.72,0.08,2.63,2.10,2.69,3.09,2.36,0.25,1.63,1.33,-0.41,1.25,1.69,2.05,1.78,2.04,-1.21,-0.37,0.58,0 -0.14,-0.56,1.45,3.29,4.35,2.11,4.66,4.35,2.66,4.68,2.99,3.21,0.87,-0.59,1.22,1.38,1.51,-0.35,0.61,-0.21,1.11,1 --0.44,0.89,1.12,0.18,2.17,-0.33,-0.75,-0.37,-1.01,2.64,2.08,2.52,4.32,5.49,5.44,5.09,3.74,3.02,1.94,-1.39,-1.96,2 -0.37,1.70,1.11,0.29,0.95,5.10,3.04,2.64,2.64,3.21,0.78,1.07,-0.74,0.87,0.97,1.73,-0.05,-0.02,0.38,1.15,1.07,0 --2.27,0.65,1.45,0.55,2.77,2.70,1.20,4.23,3.60,2.87,6.12,4.69,4.19,2.90,1.93,0.74,-0.92,0.44,1.48,-0.20,0.30,1 -0.10,1.30,1.48,1.75,5.05,4.55,4.00,4.44,3.16,2.76,1.64,0.94,-0.54,-0.04,-0.34,0.24,0.81,-0.17,0.25,2.74,-0.94,0 -1.71,0.99,2.76,2.03,1.69,4.40,2.22,1.38,1.17,1.00,2.93,2.44,3.45,3.47,1.68,4.19,2.86,1.06,1.27,0.99,0.76,0 -1.64,1.74,-0.44,-0.39,1.76,0.24,2.90,2.37,3.03,2.71,2.07,2.44,1.84,3.04,2.09,4.26,2.90,2.42,-0.09,-0.13,0.42,0 -0.65,1.05,3.49,1.82,3.06,2.07,5.74,4.38,2.36,3.65,3.33,3.02,1.24,0.61,0.90,-0.64,-0.24,1.14,0.07,0.21,-1.43,1 -0.03,-0.93,0.67,-1.42,0.21,0.38,2.02,2.42,2.91,2.81,7.30,4.23,4.05,2.52,2.13,0.28,0.43,1.09,1.47,0.21,0.70,2 -0.62,-1.05,0.58,0.92,1.32,1.32,0.16,0.19,-0.27,1.52,1.46,3.25,3.77,4.86,3.82,4.06,1.23,3.87,0.93,2.40,0.36,0 --1.01,-0.68,1.34,-0.68,0.15,0.16,0.45,3.71,2.86,3.17,5.06,4.04,2.77,2.45,1.32,0.74,0.18,0.65,-0.75,0.73,-0.41,1 -2.06,2.38,-1.49,-0.50,-1.03,1.72,2.13,1.56,4.33,2.53,5.44,3.61,4.01,2.22,4.22,2.39,2.47,0.80,-0.14,-0.46,-0.33,2 -0.04,-1.68,-0.13,0.85,0.35,-0.31,-0.32,-1.90,-1.72,3.02,3.27,3.82,3.63,3.79,5.05,3.69,3.74,3.21,3.47,1.21,-0.56,2 -1.40,-1.27,1.87,-0.61,0.29,-0.52,2.16,2.35,3.64,2.22,6.17,4.88,3.36,3.98,3.55,0.64,-1.47,0.15,0.43,0.39,0.67,2 -0.06,-0.34,-1.32,0.13,-0.14,1.59,3.64,2.05,4.21,4.65,5.11,5.43,4.68,4.68,1.18,-0.47,-0.02,0.29,0.29,0.43,-0.55,1 --1.73,-0.14,1.15,1.67,2.61,3.34,3.94,1.82,2.12,2.34,1.88,1.38,2.22,2.91,3.43,2.67,3.42,1.22,-0.55,0.07,-0.02,0 -0.90,0.16,-0.06,1.00,1.55,1.91,5.36,2.74,3.33,4.16,5.47,4.06,1.75,3.22,1.83,1.13,-0.07,-2.39,-0.65,0.53,0.02,1 -0.69,-0.18,-0.40,0.68,1.20,0.10,0.50,1.04,0.30,2.12,1.52,2.24,2.94,4.01,7.02,4.22,3.71,1.48,2.40,1.21,0.60,2 --0.15,2.00,2.49,2.76,3.43,2.76,4.67,4.32,4.01,2.23,1.56,1.85,1.86,1.37,0.69,0.61,2.92,-0.27,1.33,2.05,-1.57,0 -1.93,0.46,1.40,0.39,0.06,0.68,0.55,2.58,2.13,1.32,5.33,4.34,2.94,6.33,4.56,5.55,2.63,1.19,1.65,-0.20,-0.17,2 -1.49,0.46,1.57,1.03,0.95,0.58,3.51,3.61,5.08,3.90,5.37,3.28,4.06,2.40,1.16,-1.72,-0.79,-0.54,-1.34,-0.80,0.91,1 -0.47,0.28,0.93,0.23,-0.82,0.13,1.19,2.74,4.39,5.44,5.50,5.67,2.65,1.80,1.47,1.06,1.15,-0.59,-0.81,-3.11,0.26,1 -0.27,0.40,0.19,0.93,-0.77,0.76,0.07,-0.34,0.22,1.20,1.69,1.46,3.64,4.93,6.38,3.89,4.55,4.08,2.74,0.78,0.67,0 -0.16,0.50,1.65,1.10,2.61,3.18,4.76,3.85,2.88,1.13,1.89,1.10,1.62,1.38,-0.42,1.65,0.62,0.06,-0.77,0.55,0.37,0 --1.43,-0.57,-1.55,-1.64,-1.66,-0.28,-0.49,0.34,1.15,1.24,2.42,3.13,3.92,6.75,4.87,4.81,2.31,2.17,2.27,1.39,0.25,2 -0.49,1.79,0.13,0.05,0.82,2.14,2.40,3.10,4.62,3.91,4.88,4.00,3.35,5.86,2.13,1.23,1.14,-0.54,0.95,0.06,0.73,2 --1.66,0.08,1.64,0.52,2.81,3.68,1.68,2.97,1.92,1.86,3.04,2.36,3.33,4.00,4.07,2.48,2.24,3.32,1.26,-0.36,-0.20,0 --1.92,0.99,1.60,2.04,1.83,3.65,2.62,3.92,3.72,4.06,5.07,4.06,2.02,3.15,1.55,1.12,1.02,-0.80,-0.30,-1.84,1.37,1 -0.85,0.86,2.25,2.51,3.46,4.43,6.33,4.69,4.12,2.97,1.64,0.86,-1.08,0.10,-1.75,0.10,-0.40,1.72,-0.73,0.41,0.12,1 --0.61,0.51,0.90,1.26,0.00,1.06,1.99,-1.20,1.39,0.13,1.21,1.71,3.29,5.85,4.95,5.21,1.36,2.66,1.90,-0.66,-1.81,0 -0.26,1.20,0.27,1.74,-0.87,0.86,0.67,1.86,-0.60,1.40,2.83,2.19,5.45,5.45,5.61,3.82,3.73,4.09,1.99,-0.16,0.05,2 -0.22,0.19,1.71,2.21,0.81,1.93,3.00,3.66,2.34,3.03,1.36,-1.00,1.61,1.18,1.43,2.03,1.86,1.49,0.73,-1.30,-0.40,0 --0.81,-0.14,2.28,4.20,3.35,4.26,4.69,5.36,4.24,1.60,2.52,1.79,-0.13,0.45,0.56,0.11,-0.24,-1.20,-0.65,-1.44,1.83,1 -1.55,1.22,-0.31,-0.95,-0.92,-0.23,1.14,2.42,0.91,2.23,1.31,2.33,3.57,5.04,5.07,4.73,2.01,1.39,0.66,0.33,-0.76,0 -1.49,1.97,-0.15,0.41,0.03,1.19,2.65,3.48,3.36,6.44,6.76,3.25,4.26,0.16,0.88,1.98,0.59,0.00,-0.09,1.86,1.47,1 -0.44,1.91,-0.80,1.39,2.03,3.46,3.54,3.94,3.84,2.33,2.63,4.18,1.36,1.85,0.19,-0.06,0.15,0.72,0.13,-1.82,0.37,1 -0.14,0.19,-0.19,0.65,2.01,2.34,4.12,1.33,3.46,4.17,5.29,3.20,4.01,2.80,2.71,1.07,-0.91,0.07,0.82,0.21,-0.60,1 -0.79,0.97,2.53,2.45,3.64,4.80,3.87,4.78,3.65,1.66,2.04,1.08,1.01,1.54,0.68,-0.58,-0.05,-1.12,0.99,-1.53,-0.65,1 -0.53,-0.99,1.27,0.11,1.29,1.08,1.26,2.05,1.92,2.57,2.88,2.68,2.95,4.98,6.00,3.45,2.50,1.61,2.19,1.99,0.79,0 -1.57,0.53,1.72,0.59,-2.25,0.35,0.32,0.78,0.23,0.65,0.69,3.85,3.61,4.43,6.59,4.78,3.74,2.25,3.15,2.26,0.06,2 -0.31,-0.06,-1.24,-0.43,1.51,-0.40,-0.40,-1.43,-1.88,2.99,2.32,3.94,3.94,5.27,5.47,4.55,3.67,1.92,2.13,0.68,0.27,0 --1.81,1.13,1.23,0.66,1.57,1.92,4.73,3.60,3.50,2.65,2.23,4.32,0.96,1.37,-0.53,0.90,-0.02,-0.72,-1.47,1.00,-0.77,1 -1.76,-0.75,1.38,2.19,0.37,4.26,4.08,4.65,3.83,4.85,4.13,2.53,3.28,2.59,2.41,-0.60,0.75,-0.07,0.60,-0.33,0.26,1 -1.20,-0.78,0.92,3.02,1.71,3.42,3.91,2.37,3.47,2.41,2.31,1.32,1.17,1.65,1.03,0.33,0.30,0.11,0.07,-0.56,-0.51,1 -0.39,-0.25,1.21,0.28,-0.51,0.45,0.23,-0.17,2.05,4.34,2.26,3.87,4.75,4.68,5.15,2.53,1.38,3.05,1.86,1.35,1.10,2 --1.36,0.03,1.46,0.39,0.00,0.36,1.26,3.67,1.38,3.04,2.26,6.67,3.75,2.37,3.27,3.30,0.22,2.40,3.41,1.44,-0.31,2 --0.35,-1.48,1.05,-1.28,0.25,1.59,0.80,3.45,3.74,4.44,5.45,4.05,3.59,3.09,2.16,0.97,0.15,1.74,0.25,0.07,0.87,2 --0.99,0.11,3.23,2.31,1.81,4.27,5.49,6.16,3.90,3.26,1.54,2.27,2.12,0.44,-0.40,-0.42,1.24,-1.61,-0.75,0.63,0.16,1 --0.68,0.62,2.17,1.31,2.38,2.68,3.94,2.98,5.45,3.07,4.87,3.62,1.01,0.93,2.46,-1.02,-0.19,-0.50,-0.36,0.87,-1.73,1 -2.30,-0.16,2.86,1.94,3.03,3.22,4.58,4.81,4.07,4.51,3.89,1.72,4.72,1.25,2.49,1.38,-0.51,-0.91,0.44,-1.70,0.24,1 --0.50,-0.77,3.47,2.56,2.23,3.42,2.94,4.92,4.92,4.85,5.31,2.31,3.28,0.79,0.07,2.13,0.48,-1.53,-1.14,-0.35,-0.47,1 --0.12,1.85,0.36,0.07,2.13,3.67,4.48,2.17,3.84,-0.22,0.77,1.94,1.82,4.10,2.60,3.16,3.86,1.65,1.45,-1.60,1.78,0 --1.69,1.42,2.48,4.40,3.74,3.08,4.81,3.41,3.14,3.28,-0.55,-0.63,1.84,2.02,-0.60,0.43,0.89,0.41,-0.50,0.51,-0.99,0 -0.99,-0.17,0.53,1.31,0.07,-0.45,2.64,1.74,3.17,4.19,3.92,6.55,2.69,3.60,1.94,1.32,0.32,0.32,0.68,-0.59,-1.06,2 -0.27,1.41,0.94,1.45,3.26,2.62,4.68,4.14,4.06,2.35,0.45,2.04,-1.18,2.23,0.49,0.68,2.05,1.46,0.70,0.82,-0.85,0 --2.30,-0.33,2.24,1.49,1.03,5.30,4.96,5.49,3.12,1.02,1.20,1.09,-0.45,1.14,0.56,0.34,-0.09,0.52,-1.97,-0.40,-2.29,0 --0.05,0.62,-0.49,-1.18,0.17,-0.24,0.43,1.56,1.40,2.39,3.53,4.45,4.04,2.82,3.19,4.94,3.33,2.78,0.08,1.65,0.51,2 --1.66,-0.44,-0.90,-1.15,1.11,-2.19,1.61,-1.00,-0.34,1.39,1.87,2.78,3.70,4.09,6.66,5.10,2.48,3.86,3.06,0.41,-0.39,0 -0.57,-1.85,3.55,1.51,3.06,3.09,2.24,4.40,1.58,3.96,2.03,0.25,1.41,1.84,2.01,1.15,0.81,1.19,1.26,-0.91,-2.04,0 -0.40,-1.10,-0.14,0.91,2.54,0.05,3.02,3.24,4.21,4.91,5.51,4.69,2.52,0.62,1.95,-0.25,1.77,-1.07,-0.55,0.62,2.04,1 -0.16,-1.53,0.83,-0.47,3.42,1.48,1.77,2.76,4.35,4.00,4.41,5.03,4.93,3.22,1.41,0.54,-0.21,0.27,0.23,0.61,0.78,1 -1.80,2.14,1.70,3.96,4.01,4.51,4.43,3.86,5.34,3.99,4.10,1.96,-0.80,-0.57,-0.69,-0.69,-1.44,0.87,1.54,-2.18,-1.50,1 --0.74,1.32,1.10,3.35,1.51,2.27,4.85,3.96,3.40,3.79,3.66,4.06,2.79,0.86,1.30,0.68,-0.55,0.76,-0.03,-0.38,-1.68,1 --0.29,0.23,2.21,2.85,4.00,5.47,5.82,1.93,4.70,3.33,1.35,2.50,-0.66,1.74,-1.34,0.17,0.53,-0.58,1.68,1.19,0.44,0 -1.56,0.34,0.72,0.89,1.44,1.85,2.43,3.77,3.95,3.16,4.75,4.01,3.20,2.12,2.65,1.10,0.21,-0.93,0.56,1.13,-1.24,1 -0.90,-0.38,-0.68,-1.56,1.03,-0.26,0.97,-1.09,0.98,0.46,3.34,3.82,3.78,6.31,5.27,5.11,2.33,4.04,2.07,2.13,-0.15,2 -0.30,-1.42,0.37,0.62,1.34,1.39,2.81,1.78,4.81,5.26,6.14,3.56,2.86,2.84,1.52,-0.16,1.32,1.48,0.99,-0.15,0.73,2 --0.29,-1.82,0.01,-1.41,0.53,0.66,1.44,3.63,3.43,4.35,5.23,4.29,3.84,1.90,4.35,2.32,-0.71,1.42,0.19,-0.66,-0.58,2 --1.21,1.69,1.48,2.26,2.66,4.66,6.43,5.20,3.66,2.94,1.26,1.32,-0.93,0.62,-0.19,0.77,-1.32,2.08,0.48,1.48,0.77,1 --0.17,-0.10,0.11,-0.75,1.11,1.26,1.02,0.66,3.97,4.43,5.07,4.11,5.15,3.31,2.60,1.35,-0.20,0.64,-0.95,0.20,1.35,2 -1.17,-0.39,2.93,3.78,3.07,2.58,4.12,4.40,5.86,3.30,2.76,2.52,0.09,1.80,-0.47,0.78,2.54,2.52,-0.12,-1.56,1.55,0 -0.25,0.40,0.89,0.06,0.15,1.39,1.37,3.18,1.48,3.61,2.97,4.12,3.93,5.74,3.54,3.58,1.87,1.57,1.15,-1.45,-1.52,2 --0.98,1.44,0.36,3.40,4.90,6.92,3.71,5.28,4.72,3.15,3.15,1.28,-0.29,0.07,-1.11,0.91,1.40,1.70,0.68,0.10,-1.67,0 -0.65,0.25,1.43,2.58,4.31,3.52,3.13,4.98,2.91,3.64,3.20,2.68,0.64,2.07,1.28,1.12,0.13,1.01,0.09,0.45,1.88,1 --0.97,1.48,2.70,2.17,4.62,4.21,5.94,1.95,3.41,4.52,2.88,2.71,3.06,2.21,-0.42,0.57,-1.28,0.97,-1.46,0.53,0.53,1 -0.25,-0.02,-0.98,0.01,-0.63,-0.97,0.32,0.84,-1.64,0.42,1.41,3.11,3.74,3.82,5.83,5.00,2.80,2.07,2.39,0.51,-2.22,2 -0.86,1.01,1.04,1.64,0.37,2.77,2.45,4.48,2.92,4.11,3.82,4.56,3.34,1.95,1.29,-0.25,1.61,0.40,0.53,-0.61,-0.86,1 --0.10,0.73,0.10,1.25,1.96,4.46,4.93,2.42,4.23,3.50,2.61,1.63,1.10,-0.66,-2.28,0.30,-0.97,1.57,-0.03,-1.75,0.18,1 -2.50,0.46,0.63,-0.98,-0.73,3.69,2.94,3.04,1.57,4.09,5.52,5.02,6.06,2.72,2.31,0.42,-0.36,0.31,-0.30,-0.70,1.01,2 --2.23,0.19,-0.41,-1.31,0.52,1.75,2.03,1.51,4.17,4.09,3.35,5.32,2.86,3.19,2.74,1.90,2.34,0.55,1.30,0.43,-0.58,2 --1.09,-0.07,0.29,1.71,0.61,1.68,3.07,4.16,3.40,5.47,4.08,2.31,4.07,1.85,1.23,-0.74,0.45,-1.09,-0.30,0.84,-0.02,1 --2.69,0.72,2.02,0.20,0.99,0.38,1.04,0.96,0.98,1.56,1.87,2.68,2.76,3.36,6.52,2.58,3.10,2.87,2.14,0.68,0.67,0 --1.22,0.14,1.44,1.02,1.00,2.85,3.55,5.09,3.41,3.72,5.35,3.83,0.89,0.10,2.36,0.81,-0.18,-1.27,-0.85,-1.51,1.11,1 --1.04,-0.47,2.61,0.82,4.07,1.67,4.37,3.64,0.18,2.18,3.07,2.52,1.56,-0.04,0.75,2.69,0.77,1.20,0.26,3.65,0.17,0 -1.41,-0.30,-0.59,1.01,0.70,3.12,2.23,3.99,6.42,4.28,5.25,4.73,3.65,2.08,2.09,0.66,-0.45,2.33,-1.52,-0.69,-0.08,1 --1.61,0.04,-0.24,1.22,-1.98,2.11,1.11,2.12,1.25,2.27,3.95,2.88,4.19,3.23,4.87,2.75,2.85,3.42,1.74,-0.21,-0.46,2 -0.35,2.31,0.90,0.17,1.92,3.51,2.67,3.26,1.04,0.44,1.77,0.15,2.59,1.11,4.15,0.74,1.66,1.68,1.57,1.02,1.12,0 --1.30,-0.00,-0.02,-0.35,0.74,1.53,4.47,5.31,2.54,4.85,4.66,5.58,1.47,0.75,1.49,0.43,0.19,-1.22,2.03,-1.35,-0.92,1 -0.59,-0.31,1.62,-1.87,0.14,-0.43,-1.07,0.55,-0.34,1.58,3.35,1.97,3.64,6.54,5.50,5.87,3.22,3.20,2.11,1.44,-0.06,2 -0.66,0.28,0.81,2.09,0.80,3.28,3.95,1.76,2.71,2.75,2.04,4.27,1.17,0.75,4.21,2.46,0.57,0.43,0.87,-0.55,-0.75,0 -0.16,-0.06,0.87,0.23,4.05,5.32,5.40,4.86,1.47,3.14,2.71,0.57,1.61,-1.97,-0.34,2.02,1.50,0.33,1.16,-1.31,1.33,0 --2.20,-0.90,1.63,3.33,3.58,4.28,5.57,5.47,3.00,6.07,3.64,2.19,-1.06,0.53,1.78,0.90,1.18,1.20,2.23,0.32,2.14,1 -0.77,-1.56,1.95,-0.70,0.49,0.62,1.10,-0.77,1.56,2.83,2.52,3.95,5.20,4.79,7.39,0.91,2.05,2.58,3.12,0.49,0.63,2 -1.75,-0.45,-0.02,1.75,2.18,1.77,3.79,4.00,4.62,4.02,1.35,2.71,2.17,2.55,-1.70,0.27,0.66,0.60,0.51,-0.69,-0.20,1 --0.86,1.03,1.30,1.14,2.72,3.14,3.41,1.74,1.14,0.95,2.21,3.49,3.58,3.65,4.22,2.17,1.01,0.95,1.02,0.33,1.28,0 -0.84,0.34,1.89,0.07,3.53,4.90,5.19,6.45,2.20,1.29,2.32,1.83,-0.04,-0.75,0.02,1.20,1.05,1.95,0.51,0.76,2.20,0 -1.50,0.79,0.31,2.22,3.33,0.99,2.46,3.39,2.00,0.02,3.29,-0.46,2.45,3.25,2.71,2.68,2.24,1.06,1.56,0.69,1.00,0 -0.51,-1.18,2.03,0.69,0.11,1.13,0.63,1.87,2.24,2.08,3.96,3.39,3.15,4.07,3.55,3.54,2.52,0.97,1.12,0.16,0.82,2 -0.35,2.02,2.21,3.53,3.54,5.54,4.95,5.26,2.99,2.25,3.69,0.30,0.69,1.50,0.21,0.25,1.49,0.28,1.46,0.46,0.38,0 -1.18,0.88,-0.28,1.21,-0.33,-0.34,0.57,0.51,2.71,1.99,3.85,3.00,3.11,5.65,3.37,1.67,2.20,1.63,0.18,1.05,0.61,2 --0.11,-1.56,-0.39,0.39,-0.43,0.03,-0.78,-1.52,-0.35,-1.14,0.81,3.85,3.23,5.92,5.81,6.36,3.12,3.02,2.38,-0.01,2.37,2 -1.76,0.42,0.08,-1.12,-0.65,2.14,1.24,3.19,3.36,4.09,4.37,3.20,3.40,2.58,2.92,1.63,0.79,0.80,0.81,-2.52,-1.15,1 -1.56,-1.24,2.88,4.35,3.63,4.87,7.66,5.29,2.64,3.51,2.96,2.14,2.04,0.67,-0.53,1.30,-0.95,-1.09,0.05,-0.33,-1.18,1 --0.39,-0.10,-0.95,-1.62,-0.49,0.19,0.60,2.04,0.50,3.09,4.46,4.74,2.92,3.39,2.68,1.82,1.51,3.32,0.50,0.67,-0.64,2 --1.15,2.43,-0.69,0.44,1.07,2.08,4.74,3.41,3.48,4.75,3.70,3.60,2.64,3.48,0.41,1.11,0.84,0.97,0.40,0.50,0.90,1 --0.93,0.99,3.07,2.22,4.12,5.32,5.10,4.26,6.06,3.67,2.38,-0.73,-0.73,-1.79,0.11,0.93,-0.66,-0.17,-0.42,0.27,-0.06,1 -1.64,-0.49,2.18,1.50,4.45,6.35,4.07,3.36,5.10,2.80,2.16,1.23,1.77,2.55,0.45,-0.74,0.08,0.72,0.12,0.10,0.08,1 --1.21,2.16,1.46,3.01,2.84,3.38,4.26,3.24,1.56,2.45,1.98,-0.18,0.14,0.50,1.34,0.55,-0.25,0.90,0.80,-0.84,1.04,0 --0.26,0.68,2.29,2.37,3.18,5.65,5.39,4.87,3.85,2.80,2.28,0.63,0.59,0.69,-0.98,-0.79,0.84,-0.44,-1.41,-0.19,-1.09,1 -0.16,1.23,0.83,3.02,4.37,2.99,4.47,4.59,4.25,2.44,0.87,1.76,0.51,0.65,-1.82,-1.29,-0.14,1.00,0.03,-0.96,-1.57,0 --0.01,0.78,-0.36,1.67,4.05,3.51,1.19,1.78,0.28,1.83,0.67,1.53,2.47,3.14,4.80,2.41,2.04,1.21,1.57,0.97,-0.30,0 --0.29,0.02,2.39,1.08,4.07,1.70,0.92,0.64,0.14,2.27,2.39,0.42,4.19,3.01,4.04,1.57,4.05,1.64,1.19,1.52,-0.75,0 --2.02,-0.84,-1.20,-0.73,-1.68,-0.24,1.11,4.43,5.19,4.65,3.10,4.84,2.70,2.25,2.22,1.14,0.73,0.05,0.60,0.03,0.03,2 --0.10,-1.74,-0.90,1.21,1.64,0.21,0.94,0.39,-1.12,1.38,-0.47,3.88,3.87,5.93,6.03,4.56,4.65,2.51,1.27,0.39,2.24,0 --2.17,1.33,0.33,-0.50,1.01,1.07,1.06,2.59,1.13,3.50,3.72,3.24,4.86,2.07,3.05,1.50,2.08,2.45,-1.74,2.05,1.72,2 --1.38,0.42,-0.12,1.04,-0.09,-0.32,1.19,0.33,1.10,0.06,4.84,2.20,4.54,4.08,5.89,5.37,1.60,3.39,0.55,1.31,-0.01,2 -1.31,1.36,0.27,2.05,3.74,3.63,4.33,5.01,4.15,4.19,5.45,3.82,2.79,3.03,2.06,1.51,0.74,1.60,0.79,-1.67,1.28,1 --1.56,-0.57,0.80,2.33,1.86,-0.01,3.48,-0.26,0.92,2.16,1.52,1.87,3.08,3.28,2.26,4.48,2.45,2.48,1.14,0.92,1.59,0 --1.03,1.31,2.55,2.31,2.28,2.57,3.20,2.62,4.43,4.82,4.35,3.81,3.19,2.29,1.02,0.83,1.84,1.37,1.95,-0.88,-0.04,1 -0.02,-1.25,0.65,0.76,0.85,2.03,2.62,4.66,3.51,3.82,3.59,4.20,3.24,3.10,2.92,0.45,0.97,0.31,0.81,-0.92,0.00,1 -0.36,2.22,1.88,3.99,2.79,5.01,5.13,5.23,3.97,2.69,1.92,0.43,0.01,0.22,0.07,-0.94,-0.17,-1.17,0.57,0.21,-0.58,1 -0.06,0.90,1.78,1.02,2.13,2.15,3.28,2.62,2.30,2.80,1.34,2.66,0.48,1.41,3.58,2.41,2.09,0.78,2.07,0.97,-0.99,0 -0.02,-1.03,0.20,2.34,0.14,2.77,3.44,3.13,4.87,6.14,3.66,2.25,2.03,1.00,2.02,-0.18,0.17,-0.03,-1.27,0.68,-0.09,1 -1.26,-0.26,-0.01,2.00,2.56,3.32,5.33,4.87,3.58,4.12,4.45,0.09,-0.11,-0.30,-0.31,-0.09,-2.68,-0.28,-1.51,0.65,0.94,1 --0.07,-0.74,-0.33,1.55,1.34,0.54,3.14,3.34,4.71,4.64,5.34,3.96,2.78,2.58,0.67,1.24,0.35,-0.74,-1.15,-1.86,0.30,1 -1.68,0.12,-0.69,-0.84,-0.98,0.38,0.70,2.84,4.17,2.62,3.48,5.62,2.73,5.50,2.74,2.05,0.06,-0.38,-0.25,1.18,0.65,2 --1.54,-2.73,-0.31,-0.19,0.67,1.44,1.87,1.63,4.67,6.08,6.03,2.72,4.70,4.66,3.47,1.81,1.34,1.01,0.85,0.51,-0.53,2 --0.99,-1.13,1.19,-1.38,-0.47,1.02,2.29,4.24,2.94,4.37,5.61,3.92,4.48,1.85,4.05,0.50,2.37,0.92,-1.33,0.80,-0.96,1 --1.37,-1.31,3.26,2.85,2.56,4.55,5.14,4.17,2.61,2.44,3.43,0.62,0.89,0.92,0.05,-0.05,-0.34,0.80,-0.21,-1.68,1.53,0 --0.96,1.24,-1.31,-1.59,0.29,-0.06,1.63,-0.33,0.33,1.30,3.87,5.86,4.25,3.74,6.71,5.18,1.67,2.05,-0.39,2.27,0.71,2 --0.26,-1.00,1.21,-0.47,2.99,3.73,3.39,3.47,2.88,3.87,3.13,3.58,1.92,1.24,1.14,0.52,-0.12,-0.02,-0.53,1.57,0.91,1 --0.07,1.41,0.16,1.05,0.28,3.68,3.55,4.84,4.07,2.70,4.34,2.49,3.71,3.13,3.32,1.25,-0.56,-0.26,1.59,0.87,-0.56,1 --1.78,1.87,0.19,2.33,0.28,2.26,3.97,2.99,3.15,5.00,4.89,3.23,2.46,2.04,3.09,-0.29,0.27,1.14,-0.90,1.93,1.42,1 -0.76,0.57,1.02,3.47,2.30,5.04,1.86,2.16,4.63,5.24,3.96,3.40,2.61,0.75,1.26,-0.36,0.96,1.46,0.10,1.14,-1.11,1 --0.46,0.39,-0.84,-0.82,0.08,-0.03,0.61,-0.50,1.07,1.51,0.94,2.12,6.32,5.00,4.64,5.51,3.11,2.82,1.14,1.85,0.78,2 -1.45,-0.52,0.23,0.23,1.42,0.63,1.97,-0.66,2.72,3.17,0.13,3.72,3.02,4.69,5.69,3.53,1.40,2.38,3.30,0.38,-0.65,0 --0.81,0.20,0.77,-1.25,0.22,0.05,-0.76,1.51,1.14,1.87,1.33,4.59,3.93,4.64,3.90,3.37,2.47,1.23,1.55,-1.75,1.08,2 -0.03,1.51,1.71,1.85,1.31,2.17,1.21,-0.27,3.34,1.22,2.35,2.32,2.09,3.36,5.50,5.06,3.30,2.92,2.40,0.87,0.45,0 -1.75,-0.30,-0.77,0.54,-0.04,0.72,3.00,2.19,4.11,4.22,5.34,2.78,5.34,2.56,3.07,0.52,1.02,0.20,0.91,0.30,1.76,2 --2.03,0.65,0.12,0.23,0.52,0.64,3.38,2.40,5.11,4.91,6.87,2.79,4.74,2.46,2.02,4.40,0.78,0.05,0.46,3.10,-0.64,2 --1.47,-0.18,0.47,1.83,-0.67,-0.01,2.49,0.09,2.53,1.37,3.31,5.45,4.64,3.97,2.59,4.22,1.57,1.67,1.17,1.78,-0.65,2 --0.61,0.97,1.95,1.00,1.23,4.25,4.53,3.33,4.65,2.15,1.17,1.82,1.44,0.70,0.01,-1.39,1.28,1.98,-0.34,-0.25,-0.25,0 -1.43,1.99,3.89,2.19,5.71,4.69,5.55,5.74,4.12,4.38,3.81,1.57,2.28,-0.89,1.44,-1.80,1.06,-0.90,-0.69,-1.27,1.15,1 --1.00,1.02,0.90,-0.26,-1.48,-1.44,1.76,0.44,2.64,2.48,2.94,2.60,3.97,3.99,7.57,4.13,3.42,1.56,1.64,1.29,0.20,0 --1.00,1.59,-0.79,1.62,-0.33,-0.26,1.08,1.55,0.11,0.55,4.66,3.36,3.51,6.92,3.69,4.02,3.45,2.38,0.13,1.55,2.36,2 -1.11,0.21,-1.12,2.13,-1.67,1.94,2.90,4.23,3.43,6.10,5.16,3.05,2.89,3.78,2.20,0.59,-1.12,-1.49,-0.13,0.69,-0.12,1 -0.42,-1.30,1.65,1.33,1.35,1.74,1.08,1.78,1.27,2.56,0.96,2.41,2.66,5.23,6.80,4.41,3.01,1.30,2.25,1.44,0.92,0 -1.13,-0.32,0.04,-0.85,-0.21,-0.10,-1.01,0.69,1.70,3.35,4.01,2.35,3.98,6.02,4.66,3.04,1.86,1.47,1.07,2.71,-1.32,2 -0.17,1.23,1.29,0.89,0.47,4.42,3.73,3.47,4.72,3.68,2.56,5.27,2.10,2.71,-0.10,0.51,-1.61,1.46,-0.51,0.05,-0.45,1 -1.54,0.07,2.57,2.61,2.78,4.56,4.93,4.30,2.91,3.79,3.87,1.02,0.56,-0.01,1.61,1.01,-1.33,0.97,-1.26,-0.40,0.43,1 -0.16,0.35,1.51,1.53,1.83,3.18,4.01,1.96,2.74,1.03,2.94,1.65,0.55,2.80,2.57,1.18,2.20,1.66,1.59,-0.18,-0.70,0 --1.98,0.20,-0.81,-1.05,-0.65,-0.49,-0.23,0.78,2.44,2.69,3.42,4.05,4.09,2.75,6.34,2.93,3.33,0.33,-0.12,1.33,1.46,2 -0.86,0.10,-0.82,2.92,3.27,4.86,2.92,3.63,1.07,1.58,1.96,1.40,0.80,2.46,2.15,2.29,1.71,1.28,2.80,-0.61,0.44,0 -2.05,1.15,-1.01,1.11,-1.17,-0.29,1.11,2.42,1.11,0.60,3.02,1.30,3.20,5.20,6.67,4.10,3.18,2.25,1.28,3.00,-0.67,2 -1.45,1.89,-0.41,1.22,2.48,2.38,7.05,2.90,2.64,1.12,3.76,3.16,3.00,3.20,2.49,2.78,1.86,1.74,-0.13,0.81,-1.84,0 -0.49,0.36,1.61,2.02,-0.76,3.06,2.70,2.50,5.52,4.04,4.02,2.74,2.78,3.68,2.29,-0.38,-0.44,-0.43,-0.09,0.21,0.00,1 -1.26,1.98,0.66,2.98,4.42,2.91,4.09,2.58,2.76,1.78,0.92,1.60,1.20,2.24,2.65,2.24,1.00,2.14,-1.78,0.95,-0.35,0 -2.23,1.12,1.53,2.26,4.33,3.71,6.10,4.21,3.08,3.29,3.46,1.82,0.96,0.23,0.69,0.20,2.30,-0.12,-1.25,-1.40,0.05,1 --0.35,-0.46,-0.40,-0.55,-0.85,0.87,0.71,2.43,1.50,3.34,3.73,3.50,5.18,4.83,4.50,4.51,2.50,0.20,-0.99,-0.57,1.46,2 -1.30,1.17,0.24,2.18,2.33,4.95,4.08,3.59,2.05,1.00,2.71,3.02,1.14,2.57,2.66,3.59,3.31,2.48,0.56,2.27,0.50,0 --2.17,0.54,-0.29,-1.61,0.61,-0.94,2.20,4.01,3.05,5.59,5.29,4.17,5.16,1.54,3.74,2.04,-0.70,1.56,-0.41,-0.43,-0.30,2 -0.41,0.30,2.18,1.89,3.46,3.93,3.58,3.81,1.70,1.88,0.63,0.04,1.93,2.38,2.32,1.34,1.88,1.44,0.22,1.20,-1.01,0 -0.74,1.05,1.06,4.32,3.32,4.50,5.42,4.54,4.53,3.93,2.61,0.97,-1.89,-0.31,1.88,1.46,0.63,-2.64,0.77,-0.18,-0.02,1 --1.48,0.27,-0.54,1.98,1.41,2.39,2.01,3.02,4.92,2.03,6.83,4.17,1.25,3.10,0.28,2.19,-0.06,0.68,-1.25,-0.57,-0.40,1 -0.09,1.64,1.19,3.40,2.10,3.98,4.50,3.54,1.16,1.47,2.15,-1.69,0.75,0.54,0.96,1.41,1.11,0.91,0.95,0.66,-0.50,0 -0.34,0.09,0.33,0.76,0.10,4.11,3.33,5.16,4.26,4.80,3.72,3.72,0.82,1.49,0.56,0.90,-2.70,-0.63,2.50,0.18,-2.44,1 --0.19,-0.07,1.39,0.80,3.41,0.81,3.88,4.25,3.58,5.97,5.33,2.19,2.28,1.05,4.10,0.65,-1.61,0.95,0.29,0.83,1.09,1 --0.98,-0.05,-1.14,1.24,-0.15,0.13,-0.24,0.45,0.63,0.50,0.77,2.31,3.54,4.70,5.71,4.21,4.90,3.84,2.68,1.71,0.88,0 -0.98,-0.14,1.34,1.47,-0.11,4.06,4.15,4.02,4.38,3.34,3.29,2.09,0.82,0.18,0.57,-0.03,1.30,1.92,-0.91,0.12,-0.38,1 -0.70,-1.12,-0.19,-0.34,-0.83,0.09,0.60,1.40,0.10,1.73,3.06,6.31,4.45,4.02,5.75,3.03,1.32,1.42,2.16,-1.46,0.98,2 --0.49,1.04,-0.28,-0.97,1.50,0.57,1.77,1.89,1.50,3.08,2.91,4.22,5.52,4.30,5.16,2.08,4.00,1.84,0.02,-0.63,0.89,2 -0.01,-0.47,-0.20,2.71,3.35,2.47,5.84,5.33,4.46,4.58,2.34,-0.02,-1.51,0.24,-1.62,-1.04,0.61,-0.32,-0.49,0.33,0.78,1 -0.45,1.05,0.45,1.74,0.77,2.17,1.07,0.75,1.82,1.18,1.25,1.61,1.53,3.94,4.25,3.04,3.78,1.46,0.24,-0.85,1.03,0 -0.80,0.86,-0.11,1.46,1.82,3.12,5.01,2.31,2.60,1.99,2.25,1.38,1.62,3.00,1.07,2.16,1.16,1.43,1.02,-1.01,-2.31,0 --0.55,-0.82,-0.43,0.85,1.84,0.80,0.83,1.44,0.37,2.28,1.80,2.85,3.20,4.76,3.30,4.40,4.55,1.61,0.62,-1.04,-0.70,0 --0.50,0.38,0.70,1.15,0.42,0.96,3.44,1.99,2.35,3.97,5.50,3.32,2.21,0.56,1.20,0.44,0.55,1.12,-1.60,-2.06,-1.26,1 -0.07,0.77,-0.73,-1.20,0.98,3.37,2.90,3.95,3.24,4.09,5.78,4.93,3.23,1.68,1.12,3.12,-0.20,2.55,1.05,0.45,-2.03,1 -0.18,0.14,1.97,0.62,2.42,2.72,5.14,2.86,2.20,2.83,4.01,0.96,-0.18,1.36,0.64,2.46,-1.05,0.92,1.95,0.98,0.32,0 --1.00,0.14,2.15,2.55,4.92,5.30,4.32,4.68,5.71,2.40,1.35,1.40,1.80,1.69,-0.23,0.38,1.96,0.17,0.79,2.05,0.41,1 -0.57,1.85,-0.47,1.91,0.38,-0.35,0.86,2.21,-0.66,0.56,1.26,1.61,4.56,5.13,4.92,5.05,3.03,4.95,3.08,0.77,0.82,0 -0.50,0.13,0.73,1.73,2.93,3.55,2.83,3.56,3.60,2.76,4.51,3.13,0.58,1.39,-0.67,1.86,0.33,-0.10,0.15,0.75,-0.39,1 --1.22,-1.18,0.94,0.61,5.57,4.00,6.76,4.78,4.11,3.07,2.35,2.64,-0.08,1.05,0.71,1.01,1.12,1.25,1.00,-0.02,2.19,1 --0.64,-0.40,0.77,0.59,1.09,1.34,1.31,1.60,1.77,1.73,0.38,1.18,1.71,3.10,3.24,3.54,2.60,3.63,1.59,0.88,0.85,0 -0.06,0.16,0.71,1.74,2.24,0.41,3.78,3.69,2.90,2.18,0.92,2.68,3.47,1.09,3.09,1.82,3.27,1.29,0.22,1.65,3.67,0 --0.01,3.20,3.57,2.18,2.42,3.07,5.96,3.05,3.17,1.47,2.19,0.13,0.63,3.39,0.89,-0.46,-0.82,-1.43,-1.03,-1.96,-0.20,0 -0.12,0.15,-0.06,-0.97,0.32,0.86,1.95,3.52,2.07,4.50,8.50,3.12,3.29,3.66,1.65,-0.26,0.48,2.47,2.05,-1.47,1.64,2 -0.45,1.80,1.44,0.06,1.31,-0.25,2.24,2.17,2.83,3.83,5.80,3.25,1.35,1.64,3.53,1.86,-1.23,0.30,-1.34,-0.43,1.48,1 --0.33,-0.15,0.19,1.54,0.70,0.70,2.34,2.24,1.27,1.08,3.15,4.70,1.08,3.45,4.53,3.35,2.24,0.54,1.11,-0.61,-1.34,0 -0.03,0.35,0.78,0.81,-0.65,-0.12,1.96,1.46,2.22,5.78,5.05,3.11,2.26,2.94,1.16,2.33,-0.75,0.99,0.15,-0.94,0.30,2 --0.14,0.63,1.76,1.08,3.94,5.46,7.49,5.07,5.82,2.82,5.07,1.06,2.10,1.89,-0.24,1.02,1.72,-0.10,1.19,0.03,-1.35,1 -0.26,-0.67,0.26,0.94,0.40,3.12,2.03,0.99,1.95,0.85,1.03,0.83,3.27,3.50,3.05,3.37,3.25,1.11,0.76,-1.12,1.58,0 -0.12,-0.33,1.63,1.97,-0.42,3.12,3.23,3.63,3.56,1.44,1.45,1.70,2.66,2.16,3.21,1.39,2.24,1.61,1.50,-0.02,0.31,0 --1.56,-2.15,0.99,-0.28,-1.06,0.99,1.60,2.86,4.20,1.78,3.62,5.14,4.83,4.15,3.39,5.80,0.71,0.12,-0.42,-0.64,-0.28,2 --0.16,-0.45,-1.16,0.50,0.12,-0.43,-0.12,0.98,3.50,2.89,4.11,4.50,3.69,3.83,3.93,3.36,1.90,0.57,1.20,0.86,-1.12,2 --1.28,0.36,1.14,2.87,2.56,3.28,5.61,4.37,2.82,4.35,1.91,2.31,1.02,1.82,3.38,2.80,0.98,0.72,0.31,-0.99,1.02,0 --0.93,0.44,-1.24,-0.56,-1.38,-0.05,3.32,2.86,2.98,4.75,4.93,5.85,4.07,2.09,2.62,3.12,1.17,0.53,0.12,-0.25,-0.29,2 -1.03,1.39,-0.81,1.89,4.47,1.80,5.34,5.82,3.03,4.39,4.12,3.69,2.59,3.60,-0.42,-2.02,2.37,-0.41,0.62,-0.80,0.26,1 -0.33,0.26,-1.46,0.26,-0.45,1.14,2.40,1.37,0.70,1.96,4.74,3.52,3.94,3.65,5.62,6.86,3.20,2.94,3.06,1.73,0.44,2 -0.30,3.18,0.81,2.77,3.33,4.29,6.46,3.08,3.24,1.36,0.75,1.74,0.31,0.92,1.05,1.02,1.18,1.83,-0.58,1.67,0.67,0 -2.01,0.66,-0.31,0.65,1.68,2.95,7.04,5.00,6.20,2.58,2.53,3.21,0.20,-0.06,1.00,-0.01,2.85,0.66,-0.07,0.54,-0.67,1 --1.04,1.48,2.05,0.77,1.10,1.03,1.35,4.66,4.89,5.71,5.87,3.33,1.92,1.46,2.51,0.02,-0.17,1.16,-0.58,0.00,0.45,1 -0.76,0.59,0.77,-2.56,-1.15,-0.89,1.98,2.95,3.03,3.73,6.41,5.91,5.30,3.65,2.08,1.45,0.69,0.86,0.99,-0.03,0.20,2 -0.23,1.26,0.29,0.84,0.58,0.34,0.01,1.78,-0.59,0.91,2.62,2.44,3.56,4.91,5.37,4.04,2.74,3.26,3.00,1.23,1.23,0 --0.41,1.65,3.03,2.08,4.00,3.75,4.85,6.65,2.58,3.76,1.25,1.14,-1.10,0.67,1.32,-1.80,0.13,0.23,0.29,-0.72,-1.67,1 --0.56,-0.63,0.77,0.69,0.83,-0.13,0.04,-1.21,-1.01,-0.16,1.97,1.59,3.44,6.03,6.28,4.21,3.25,3.44,1.68,1.82,1.40,0 -0.46,0.54,0.74,1.01,1.55,2.28,3.09,2.82,1.95,1.84,2.44,0.59,4.53,2.80,4.25,3.77,1.10,1.47,-0.22,2.38,-1.05,0 -0.21,0.84,0.68,2.54,2.90,3.23,3.95,3.66,2.36,2.92,0.79,2.65,2.41,1.22,5.02,2.26,0.08,0.29,0.47,0.10,1.14,0 -1.35,0.45,1.09,2.88,2.56,3.93,1.74,2.30,2.56,2.31,1.65,0.77,2.01,-0.75,2.84,2.37,0.35,1.64,1.72,1.65,-0.97,0 -0.93,-1.73,1.06,0.69,-0.12,3.32,0.78,2.17,2.57,4.26,2.83,2.35,4.36,2.22,3.00,3.01,2.43,2.54,1.73,-0.12,1.42,2 -0.72,0.58,1.48,1.07,2.24,3.43,4.40,2.99,5.64,5.26,6.23,4.13,0.39,0.23,1.98,1.06,1.14,-0.13,1.47,1.39,-0.41,1 --1.38,1.83,0.16,-0.30,0.76,1.56,4.71,4.42,3.24,3.94,6.12,5.07,4.45,3.90,1.10,1.68,-0.60,-1.39,0.78,-1.35,0.35,1 --0.20,0.79,2.22,-0.92,-1.24,-0.09,0.24,2.06,1.67,1.37,5.79,4.91,2.75,3.38,1.43,0.57,-1.15,1.32,-0.08,-1.48,-1.12,2 --0.58,1.11,-0.32,2.15,-0.76,4.37,3.89,4.09,3.39,4.02,5.83,4.77,1.30,0.75,0.21,0.15,-0.91,1.31,-0.10,0.00,-0.61,1 --0.39,-0.65,0.13,-0.87,-2.89,-0.26,0.94,1.96,2.52,4.08,4.52,5.16,2.75,3.69,4.03,2.87,1.31,2.52,2.31,-0.07,-0.69,2 -0.24,0.48,1.91,-0.10,1.06,0.47,1.17,-0.72,-0.81,2.48,1.36,2.00,5.12,6.14,5.04,4.32,3.23,3.66,1.28,2.10,-0.54,0 -1.89,-1.65,3.52,-0.59,0.94,1.54,2.29,3.50,5.07,4.48,5.62,4.17,2.94,5.39,1.83,1.83,-0.38,-0.30,0.48,0.63,1.06,1 -0.55,0.65,0.12,1.20,2.59,1.76,0.65,0.55,-0.18,1.85,1.61,1.85,2.82,2.33,4.94,3.77,3.08,1.83,0.93,2.19,0.08,0 -0.01,-0.66,-0.20,2.22,-0.26,-0.65,-0.34,0.85,-1.29,1.21,1.40,3.50,4.89,6.29,4.63,3.41,3.44,0.74,2.56,1.11,-1.70,2 --1.54,0.83,1.71,2.32,3.39,2.19,4.72,2.72,3.60,1.78,2.13,1.92,2.02,2.40,3.80,1.78,1.92,0.01,1.17,1.52,-0.14,0 -0.04,-1.24,1.82,0.80,0.51,1.58,1.82,3.36,4.32,2.94,5.86,4.58,3.03,1.90,3.05,1.69,0.09,0.90,0.53,0.75,0.76,1 --2.48,0.59,1.00,2.11,-0.28,6.48,4.47,3.57,3.15,3.61,6.02,5.39,2.66,3.01,1.74,3.10,-0.15,-0.18,-1.70,-0.23,0.66,1 --1.61,0.49,0.77,1.26,3.02,5.91,3.72,4.50,4.86,3.98,3.59,1.32,2.16,0.86,1.45,1.05,-0.45,-0.03,-0.58,1.08,0.32,1 --0.66,0.90,2.30,2.65,5.12,5.22,7.24,5.13,5.09,1.31,1.26,-1.43,0.39,1.96,1.48,1.88,2.57,0.82,-0.17,1.43,1.84,0 -0.55,1.79,0.57,-1.30,-0.07,1.58,1.65,2.04,3.22,5.93,6.08,4.15,3.24,2.72,2.24,2.42,1.84,-0.16,1.14,0.83,0.30,2 --0.60,1.26,4.08,4.10,3.00,3.93,7.36,5.57,4.22,1.48,1.56,1.36,-1.06,-0.63,1.48,1.86,1.36,-0.50,0.98,-2.27,-0.30,0 -0.30,-0.17,0.09,0.59,-0.27,2.30,0.72,1.22,1.50,1.78,1.00,3.60,3.47,2.14,3.70,2.92,1.93,1.95,-0.09,3.57,-0.86,0 --0.86,0.01,-1.22,0.53,0.94,1.06,1.78,3.37,4.69,3.26,7.43,5.51,3.11,1.74,1.54,2.26,-0.04,-1.36,-0.54,0.73,-1.77,1 -1.22,-0.80,1.28,0.80,0.35,0.82,4.75,2.34,3.39,4.17,3.61,2.61,5.55,4.92,2.41,2.69,-0.92,-0.14,1.72,0.47,2.23,2 --1.36,-2.60,-0.30,-1.64,0.40,-1.89,1.12,3.11,3.25,5.81,4.53,3.63,4.55,3.65,1.24,0.75,-0.48,-0.94,0.17,-1.84,2.02,1 --0.85,-0.76,-0.47,0.16,0.07,-1.24,0.98,2.08,3.91,6.25,6.50,6.12,3.75,2.99,2.70,2.86,0.39,-0.02,-0.80,0.13,1.20,2 --0.71,-0.82,-1.12,0.63,0.24,0.27,1.17,0.46,1.27,1.62,4.46,1.53,2.74,4.47,5.39,3.77,3.49,2.42,1.12,0.23,-0.49,0 --0.29,-0.38,-0.13,0.01,-1.08,-0.69,2.85,1.21,1.00,0.98,4.27,4.13,4.26,2.68,4.06,2.21,0.01,0.88,-1.00,0.60,0.04,2 --2.41,-1.70,-0.48,1.97,-1.42,-0.01,3.29,1.32,6.72,5.35,4.81,5.73,5.68,4.82,1.96,1.28,-0.17,-0.31,-0.17,-1.00,-0.16,2 --0.63,-0.78,1.64,1.61,1.96,2.96,1.92,3.86,3.63,5.94,6.88,5.73,2.87,4.20,2.86,0.38,-0.75,-0.01,0.90,0.70,1.13,1 -1.05,1.70,-0.73,0.21,1.72,2.77,2.05,1.55,0.42,2.58,0.91,1.96,1.77,3.77,4.06,2.31,1.33,0.76,-0.06,-0.10,1.77,0 -1.29,0.41,1.50,2.03,4.17,5.50,6.15,5.78,3.46,4.47,2.57,2.52,-0.62,0.81,0.21,-2.40,-0.66,-1.26,1.14,0.05,0.78,0 --0.84,0.26,0.02,-0.32,0.38,2.29,0.10,3.69,3.41,6.12,6.00,3.05,3.78,2.39,1.80,1.86,-1.00,-0.44,-0.96,0.37,-0.86,1 -0.99,0.63,0.69,0.49,0.90,0.98,1.18,4.08,4.03,6.24,6.59,4.32,2.69,3.95,2.08,-0.48,-0.49,-0.91,-0.20,0.97,1.31,1 -0.71,-0.86,1.22,0.99,1.33,1.67,2.94,4.75,3.53,1.80,1.60,2.60,2.08,-0.02,2.02,1.16,3.19,1.46,0.80,-0.02,0.32,0 --1.15,-0.41,0.57,-0.18,-0.66,-0.16,2.49,2.63,2.06,3.09,3.08,4.77,3.46,3.14,1.83,1.43,-0.27,0.90,-1.44,-0.56,0.58,2 --0.09,0.60,0.78,-0.23,0.60,-0.13,1.96,1.67,1.40,2.15,4.94,3.66,3.11,3.95,4.20,1.30,2.30,1.09,-0.78,1.09,-0.75,2 --0.03,0.71,1.22,0.40,2.54,2.03,4.57,2.46,1.52,2.42,2.37,2.67,-1.06,2.27,2.58,0.50,3.51,1.13,0.29,0.56,0.75,0 --0.04,0.83,1.42,-0.03,1.19,-0.29,-0.26,0.65,1.53,4.13,5.15,5.10,3.64,3.72,4.38,2.77,2.39,1.84,1.17,-0.00,1.20,2 --0.32,2.45,1.42,1.94,1.75,5.00,4.42,2.81,3.67,3.20,4.63,4.15,1.63,0.51,1.59,1.18,1.36,1.83,-1.15,-1.01,0.61,1 -0.16,-1.65,-0.55,1.54,-0.12,-2.49,-1.30,-1.51,0.69,2.39,2.59,2.15,4.21,4.63,6.21,3.97,4.16,2.87,3.15,3.83,-1.10,2 -0.70,-0.20,2.68,1.97,4.03,3.74,4.60,3.17,6.06,3.05,2.18,2.35,0.78,3.46,-0.68,2.56,-1.06,0.02,0.98,-0.11,0.33,1 -1.24,0.29,1.16,-0.58,-0.25,4.59,2.47,4.38,4.99,4.80,3.82,4.32,1.87,0.90,2.22,1.39,0.97,-0.36,0.35,-0.26,-0.45,1 --0.17,1.14,0.71,3.05,4.96,6.73,5.80,6.51,3.73,2.38,2.36,2.42,0.61,-0.50,-0.94,1.91,1.10,-0.65,-0.07,-0.42,-0.76,1 --0.95,-0.28,0.51,-0.19,0.43,2.19,3.01,0.11,2.24,2.81,4.47,2.67,2.44,3.19,4.44,3.19,2.18,2.58,1.10,1.26,-0.79,0 -1.89,0.68,0.86,3.12,1.62,4.19,5.37,4.63,3.72,2.74,1.93,1.27,2.70,0.45,1.62,1.50,1.55,1.59,-1.16,-2.76,0.44,1 -1.20,0.62,1.85,3.33,3.55,3.65,4.84,3.54,5.24,2.70,1.64,1.81,-1.19,-1.26,2.37,-0.51,2.27,0.91,-0.54,-0.13,0.91,0 --0.54,-0.58,0.76,-0.70,-0.14,0.65,2.26,2.51,3.16,3.01,3.35,5.04,4.92,4.22,2.19,1.27,0.05,-0.27,-0.90,0.01,0.96,2 --0.58,0.88,-0.34,0.41,-0.12,-0.06,-0.15,3.46,0.53,3.24,4.82,3.94,3.53,3.99,6.01,3.06,2.88,0.33,1.84,0.41,1.00,2 -1.21,0.42,0.51,-0.88,-0.02,0.30,-0.17,1.08,0.69,2.50,2.51,2.74,4.50,5.38,8.72,4.34,4.05,2.22,0.54,-0.44,-1.01,2 -0.68,2.87,1.84,2.08,3.00,4.45,4.64,4.72,4.39,2.14,2.03,0.27,0.95,0.50,-0.43,0.10,0.34,1.18,0.82,0.55,-1.32,0 --1.28,0.23,-1.18,0.83,1.96,2.63,2.98,2.45,3.05,4.53,5.99,3.50,4.20,2.86,3.52,0.76,1.56,1.37,0.02,-0.62,1.50,2 --0.17,-0.02,2.03,1.10,0.73,0.34,2.43,1.27,0.98,5.69,6.82,4.21,4.97,2.68,4.06,2.36,1.49,0.88,-0.38,3.11,-2.78,2 --0.98,-1.60,0.12,0.25,-0.23,1.99,2.02,2.52,4.06,5.65,5.10,3.74,3.89,2.43,3.13,0.81,1.44,0.10,-0.09,-1.47,-0.89,2 --0.42,-1.57,0.53,0.19,0.68,-0.08,1.86,2.42,5.16,5.92,6.66,5.05,2.99,1.51,3.06,1.73,0.35,0.19,-2.26,-1.19,-0.89,1 -1.27,0.43,0.39,1.30,2.93,0.23,4.28,4.45,2.39,3.75,5.70,6.58,2.00,0.40,1.28,2.15,-0.10,-0.04,-1.33,-0.50,0.92,1 -0.21,0.13,0.09,2.48,2.25,1.47,4.15,3.34,6.44,3.89,5.56,3.10,1.92,1.62,1.81,0.36,0.43,-0.52,0.26,-0.70,-0.45,1 --1.16,0.56,0.36,-0.93,0.12,0.64,-0.73,0.55,0.10,0.96,1.82,2.56,3.16,6.98,6.74,4.98,4.55,1.27,2.12,1.63,-0.65,2 -0.24,-2.18,-0.03,-1.10,-1.69,1.02,1.07,1.47,3.87,6.01,4.86,4.34,3.24,3.72,2.65,0.31,1.88,0.52,2.19,-0.98,1.22,2 --0.00,2.49,0.16,4.10,4.82,5.20,5.83,3.84,3.80,2.93,0.40,2.87,0.58,1.18,1.44,0.56,-1.35,0.01,0.28,2.05,-1.12,1 -2.42,-0.41,-0.73,-0.28,0.93,-0.35,0.69,1.86,2.14,3.17,5.91,3.44,3.48,5.26,2.84,2.09,1.71,-0.52,0.49,1.44,-0.10,2 -0.73,-0.31,1.97,0.72,4.14,6.60,6.36,3.58,4.14,3.34,0.82,-0.45,-1.36,-0.20,-0.83,0.94,0.21,-0.30,0.47,0.87,-2.23,0 -0.29,0.82,2.47,2.23,4.88,5.53,6.19,4.67,4.83,4.34,2.55,2.42,3.06,0.99,-0.71,1.08,-0.79,-0.44,-0.82,2.42,0.71,1 --1.04,-1.45,0.88,2.24,2.70,4.18,3.70,3.25,4.19,1.88,2.34,1.37,0.61,0.19,1.03,-0.28,-1.08,-0.01,0.32,0.06,0.88,1 -1.46,-2.93,0.83,-1.77,-0.24,-1.03,0.52,1.02,1.14,0.50,0.57,3.26,4.26,4.42,6.95,4.66,3.36,2.76,1.21,1.57,-1.16,2 -0.03,0.50,0.32,-1.68,-0.22,1.70,1.56,2.33,3.02,3.09,5.04,3.84,3.12,2.86,2.21,4.43,2.27,1.40,0.74,1.12,-0.73,2 -0.66,2.13,2.15,2.03,1.56,3.59,3.33,3.74,1.37,4.11,1.76,2.41,1.24,0.58,2.28,2.75,3.05,0.76,2.02,0.37,0.95,0 --0.81,-0.07,0.87,-0.50,1.10,0.37,2.00,0.30,1.06,2.56,5.08,3.81,4.65,6.65,4.08,2.31,1.97,0.52,2.20,2.00,-0.47,2 -0.19,2.18,1.79,1.12,1.78,2.33,3.24,3.04,5.25,4.26,4.27,3.31,2.61,1.87,1.95,0.20,0.25,-0.42,-0.29,-0.30,0.51,1 -0.30,-0.17,1.57,1.70,4.88,2.37,5.05,4.31,2.17,2.87,2.85,1.88,0.85,3.52,0.83,2.31,1.57,1.14,1.11,1.32,-0.15,0 -1.12,0.40,2.27,1.57,2.60,3.44,3.77,2.60,4.09,3.17,4.59,2.41,2.64,1.36,2.98,2.16,1.32,-0.60,-0.86,0.61,0.03,1 -0.18,-0.01,-0.05,0.49,2.58,1.59,2.62,1.16,2.58,3.26,1.91,1.87,2.06,0.93,2.10,3.28,0.24,0.43,1.75,0.94,-0.51,0 -1.98,1.52,2.80,1.54,-0.34,-0.24,1.68,1.54,2.03,3.77,5.17,5.78,3.53,3.28,2.04,0.69,3.32,-0.20,0.85,-0.83,0.48,2 -0.82,0.84,1.33,2.33,1.16,4.25,5.02,2.47,3.92,3.29,3.87,2.23,-0.50,1.32,0.13,1.91,0.07,0.96,2.67,0.36,-0.97,0 --0.15,-1.56,-1.95,-0.06,0.09,-0.63,2.24,1.97,2.47,1.69,4.65,3.70,4.47,2.55,4.58,3.10,1.57,0.15,-0.79,1.01,1.74,2 --1.56,-0.49,1.38,1.79,4.38,3.81,4.85,4.38,4.11,1.87,3.10,2.40,1.23,0.02,0.59,0.65,-0.02,1.46,0.31,0.61,-0.18,1 --0.48,0.29,0.87,2.46,2.34,4.56,4.37,4.44,4.05,2.62,1.08,-0.49,1.30,0.28,2.24,1.05,-0.95,0.11,0.46,-0.21,1.31,0 -1.40,0.98,2.03,2.35,2.35,0.39,2.62,2.60,2.11,0.99,2.27,1.42,0.08,2.61,3.19,3.81,2.26,0.90,2.38,0.23,-0.51,0 --0.26,2.13,-0.27,-0.57,0.65,2.42,3.35,5.24,2.96,3.98,2.92,2.76,3.14,1.86,-0.35,2.13,-1.13,0.83,-0.64,1.01,-0.57,1 --0.09,-0.99,0.50,2.90,2.74,2.56,4.07,2.95,4.34,2.73,1.20,2.34,1.08,0.60,0.56,-0.11,-0.41,-1.36,-1.34,0.16,0.31,1 --0.11,-0.07,2.16,2.33,2.59,2.38,3.99,1.94,4.37,3.59,2.52,2.69,0.49,0.48,1.52,1.14,2.72,-0.13,-0.59,0.38,0.54,0 --0.36,0.10,0.76,-0.13,1.08,0.31,-0.45,1.44,1.84,0.63,0.98,3.12,1.82,4.40,4.77,3.49,3.78,1.02,0.65,0.37,0.10,2 -0.03,1.30,1.66,0.87,2.57,3.98,3.26,3.02,3.28,3.89,4.28,4.06,1.11,2.11,2.38,0.90,1.41,-0.74,0.18,0.08,1.19,1 -0.07,1.29,0.93,0.57,-0.32,2.42,2.54,3.92,5.62,3.01,3.74,4.12,2.95,2.61,1.65,1.41,1.02,-0.35,-0.43,0.57,-0.21,1 --1.92,-1.12,1.81,3.87,2.73,5.58,5.53,3.94,3.44,4.59,1.45,1.48,-1.56,1.08,-0.71,1.38,1.59,0.58,0.28,-0.13,-1.18,1 -1.14,-1.42,-0.28,0.47,0.48,1.29,0.91,2.75,2.18,3.54,4.61,6.29,1.84,1.77,1.29,0.97,0.80,-0.11,0.94,0.86,-0.52,2 --0.59,-0.26,0.15,1.64,1.62,1.95,4.18,3.24,5.52,4.67,5.17,5.83,2.77,2.26,2.80,1.52,1.18,-0.07,-0.90,0.41,-0.31,1 --0.02,1.36,2.41,1.24,2.53,2.28,1.32,1.65,3.96,6.24,6.13,3.22,2.59,1.65,2.45,0.16,-0.63,-0.74,0.51,-2.42,0.40,1 -1.24,0.78,0.51,3.22,3.78,3.53,4.60,4.07,3.94,4.39,3.01,-1.20,0.62,1.76,-0.04,1.14,-0.65,0.51,-0.96,0.06,-0.64,1 -0.09,-2.50,0.58,0.31,-1.28,-0.39,1.05,2.25,2.26,1.87,5.23,4.34,2.62,4.88,4.62,1.73,2.14,0.11,0.48,2.35,-0.71,2 -1.79,-0.76,-0.58,-0.18,-0.13,-0.12,-1.31,0.29,-0.33,2.01,1.38,2.67,5.18,4.78,5.19,4.45,3.33,2.43,0.68,0.44,-0.59,2 -0.05,0.93,1.83,2.15,1.87,3.50,4.32,3.69,3.90,3.43,2.79,1.07,1.05,1.47,0.86,2.10,-0.16,-1.16,-0.82,0.03,-0.77,0 --0.26,1.10,0.98,2.15,0.84,1.67,1.06,2.59,4.01,5.66,6.18,3.10,4.53,2.92,1.92,0.81,0.74,0.05,-0.75,-0.63,0.82,2 -0.46,1.55,1.35,2.48,0.80,1.92,1.53,3.74,2.07,1.68,0.73,3.16,2.40,3.33,1.80,1.44,2.07,2.03,1.06,-1.37,0.41,0 -1.13,-0.24,1.06,2.55,0.26,3.37,2.42,2.87,1.71,4.49,2.00,1.83,3.77,3.18,1.49,3.69,-0.74,1.64,1.49,0.89,-3.88,0 -0.37,1.63,0.92,-0.17,3.30,3.07,3.87,1.82,0.62,2.02,2.67,1.82,1.33,1.02,1.06,1.51,2.11,0.72,2.71,2.13,-1.73,0 --0.84,-1.49,1.01,-2.73,-0.32,-0.83,2.95,0.36,3.45,3.35,2.46,3.30,4.35,2.37,2.89,0.71,1.59,3.24,0.06,1.00,1.11,2 --0.56,0.64,-0.19,0.14,-0.46,0.88,1.66,1.98,1.03,4.77,4.91,5.12,4.58,5.96,5.57,3.13,2.24,1.84,0.32,-1.05,1.36,2 --0.17,-0.85,1.03,0.92,-0.38,0.58,0.05,2.96,1.01,2.59,3.26,3.05,4.49,2.23,4.05,2.51,2.20,0.32,1.71,1.29,-0.59,2 -0.04,-0.03,-0.92,1.49,2.40,3.43,2.76,2.92,2.24,3.04,0.97,2.26,0.59,1.42,2.55,1.51,2.48,2.31,0.40,1.71,-1.23,0 --2.08,0.36,1.52,2.46,2.78,5.65,5.84,5.46,4.63,1.22,2.77,1.69,0.80,1.30,-0.05,0.30,-1.21,0.37,1.61,0.16,-0.54,1 -1.18,1.39,2.02,0.61,1.78,2.07,5.57,3.74,3.55,3.65,4.24,2.40,0.18,1.48,-0.85,1.04,-0.65,0.91,0.72,-0.25,-0.85,1 --0.75,0.92,0.62,1.15,0.36,1.94,3.25,3.61,4.31,3.83,4.96,2.52,1.56,2.65,1.25,0.08,-0.45,-1.01,1.60,-0.56,0.24,1 -0.24,0.37,0.32,2.15,2.72,1.84,3.34,2.15,2.65,2.48,1.50,1.83,1.38,1.69,3.18,0.13,0.09,1.73,-0.20,1.57,0.45,0 --0.90,-1.05,0.51,1.24,1.59,0.14,2.59,2.54,-0.80,-0.35,1.75,3.25,3.70,4.87,3.61,5.16,3.82,0.56,2.03,0.67,-0.27,0 --0.64,-0.05,-0.28,-1.33,0.27,2.16,3.31,3.61,4.95,3.72,5.68,4.98,3.97,2.83,3.02,2.37,-0.22,0.40,2.13,0.24,0.61,1 -0.01,0.51,0.77,0.03,-0.42,2.23,3.90,2.93,3.16,3.11,0.83,2.80,2.59,2.32,3.59,3.68,2.96,-0.18,1.31,0.67,0.63,0 --1.25,1.88,0.35,1.01,-1.52,1.32,3.64,1.57,3.41,3.26,6.04,6.57,3.55,5.68,1.17,1.04,0.50,0.45,2.27,1.60,-0.28,2 --0.52,-0.09,-1.48,-0.27,-0.19,1.35,3.34,1.62,1.58,3.95,3.63,4.49,2.32,3.32,3.35,1.26,-0.07,1.90,-0.15,0.98,-0.65,2 --1.01,-0.33,0.47,1.74,0.07,0.89,1.66,1.81,5.24,4.13,6.05,5.28,4.57,2.29,2.32,2.78,1.59,0.07,0.74,0.27,0.74,2 --0.45,1.82,0.67,3.98,0.87,1.44,1.47,2.73,4.50,2.72,5.33,4.41,2.66,0.63,-0.14,-0.26,0.44,1.86,0.01,2.10,-1.95,1 --0.29,-0.49,1.52,1.60,1.42,2.74,4.30,1.61,3.63,3.31,4.99,4.98,3.44,1.52,0.07,-0.19,-0.28,-0.10,-0.79,1.34,0.27,1 -1.16,0.42,0.42,0.79,1.09,1.82,1.83,2.64,1.30,2.48,2.20,2.20,1.43,4.55,3.76,1.59,3.90,1.35,2.99,1.54,1.09,0 --0.73,2.62,1.46,2.20,1.38,2.85,3.73,2.48,2.84,2.34,0.71,2.75,3.82,2.40,2.35,1.46,0.63,1.95,1.29,-0.83,-0.03,0 -1.30,0.67,0.88,1.35,0.86,2.29,0.66,-0.72,1.81,2.48,0.39,4.33,4.22,5.45,4.77,3.05,3.38,2.52,3.16,-0.27,-0.34,0 -1.21,1.25,-0.20,-0.07,0.61,1.06,1.61,2.77,-0.07,1.83,1.83,2.65,2.98,5.26,5.58,3.15,5.04,3.90,2.50,3.26,0.02,0 --0.61,1.23,0.07,-0.32,0.51,1.69,1.45,1.30,1.43,3.43,4.94,5.39,2.86,3.30,5.37,2.41,2.85,-0.44,-1.23,1.22,0.89,2 --0.27,1.89,-1.32,1.31,-0.08,0.37,0.87,3.23,5.46,6.15,6.44,4.39,2.12,2.57,2.30,1.91,1.27,-1.83,1.16,0.42,-1.49,2 --0.74,0.33,-0.79,0.29,0.09,0.36,-0.20,0.09,0.10,0.27,1.62,3.09,5.59,4.95,5.37,4.17,4.31,2.68,2.38,1.58,0.44,2 -0.11,-1.30,-0.62,-0.15,0.85,1.66,4.18,2.82,5.08,7.63,5.74,4.05,2.66,2.77,1.92,2.73,-0.11,-0.44,1.01,0.84,-0.39,1 -0.78,-1.19,-1.06,1.04,-0.32,0.41,3.27,2.32,5.18,5.02,7.11,4.29,5.08,1.26,2.22,0.15,0.22,-0.83,0.23,-0.99,-1.26,2 -1.30,0.60,0.71,1.23,2.97,3.45,3.38,2.86,4.94,4.46,4.74,3.73,0.42,2.35,0.64,0.22,0.28,-0.69,0.22,0.56,-1.15,1 -0.23,-0.38,-0.03,0.89,1.85,3.81,3.01,1.80,2.47,3.04,0.58,1.60,-0.06,0.54,0.79,-0.63,-0.77,-0.62,-0.40,1.15,0.69,0 -0.64,1.22,2.00,3.77,4.30,3.89,5.08,3.78,6.04,2.73,2.42,0.67,0.40,-0.23,0.58,-1.92,-0.21,-1.27,-0.58,-0.23,-0.01,1 --0.69,-2.10,0.58,1.85,-1.32,0.63,0.53,0.48,-0.21,-0.17,1.75,3.47,5.70,6.93,5.49,4.63,4.46,1.94,4.32,1.34,0.52,2 --0.78,1.72,2.96,1.93,4.84,3.02,4.48,4.12,2.75,3.60,3.95,1.35,1.54,1.08,1.80,3.06,-0.21,-0.93,-0.25,0.36,0.84,1 --1.40,1.29,-0.06,-0.94,2.86,-1.78,-1.84,1.73,-1.04,0.68,1.88,4.69,4.85,6.68,6.28,3.55,4.93,3.28,1.91,3.15,-0.39,0 -0.10,0.12,-0.51,1.19,-1.63,-2.23,-1.51,0.53,1.49,-0.03,3.08,2.48,3.33,4.74,5.25,2.77,3.79,3.09,1.09,2.05,-0.04,0 -1.87,1.16,-1.38,-0.71,-0.97,1.63,1.40,1.82,1.84,3.65,3.89,3.50,3.78,3.20,2.80,2.13,3.11,3.01,1.98,2.13,-0.50,2 --1.32,-0.04,-0.70,1.31,0.80,-1.76,0.82,2.45,1.13,2.63,1.36,3.40,3.84,6.28,4.38,3.25,0.56,2.00,1.56,-0.28,0.20,2 -0.48,0.61,3.33,1.09,3.06,3.98,7.18,4.35,3.76,1.96,2.73,0.42,3.02,2.15,1.72,1.40,-0.41,-0.47,1.35,0.16,-0.73,0 --0.03,0.06,0.83,1.12,2.43,2.54,2.98,4.11,4.14,3.64,6.35,2.63,1.85,1.82,1.44,-0.19,2.34,0.18,-0.51,-2.84,0.93,1 --0.36,0.06,-0.99,0.55,-1.30,1.50,1.49,0.60,0.85,3.06,2.75,2.10,4.05,2.92,5.02,4.31,3.51,2.61,1.06,1.40,-0.77,2 -1.02,-0.22,2.13,3.73,1.96,3.54,6.17,4.13,2.77,4.17,3.83,1.64,1.77,0.83,-0.74,0.33,-0.91,-0.74,-0.12,0.97,-0.66,1 --2.47,0.86,0.46,3.27,2.89,4.21,5.93,5.10,4.19,2.07,3.14,0.98,0.91,0.56,2.51,0.93,1.10,0.56,-0.13,0.90,-0.97,0 -0.29,0.29,0.63,2.20,2.31,2.56,2.24,3.13,1.79,2.19,2.11,1.81,1.23,1.47,3.26,4.32,1.93,-0.86,1.70,1.04,0.64,0 --1.52,-0.81,0.47,2.98,2.61,3.22,4.87,3.69,3.76,3.20,3.69,1.37,2.10,-0.04,1.76,-0.92,-0.58,0.39,0.25,1.57,-0.13,1 --0.54,0.17,1.43,-1.22,-0.74,-0.54,1.69,3.95,3.13,5.30,5.30,4.26,5.26,2.62,1.26,0.10,2.10,0.60,0.18,0.85,-1.82,2 --0.50,-0.26,0.58,0.15,0.39,-0.02,2.13,2.74,5.15,3.12,4.39,6.44,4.49,3.03,2.99,2.22,2.35,-0.98,-0.16,-0.23,0.41,2 -1.35,0.96,-0.85,1.14,0.64,0.80,1.07,2.46,-0.85,0.91,2.53,1.70,3.30,2.78,3.59,2.96,2.84,3.62,0.34,1.73,0.30,0 --2.93,1.04,0.85,0.22,0.35,0.67,-0.22,1.32,0.69,2.24,2.24,4.56,3.51,3.28,7.12,2.33,2.39,2.26,2.90,-0.13,-1.06,2 --0.42,1.65,1.34,1.90,0.73,1.20,2.08,2.59,1.45,2.03,-0.54,1.52,1.44,5.00,3.68,2.10,2.38,3.80,1.95,-0.42,-0.72,0 -1.09,-0.42,2.48,1.50,3.62,6.68,6.54,6.29,3.46,1.78,2.86,0.57,-1.97,1.24,0.05,0.21,0.22,1.08,1.15,-0.17,-0.83,0 --2.82,0.01,1.32,0.02,2.86,2.73,3.38,4.76,5.08,3.67,5.47,3.03,1.62,0.93,-0.03,1.15,-1.37,-0.25,0.04,0.90,-0.40,1 --1.29,-0.26,1.68,0.83,1.65,0.65,0.49,3.11,2.28,4.39,5.89,4.27,3.16,3.32,2.36,0.94,-0.06,0.95,1.46,1.05,0.14,2 -0.27,-0.34,0.11,1.92,1.34,0.41,1.16,1.20,0.99,1.41,1.31,3.70,4.34,4.69,4.71,2.15,1.94,1.70,1.51,2.07,0.13,2 --0.58,-1.20,0.80,-1.95,-0.38,1.02,-0.90,1.31,2.75,3.10,5.39,4.10,3.50,4.20,4.00,2.05,-0.57,1.15,0.52,0.08,-1.72,2 --0.96,1.85,1.67,4.13,2.20,5.20,5.21,5.43,3.42,3.14,3.05,2.44,-0.83,-0.20,2.27,-0.46,-0.14,0.91,1.70,1.42,-0.70,1 --1.32,-0.55,1.72,0.29,0.53,4.14,4.05,5.22,3.30,4.53,4.13,4.56,2.42,1.70,2.65,-0.30,-0.47,-1.88,0.74,0.08,-0.28,1 --0.78,-0.62,-0.05,-0.82,0.40,2.23,0.59,4.10,2.86,3.40,4.84,5.54,4.02,2.88,4.05,1.46,3.37,2.88,0.50,-0.44,-0.34,2 -1.17,-0.21,-2.15,-0.85,0.83,0.91,0.27,1.94,1.08,4.16,4.16,3.22,4.54,3.91,3.21,2.71,1.41,1.37,1.62,0.80,-1.35,2 -0.08,1.33,-0.57,0.44,0.84,5.09,4.89,5.21,4.97,4.09,5.81,3.44,0.63,0.80,1.33,-0.76,0.31,-0.46,-2.67,-0.70,1.03,1 --0.71,0.42,1.37,-0.60,2.28,2.73,3.53,3.61,4.62,4.34,4.38,2.98,3.22,1.25,2.79,0.35,-0.97,-0.24,-1.54,-2.82,1.33,1 --1.75,-0.34,1.55,4.03,5.18,3.45,5.23,4.55,2.39,3.09,1.20,1.08,-1.01,0.78,-2.14,0.59,-0.65,0.08,-0.14,0.71,-1.61,1 -0.48,0.31,-1.16,2.32,1.80,-0.08,0.31,2.58,4.33,4.47,5.52,5.31,4.16,4.25,3.47,3.68,0.66,1.89,0.52,-1.18,-1.57,2 -0.14,1.48,0.68,0.66,2.38,3.68,2.84,2.03,4.61,0.57,3.09,3.00,1.55,3.24,3.14,2.70,0.53,-0.33,1.48,0.12,-0.63,0 --0.63,0.14,1.54,0.37,-2.16,0.16,2.34,3.42,5.65,2.68,6.07,2.75,2.59,3.98,-0.23,0.70,0.87,0.24,0.23,1.23,0.39,2 --0.06,0.63,2.75,0.39,0.88,2.64,5.09,4.32,4.65,4.41,4.11,2.88,1.29,3.08,-0.18,1.10,0.48,-2.22,0.20,0.10,0.76,1 --0.94,0.44,4.50,2.90,4.76,5.26,4.35,3.92,2.56,2.38,1.41,2.43,-1.05,1.36,1.30,-0.33,0.40,-0.82,0.35,0.07,-0.12,0 -0.20,0.93,2.02,1.97,4.08,5.28,5.58,3.88,4.93,4.17,4.65,0.79,1.03,2.25,-1.00,1.06,1.40,-0.89,1.94,0.81,-0.70,0 --0.25,0.43,-0.10,1.80,2.19,2.42,2.21,4.10,4.22,-0.41,0.81,3.22,0.87,1.74,2.22,1.64,2.57,-0.64,1.39,-0.10,-1.58,0 --0.81,-1.78,-0.40,-1.05,-1.71,-0.35,0.59,2.41,2.11,-0.05,1.27,3.07,4.93,5.38,5.53,2.99,0.16,1.75,2.40,1.90,0.53,2 --0.45,1.52,0.51,0.43,0.76,4.24,3.25,1.96,2.07,2.41,1.30,2.78,3.15,2.39,2.56,2.44,0.51,0.54,1.41,-0.40,-0.17,0 -0.42,0.52,-0.90,-0.06,2.06,4.19,2.23,-0.24,1.30,0.25,1.52,1.68,3.64,4.17,3.36,4.88,3.70,1.38,1.08,-1.11,0.83,0 -1.22,2.15,1.53,1.33,1.47,4.57,5.35,3.78,3.21,3.71,3.80,3.47,0.36,1.15,2.84,-2.99,0.53,-1.05,0.59,0.03,1.20,1 -1.43,0.89,1.40,3.69,4.78,3.86,6.47,5.55,5.57,2.51,3.50,2.42,1.56,1.89,0.43,1.14,1.17,-0.66,1.26,-0.42,-1.00,1 --1.12,1.60,1.04,4.10,1.87,4.93,5.13,5.26,4.79,3.18,2.35,3.11,-0.03,-0.03,-0.96,-0.46,-1.14,0.52,-1.96,0.78,-0.69,1 --0.26,-0.15,-2.08,-0.46,-0.46,0.50,2.18,3.47,2.36,3.15,5.95,4.57,3.23,4.51,2.06,1.31,1.24,1.40,-2.22,-0.30,0.00,2 -0.57,-0.21,0.45,1.61,1.27,2.75,4.72,3.77,3.15,2.61,2.00,0.73,0.74,1.16,0.75,0.89,-0.01,0.45,-0.63,-0.47,0.69,1 --0.29,-2.21,0.70,1.92,-0.42,2.13,2.95,3.28,4.81,4.53,4.51,3.35,3.86,1.35,0.63,1.17,-0.51,1.66,-0.41,0.02,0.37,1 --1.60,2.46,2.05,0.76,2.46,3.33,5.72,4.85,4.93,3.81,2.94,1.10,-0.07,-2.31,1.50,-0.80,1.34,0.13,0.56,0.23,-0.81,0 -1.39,-0.93,-1.89,0.87,1.24,2.93,1.92,5.04,3.20,5.69,4.66,5.67,3.32,3.82,2.51,1.24,0.38,-2.09,0.80,0.06,-0.78,1 --2.19,1.16,0.54,1.37,0.57,-0.57,-0.36,0.27,1.78,1.30,2.29,2.91,4.42,6.21,7.72,4.58,3.50,3.50,3.44,1.74,0.40,0 -1.74,0.65,0.94,1.22,-1.34,0.62,2.05,0.41,0.48,0.71,4.54,2.11,3.63,4.70,5.44,4.74,2.52,2.03,2.16,0.46,-0.82,0 -0.44,-0.37,0.06,0.21,-0.22,2.44,1.80,3.58,3.08,4.82,5.24,5.03,3.21,3.14,1.65,-2.70,-0.55,-0.90,0.01,0.35,1.60,1 -1.08,0.95,-0.27,0.88,2.20,1.11,2.43,4.19,0.50,2.79,1.61,1.76,2.44,4.57,2.86,3.19,2.54,2.05,0.76,-0.94,-0.04,0 -1.29,-0.58,1.91,1.24,2.52,1.51,1.23,0.76,1.10,1.09,2.31,2.71,3.61,2.98,3.88,4.41,3.58,1.95,1.26,1.26,0.67,0 -1.48,0.39,1.24,0.41,-0.39,0.95,2.56,0.79,1.67,2.69,1.70,0.57,4.15,2.28,4.50,4.21,3.33,1.51,2.14,0.93,-1.14,0 -1.70,-2.05,1.39,-0.95,0.28,1.24,1.43,2.26,4.91,3.42,5.89,5.27,3.17,2.46,2.43,0.10,0.02,-2.15,0.21,0.39,1.17,2 --0.10,-0.75,-0.05,2.05,-0.92,1.39,3.51,2.60,4.08,4.33,6.36,2.71,2.25,1.12,0.95,1.22,1.50,1.16,-1.19,-0.46,-0.68,1 --1.06,-0.97,-0.94,0.82,-1.31,2.11,4.22,3.34,4.48,5.45,5.48,5.18,4.03,3.17,0.47,-0.21,1.00,0.12,0.53,-0.57,-0.35,1 -0.46,-0.07,1.87,-0.69,-0.04,0.60,1.56,1.97,2.78,4.32,1.62,3.24,4.85,3.72,5.64,3.27,1.78,-0.04,0.70,0.54,-0.22,2 --0.29,-0.84,1.51,1.19,-0.00,0.61,-1.14,-0.62,2.29,0.53,2.97,2.16,3.35,5.32,6.15,5.77,4.12,5.11,1.66,0.13,0.33,2 -0.05,0.18,2.43,1.72,2.67,3.62,4.45,5.05,4.40,4.09,2.22,1.59,0.85,-1.17,2.18,1.00,1.49,-0.07,2.09,-0.38,-0.82,1 --0.06,0.11,3.31,2.88,4.67,3.51,7.53,5.85,4.23,3.97,2.11,2.05,0.08,-0.10,-0.86,-0.68,-1.89,1.27,1.29,0.12,-0.16,0 --1.25,-0.93,1.22,-0.22,2.19,2.75,4.05,1.70,2.65,0.35,2.27,1.11,4.55,2.95,4.39,2.64,3.42,2.28,0.67,-0.47,-2.46,0 --0.16,-0.76,0.00,-0.17,-0.16,0.54,2.33,3.38,4.44,5.86,3.63,4.43,6.37,2.83,1.16,1.55,-1.06,-1.33,0.70,0.78,-0.26,2 --0.13,-1.65,-1.34,-0.84,0.92,-1.11,0.15,1.23,1.41,0.99,1.64,3.16,6.49,3.80,6.13,5.89,3.85,2.57,3.07,1.60,-0.18,2 -1.34,0.55,-1.21,0.86,0.12,1.73,2.52,2.24,1.03,1.44,1.99,1.82,2.08,3.06,2.97,2.68,2.17,1.63,1.40,1.06,-0.37,0 --0.35,-0.40,0.17,0.05,1.05,-0.30,0.68,1.03,0.90,2.15,3.60,4.97,4.51,3.51,2.77,2.67,1.09,2.31,0.24,0.22,-0.62,2 -0.11,0.60,2.07,1.74,3.79,4.81,4.67,4.98,5.01,3.31,0.85,2.27,-0.16,0.56,1.50,-0.12,-1.33,0.94,-0.99,0.11,1.40,1 --1.27,1.01,-0.83,0.50,-0.32,1.63,3.25,0.64,0.97,2.09,4.84,4.44,4.15,4.56,3.22,3.71,3.47,1.88,0.54,1.10,0.02,2 -1.20,0.31,-0.08,-0.66,0.36,0.49,-0.67,0.69,-0.27,1.30,3.91,3.86,6.38,4.32,4.11,5.49,3.68,2.99,1.13,0.03,-0.18,2 --0.66,2.26,-1.35,0.13,-0.94,0.84,1.90,0.79,2.39,3.36,6.05,3.93,3.18,3.01,3.07,1.87,0.86,1.32,-0.56,-0.88,0.26,2 --0.97,-0.76,0.68,1.37,-0.99,-0.32,3.39,3.92,3.22,4.19,6.93,5.21,3.85,5.39,0.92,0.82,0.76,0.33,0.07,1.14,-1.43,1 -0.47,-1.69,0.67,0.25,0.63,2.00,2.60,4.17,2.82,4.06,6.74,4.03,3.26,2.73,1.36,2.49,-0.22,-0.78,-0.92,0.87,1.68,1 -0.29,-1.32,0.28,1.71,0.17,2.39,3.92,1.79,3.53,6.37,4.82,3.79,0.98,2.35,1.68,1.07,1.40,-1.40,0.28,0.00,1.38,1 --0.33,0.83,1.14,-0.11,1.78,1.36,1.11,-0.91,3.43,5.03,3.99,5.31,2.85,4.03,4.36,1.16,2.47,0.93,2.18,1.40,0.85,2 -2.22,0.76,1.58,2.65,2.01,0.79,4.73,1.84,3.18,1.76,1.55,1.98,1.14,0.26,1.76,1.53,1.17,-0.11,-2.12,1.22,0.85,0 --0.48,-1.41,0.02,-1.41,0.35,1.89,0.90,3.05,3.13,5.02,5.52,5.17,3.87,5.06,3.11,1.75,1.35,1.58,-1.68,0.41,-1.62,2 --0.11,0.64,0.90,1.69,1.46,1.90,3.83,1.78,4.60,4.58,3.33,2.57,4.82,2.47,2.13,1.14,-0.43,0.04,-0.32,0.98,1.57,1 --0.35,-0.22,2.21,1.96,1.66,1.33,3.37,2.11,0.13,1.76,3.44,4.63,3.99,3.64,5.74,4.27,2.64,2.38,1.24,0.57,1.75,0 -1.33,1.54,-0.07,1.34,0.33,1.80,-0.36,2.43,2.60,3.52,4.43,2.31,4.55,3.92,2.22,1.81,1.83,-1.21,2.23,-0.86,-0.45,2 -0.39,-0.60,0.42,1.20,-1.95,-1.27,1.79,2.80,4.84,6.82,4.38,6.20,2.49,3.49,1.76,1.08,0.81,-0.58,-1.00,0.83,1.21,2 -0.39,0.28,1.66,1.85,3.92,3.08,5.26,2.87,2.28,2.68,3.67,1.62,0.79,0.81,0.34,1.12,2.00,-1.24,0.12,1.08,-1.30,0 --0.35,-0.70,2.44,3.34,0.91,2.24,3.40,4.41,2.36,1.35,2.09,-0.19,2.56,2.35,3.69,0.07,1.44,2.02,2.03,-0.50,0.09,0 -1.19,1.24,1.59,2.29,3.73,4.34,5.17,3.33,5.72,2.35,1.03,1.59,-1.23,1.82,1.19,1.18,0.81,0.88,0.79,1.39,-0.39,0 --1.32,-0.47,1.28,-0.08,-0.13,0.10,0.76,-1.91,0.77,1.24,3.10,2.90,3.41,4.96,3.83,4.75,4.09,2.89,1.57,2.22,0.71,2 --0.58,-0.46,1.59,1.53,-0.06,0.79,2.02,2.75,-0.11,1.82,1.11,2.02,3.12,5.11,5.93,5.33,3.80,2.71,0.87,0.26,-1.18,0 -2.63,1.01,0.55,-0.78,0.57,1.06,2.51,2.16,4.17,5.68,5.57,4.25,4.00,4.51,1.06,2.47,-0.89,2.20,1.32,-0.74,-0.11,2 --0.80,2.11,0.79,1.22,0.01,1.21,2.55,2.51,2.75,2.98,3.03,4.21,3.73,4.11,3.50,3.31,1.25,-0.73,0.09,0.19,-0.50,2 -1.59,1.11,1.08,1.44,3.62,3.47,5.19,3.72,2.85,4.31,2.73,1.58,-0.56,0.80,1.44,1.33,1.28,1.24,-0.98,1.80,0.67,1 -0.81,0.47,-0.57,-0.62,1.01,1.48,-1.10,3.65,2.34,1.74,6.49,4.74,4.44,5.20,2.34,2.37,2.19,2.05,-0.40,1.08,-0.07,2 -1.62,-1.62,0.18,-0.27,0.08,0.22,-1.49,-0.19,-0.50,0.89,2.05,3.87,4.28,5.29,5.80,5.84,1.71,1.95,0.62,0.07,0.75,2 --0.33,0.25,-0.40,0.95,0.14,-0.37,2.29,3.07,1.35,2.59,3.69,4.63,3.02,4.45,3.46,3.65,0.95,1.46,1.11,0.63,-0.65,2 --0.96,0.58,-0.56,0.77,-1.37,1.27,2.24,0.80,1.55,4.77,4.97,6.79,2.95,3.33,5.00,3.65,0.44,1.74,2.17,0.68,0.16,2 -1.40,-1.40,-1.14,0.59,3.32,2.39,5.17,4.21,3.93,3.78,6.74,3.39,3.40,2.20,1.81,1.60,-0.82,1.86,-0.63,0.89,-0.92,1 -0.25,-0.12,0.49,-0.41,1.14,3.71,2.93,3.02,3.83,4.31,6.17,3.59,1.81,2.13,0.57,-0.89,0.69,0.53,-0.01,-1.49,0.88,1 -2.29,-0.95,3.49,0.52,3.69,4.83,7.13,5.08,4.45,4.56,3.84,0.65,1.15,-0.64,0.69,-1.73,2.48,-0.85,1.09,-1.48,-0.11,0 -2.49,-0.10,1.53,1.29,0.20,2.62,1.83,3.67,4.44,5.51,6.99,4.24,3.78,3.60,1.07,-0.42,-0.50,-1.36,-1.44,1.63,-0.03,1 --0.36,0.32,2.74,1.60,-0.29,1.46,2.63,2.47,3.74,0.94,0.98,3.59,1.67,3.43,5.21,3.85,2.12,1.46,1.06,1.76,0.62,0 -0.37,1.04,1.41,4.83,4.08,5.62,5.18,5.86,3.47,0.57,1.94,1.46,0.05,-1.27,1.73,0.62,-0.91,0.40,0.96,-0.10,-0.53,0 --1.55,-0.76,-0.35,-0.79,0.37,0.29,3.91,2.57,2.15,3.85,7.17,4.69,3.97,3.72,1.83,0.28,-0.02,0.62,1.00,-0.19,-0.43,2 --1.73,0.78,2.13,2.81,2.91,6.26,5.62,3.51,3.90,1.97,1.43,1.65,-0.06,1.31,-0.92,-1.51,-0.76,-0.14,0.50,-0.76,0.17,0 --1.94,-1.14,0.61,-0.13,1.22,-1.30,1.37,0.57,0.18,2.04,3.06,2.65,3.73,2.84,6.26,5.58,4.65,3.86,2.15,2.41,-0.10,0 --0.89,-0.29,1.47,0.28,-1.24,-0.61,2.55,2.23,2.09,1.52,4.07,3.99,4.68,1.83,6.37,3.83,0.43,0.18,1.59,-1.19,-0.14,2 -1.82,1.66,1.57,1.89,3.12,2.25,5.83,2.69,4.06,3.66,4.19,3.80,2.37,1.66,2.64,1.74,0.05,-0.09,-0.32,0.93,0.97,1 --0.64,-1.71,1.96,2.72,1.52,1.72,3.45,3.57,4.00,3.78,3.77,3.05,3.07,1.07,0.37,-0.23,0.70,1.20,-2.33,-1.47,0.89,1 --0.62,0.84,1.23,-0.55,0.09,-0.25,0.48,2.04,1.61,2.62,4.86,2.69,4.86,3.17,3.03,2.40,0.73,2.93,-0.37,0.51,-0.99,2 --0.58,1.23,1.18,0.87,0.25,-0.90,0.21,1.70,1.64,3.31,2.29,3.20,4.40,4.04,5.05,4.52,2.31,1.25,2.97,-1.32,-0.20,2 --0.17,-1.75,-0.67,1.15,1.55,0.84,2.38,2.26,2.71,3.38,5.70,5.91,4.99,3.33,3.21,0.42,1.00,-0.04,0.05,-0.90,0.82,2 --0.47,1.25,1.50,1.48,4.03,0.17,3.80,1.37,0.31,0.91,1.90,2.37,2.69,2.88,3.15,1.91,1.77,1.27,-0.34,1.00,0.21,0 -0.93,0.76,2.22,2.64,5.79,3.75,4.29,5.76,3.96,2.80,2.41,1.28,2.40,-0.82,0.28,-2.11,-2.82,-0.12,0.30,-0.39,-0.38,1 --0.26,0.32,0.07,0.86,1.09,-0.56,1.79,0.19,-0.67,0.84,2.51,3.56,3.99,3.09,5.16,4.50,4.98,2.42,1.51,0.26,-0.73,2 --2.62,0.78,-0.24,2.02,0.61,-0.66,0.25,0.64,1.18,0.93,2.44,4.48,4.18,4.25,5.20,3.04,3.36,1.95,0.79,0.21,-0.20,2 -0.65,0.14,2.98,1.43,2.63,4.94,3.95,1.72,2.60,3.51,0.85,2.11,1.40,2.50,0.70,1.20,1.39,1.29,0.65,0.48,1.39,0 -1.59,-0.04,1.33,2.76,1.66,4.61,4.61,2.28,5.21,3.87,2.66,2.56,0.95,-0.49,-1.49,0.28,-0.06,0.46,0.84,0.54,-2.96,1 -0.64,0.14,-1.23,-0.70,0.34,2.17,3.45,3.93,3.68,4.08,3.66,3.38,4.27,2.39,3.66,2.51,1.62,0.85,-0.43,-0.35,-0.19,1 --1.29,2.48,-0.40,-0.36,-0.35,0.47,2.86,1.29,3.63,3.94,3.69,3.21,4.51,4.47,2.83,3.05,0.86,1.10,-0.09,0.05,-0.06,2 --0.16,1.67,-1.36,2.23,1.81,2.86,3.75,3.53,4.80,5.65,4.25,4.40,1.75,0.95,2.09,2.43,0.08,-0.66,0.37,-1.76,-2.18,1 --0.12,0.86,0.51,1.26,0.79,2.69,3.08,3.57,6.49,3.06,4.46,3.04,0.82,1.46,0.12,1.77,0.41,-0.69,1.47,2.66,-1.49,1 -1.52,-0.84,3.01,1.83,4.08,5.78,3.92,4.79,3.34,2.89,2.61,2.46,-1.23,0.80,0.55,1.74,-0.70,2.24,-0.67,-1.38,0.31,0 --0.52,-0.76,1.23,-0.39,1.14,2.08,1.03,2.58,0.75,1.79,1.98,0.83,2.59,2.23,4.59,4.28,3.84,2.12,1.43,1.46,-0.70,0 -1.22,-0.76,1.02,1.53,3.10,3.09,2.66,4.03,1.36,2.01,0.24,0.70,1.02,3.46,2.94,0.84,3.54,2.71,2.01,0.62,0.15,0 --1.17,0.73,-1.44,-0.05,0.28,0.81,1.55,3.74,2.67,4.96,3.84,4.09,3.68,2.34,3.88,0.11,3.33,0.19,1.15,0.80,0.47,2 --1.63,0.25,2.00,1.77,2.07,2.71,3.03,4.80,4.47,3.56,4.75,2.26,4.50,4.58,1.49,0.23,0.47,0.24,-1.03,1.84,-0.36,1 -1.44,-0.48,0.97,-1.82,1.05,-0.01,1.02,1.20,2.49,1.40,2.74,4.05,5.72,2.42,4.99,3.50,3.71,2.17,1.59,-0.06,1.30,2 -0.61,1.30,0.55,1.42,1.35,3.23,3.57,0.87,2.57,2.08,1.63,2.50,3.92,2.07,2.28,2.73,2.61,2.67,0.66,-1.49,-1.03,0 --0.81,-1.26,1.03,1.19,-0.45,-0.20,2.32,0.56,2.47,4.82,4.80,2.76,4.83,3.51,2.05,1.49,-0.63,1.95,0.24,0.27,-0.43,2 --0.34,-0.83,1.72,0.28,3.78,2.24,1.48,1.96,0.85,1.15,0.55,1.77,0.99,3.51,3.83,3.02,3.58,1.00,1.37,-1.90,-1.10,0 --0.08,0.78,1.61,1.01,0.01,0.91,1.47,-0.04,0.29,0.11,2.65,3.69,1.56,6.08,5.38,3.42,4.76,3.58,0.33,0.42,-0.31,0 -1.11,-0.59,0.50,1.34,1.29,0.83,1.14,3.54,2.48,1.57,2.38,4.35,6.75,2.72,3.15,2.25,2.77,3.31,0.73,0.01,0.07,2 --0.01,-0.88,-0.29,-0.08,2.06,0.79,2.57,2.79,3.01,3.01,5.07,2.92,2.43,1.56,2.57,2.06,0.44,1.06,0.58,-0.27,1.37,1 -1.46,-0.28,-0.72,0.41,-1.23,0.07,0.16,-0.50,0.68,0.59,3.23,3.27,3.74,4.80,4.20,4.37,2.82,1.77,2.54,2.19,-0.71,2 --1.59,0.89,-2.32,-0.76,0.14,-0.15,0.56,1.47,1.58,3.03,4.47,3.95,4.02,5.00,1.78,2.19,1.21,1.18,-0.32,-0.98,-0.69,2 -1.45,1.42,0.24,-0.06,-0.44,0.51,-0.51,0.70,1.42,2.82,3.30,2.62,4.91,4.70,6.81,4.91,3.58,1.52,1.78,-0.33,0.88,2 -0.39,0.62,0.83,2.07,4.08,3.89,3.12,3.19,2.36,2.70,1.35,0.70,-0.16,1.72,2.73,1.60,1.52,0.32,1.24,2.03,1.38,0 --0.48,0.70,-0.22,-1.91,0.30,-0.43,1.12,0.65,1.83,1.43,3.91,4.50,3.94,4.09,4.87,2.34,2.74,0.60,0.43,-1.13,-0.74,2 --0.09,1.49,1.26,0.15,1.32,3.82,2.41,4.43,0.67,3.53,3.93,1.68,1.42,2.34,3.42,0.68,2.09,0.74,2.15,0.95,1.02,0 --0.76,-1.55,-0.48,0.48,0.64,3.72,4.15,3.82,4.65,3.59,3.97,3.65,1.75,0.96,1.42,-0.10,-1.53,1.64,-1.22,0.14,-0.02,1 --0.56,0.60,2.21,2.82,3.33,3.72,5.93,3.98,3.01,3.41,3.20,1.64,0.18,0.41,0.44,1.66,0.42,-0.30,0.46,-0.55,0.49,0 -0.27,1.43,2.63,3.65,2.83,3.59,4.17,2.25,4.36,2.74,2.04,1.04,1.13,1.47,2.47,2.07,1.69,-0.07,3.19,-0.43,0.24,0 -0.84,0.29,0.21,1.37,2.44,2.25,2.88,3.02,3.87,4.74,5.49,2.98,3.29,1.68,-0.43,2.81,0.03,1.26,0.25,1.73,-1.11,1 -1.78,0.46,0.85,0.10,0.80,2.30,0.73,3.31,3.03,4.64,6.79,3.72,1.84,2.79,2.88,1.34,-0.25,0.13,1.19,-0.46,-0.33,2 -0.17,0.01,-0.18,-0.74,1.60,-0.45,1.95,3.52,1.12,1.67,3.94,5.26,3.44,3.03,3.56,4.12,3.47,1.73,1.38,-0.02,-1.68,2 --2.34,0.39,-1.42,2.09,3.15,3.31,3.78,4.24,3.70,1.81,2.18,-0.51,0.52,1.55,1.14,0.86,2.59,2.16,1.29,-0.39,0.13,0 --0.13,-0.10,-0.72,-0.38,0.06,2.40,2.03,3.12,5.08,4.91,5.33,4.70,6.14,4.13,1.71,1.35,1.24,0.21,-0.61,0.49,-0.30,2 -1.31,1.34,2.30,1.98,3.54,3.15,3.82,4.04,1.74,4.91,3.90,1.17,1.81,1.35,1.81,0.58,-0.21,-1.09,0.97,0.40,-0.84,1 -0.37,-0.13,1.35,2.55,3.34,4.09,3.69,3.93,3.30,1.32,2.68,1.82,1.93,0.24,2.75,1.66,0.44,-0.69,-0.32,2.01,-1.21,0 --1.23,2.15,0.16,0.30,-0.35,-0.11,0.44,2.35,1.33,2.92,4.63,4.75,3.72,3.07,5.56,3.44,3.03,2.67,1.50,0.24,-0.23,2 --0.28,1.09,1.51,2.20,3.03,5.17,4.46,4.41,3.30,3.61,2.63,1.82,1.20,1.98,0.14,1.53,-2.43,0.26,0.66,-1.29,-0.35,1 --0.82,1.61,2.02,1.01,2.15,2.57,1.46,2.25,0.47,1.47,2.73,1.54,1.93,2.70,4.42,3.17,1.62,2.17,1.22,1.01,-0.93,0 -1.04,0.62,2.56,2.58,5.92,5.29,4.94,4.11,3.12,2.68,1.20,1.75,1.03,-0.32,0.39,1.63,-1.96,1.17,1.86,0.67,0.56,0 --0.74,-0.26,1.25,-1.29,0.52,-0.26,-0.20,1.89,3.62,5.97,9.06,5.57,5.97,3.59,2.40,1.61,0.29,-0.55,-1.21,0.34,0.13,2 --0.13,0.24,-0.06,1.49,1.31,1.65,5.75,6.48,5.98,2.70,4.07,2.89,1.86,2.08,1.01,1.49,-0.42,-0.10,0.43,1.55,-1.64,1 -0.42,0.40,0.07,-1.03,-0.16,1.97,0.28,0.92,0.96,-0.55,1.01,3.71,4.91,4.15,4.98,3.62,4.90,2.25,3.41,2.35,-1.34,2 -1.54,1.51,3.19,1.49,3.39,3.25,3.30,1.79,3.94,2.47,4.03,2.71,0.59,1.81,-0.16,0.58,-0.34,-1.15,1.66,-1.19,-0.99,1 -1.06,-1.40,-1.09,-1.16,-0.44,2.86,-1.29,-1.15,0.14,1.40,1.77,1.37,3.40,4.22,6.18,5.12,3.33,1.26,1.04,2.97,-0.21,0 -0.28,-0.98,-0.79,-0.42,-0.69,1.93,2.29,3.44,2.55,5.49,5.21,2.82,2.93,3.00,3.37,2.10,1.88,1.36,1.33,1.86,-0.08,2 --1.62,-1.29,0.78,0.71,2.31,4.37,5.03,4.37,4.09,4.89,3.99,2.81,1.55,2.73,2.31,0.58,-0.24,-0.87,-1.77,1.82,-0.53,1 --0.79,0.02,3.42,3.18,3.40,3.56,7.45,5.44,4.35,3.35,0.98,-0.44,-1.39,0.18,0.96,0.52,-1.68,0.23,-0.46,0.86,0.94,0 -0.25,-1.10,1.55,0.77,-1.91,1.26,1.60,5.06,5.20,4.57,4.63,3.97,2.63,4.38,0.73,0.52,-0.04,-0.27,-0.76,0.31,-0.02,1 -1.72,0.23,0.10,0.48,0.51,0.11,2.09,3.82,3.93,4.93,4.05,6.53,5.26,3.68,0.51,2.20,-0.46,0.70,0.60,-0.06,0.76,2 -0.97,-0.99,-0.99,-0.98,-0.63,0.47,0.68,0.95,1.16,2.45,4.23,4.15,5.02,2.54,5.20,3.65,2.43,1.11,1.96,-0.43,-0.73,2 -1.54,0.69,1.77,1.59,2.49,1.95,4.66,4.16,4.80,4.18,4.11,3.19,2.11,2.72,-0.65,0.44,0.51,-0.48,1.12,-0.45,-0.64,1 -0.43,-0.20,-0.01,1.39,2.84,2.89,4.10,2.89,3.99,3.38,3.40,4.01,1.86,-0.20,2.17,1.93,-0.02,0.40,1.10,-0.03,0.85,1 --0.43,-0.25,1.16,2.24,-0.12,-0.21,-0.01,2.60,1.85,4.62,5.35,4.46,4.18,4.93,3.45,0.73,1.21,0.40,-1.01,0.26,-0.95,2 -1.16,0.06,-1.23,0.10,0.40,1.49,1.21,3.46,3.57,5.19,6.68,5.68,2.51,3.44,4.59,2.78,-1.21,1.83,-0.67,1.71,0.55,2 -0.84,-1.48,0.51,0.60,-0.35,0.65,0.20,1.70,3.53,4.85,4.63,3.62,5.75,2.97,3.03,0.60,1.52,0.48,0.34,0.68,-0.61,2 --0.55,-1.31,-0.90,0.66,-0.43,2.95,2.77,3.75,3.04,4.96,4.25,5.87,3.22,2.12,0.62,1.25,-1.97,-0.59,1.12,0.46,0.87,1 --0.33,0.32,-0.51,-0.85,-0.06,1.30,1.11,5.17,3.89,4.70,5.55,3.68,2.78,1.77,2.80,3.98,-0.73,-0.95,-0.05,-0.14,0.59,2 --0.03,0.86,0.85,-1.01,0.64,0.12,3.20,3.15,1.81,4.88,6.55,4.09,3.62,5.01,2.09,2.78,1.00,0.08,0.47,2.00,0.50,2 -1.02,-0.15,3.22,1.00,0.25,-0.47,-0.18,-0.92,-1.87,1.56,2.34,3.19,4.64,2.74,4.43,4.70,2.97,2.19,0.74,1.73,0.78,2 --1.13,0.22,2.61,2.20,2.98,3.72,5.76,3.93,3.67,2.43,2.76,3.14,0.41,1.62,2.08,1.23,1.01,0.48,0.40,0.24,-0.68,1 -1.17,0.35,1.47,2.76,6.32,3.82,6.17,5.85,5.35,2.78,1.82,2.04,1.43,0.73,0.85,1.34,-1.65,0.18,-0.92,-0.71,0.54,1 --0.29,0.30,-0.47,0.02,0.17,1.86,1.87,3.48,4.02,4.54,5.59,4.83,3.74,1.33,1.46,1.40,1.67,1.96,0.03,0.48,0.83,2 -0.43,0.12,-2.17,0.04,0.90,-0.00,2.02,4.01,4.15,3.74,6.57,5.35,4.26,2.59,1.39,1.54,1.30,1.76,-0.97,0.81,0.88,2 --1.56,0.40,-0.30,2.49,0.19,-0.06,1.68,1.72,0.83,2.06,2.27,2.88,2.49,2.26,6.58,4.76,0.91,3.81,1.23,0.86,1.04,0 --0.49,1.04,1.81,2.72,3.81,2.88,5.31,4.57,2.57,3.90,4.29,1.36,0.43,0.29,2.19,-0.43,0.16,-0.53,-0.03,-0.70,0.14,1 -1.66,-0.50,2.17,1.25,5.51,4.72,6.84,5.83,3.16,3.72,2.99,0.09,-1.51,-0.58,-0.05,0.99,-0.76,-0.69,-1.20,1.37,-0.80,0 --0.77,1.16,-0.40,0.98,0.53,0.52,1.69,1.89,2.54,2.48,4.58,4.31,3.25,5.25,3.01,2.28,1.17,-0.63,-0.49,-0.54,-0.25,2 --0.39,-1.70,0.85,2.35,-0.19,2.32,2.20,2.02,1.18,0.94,2.13,3.29,3.83,3.65,2.89,2.83,0.05,2.92,1.64,-0.16,-0.32,0 --0.56,1.62,0.84,1.82,2.92,2.37,3.69,4.18,2.72,2.55,0.38,2.60,2.86,0.94,2.48,1.16,3.11,2.26,-0.10,1.20,-2.23,0 --0.45,-0.12,-0.64,0.07,-0.07,0.36,2.42,4.08,6.55,5.52,5.96,5.72,3.87,4.81,1.03,-0.66,-0.40,-0.27,0.75,-0.11,-0.63,1 --1.12,-0.26,1.21,0.46,2.57,3.17,4.52,3.86,3.05,4.18,5.11,1.98,2.23,0.45,-0.30,0.29,0.44,-1.59,1.06,-1.22,1.22,1 -0.51,0.82,0.74,3.12,1.28,3.17,2.32,1.55,1.10,3.85,3.71,2.68,2.24,3.43,2.73,1.58,3.13,1.39,0.19,0.79,-2.14,0 -1.00,1.09,-0.01,-1.52,-0.17,0.14,0.93,3.16,2.97,3.78,4.44,3.44,5.35,3.62,3.47,2.73,2.82,0.43,-0.01,0.80,0.19,2 -0.61,1.26,1.30,1.28,3.57,3.21,7.43,2.37,2.13,3.05,2.91,1.05,0.08,0.22,-1.16,-0.64,0.88,0.78,1.31,0.60,-0.40,0 -0.73,0.91,2.51,1.16,1.96,3.01,2.66,4.05,3.15,4.28,5.02,2.36,1.93,1.74,1.20,3.07,-0.56,-0.45,-0.46,1.20,-0.50,1 --1.50,0.38,0.38,0.87,5.05,4.45,6.67,6.39,4.59,2.71,0.38,3.27,-0.13,1.61,0.06,0.41,0.55,0.02,0.21,-0.89,0.11,1 --0.10,-1.77,0.03,-0.19,0.14,-0.78,1.47,0.15,3.46,3.13,6.59,3.25,3.13,4.01,4.32,3.09,1.36,0.41,0.28,-1.04,0.93,2 -0.19,0.36,-0.95,2.03,0.24,0.68,1.58,3.77,2.09,4.37,5.83,5.94,4.94,3.49,1.95,2.66,1.91,1.62,-0.56,-0.27,-0.19,2 --2.17,1.28,1.10,0.86,-0.89,1.24,-0.44,0.57,1.39,1.22,3.12,1.21,4.09,4.53,5.42,4.45,5.85,5.06,1.17,1.19,-0.53,0 -0.95,1.19,0.86,2.70,2.73,6.65,5.74,3.20,4.66,3.13,1.84,1.25,0.06,0.73,1.45,-0.46,1.71,0.23,-1.93,0.84,-0.70,1 -0.04,0.65,2.01,2.39,1.31,3.81,2.69,2.21,1.59,3.59,2.10,0.86,0.76,1.22,2.80,1.57,1.93,0.47,-0.19,0.02,0.64,0 -0.68,1.01,1.34,-0.34,-0.84,-0.14,-0.35,1.30,0.93,2.09,2.36,2.70,3.13,4.70,6.60,4.42,3.80,2.90,0.87,1.85,1.19,2 --2.36,0.36,-0.08,2.38,1.72,3.04,3.65,2.99,4.11,4.08,4.25,2.17,2.25,0.89,0.27,-0.83,-1.56,-1.38,0.01,0.77,-0.40,1 --1.03,-0.45,-0.34,2.08,-0.81,0.12,3.35,2.78,3.53,5.27,5.78,5.88,2.35,3.46,2.84,2.43,1.66,-0.39,0.03,0.60,-1.71,2 --0.96,-0.56,-0.20,-1.93,-0.57,-0.77,2.18,0.60,2.99,3.17,3.98,2.96,1.89,4.07,2.85,2.81,2.68,2.63,2.16,0.70,0.25,2 -0.28,-0.57,0.26,-0.39,-0.08,-0.09,0.45,-0.03,1.70,1.34,3.38,2.87,2.37,4.97,4.56,4.43,4.41,4.25,2.70,0.94,0.97,2 -0.64,-0.16,1.42,3.68,3.56,3.21,5.33,4.61,3.42,3.94,1.16,1.30,2.18,0.13,0.68,-0.24,3.21,1.26,1.83,0.95,0.58,0 --1.25,1.10,1.89,1.34,0.71,1.37,3.26,2.54,3.61,5.15,6.58,3.68,4.32,3.61,1.01,0.77,1.07,1.87,-0.34,0.79,1.14,1 --0.38,0.49,1.66,1.75,2.68,2.15,4.67,3.80,2.23,3.39,2.54,2.60,-0.24,2.52,1.98,1.89,1.60,2.76,-0.02,0.10,0.09,0 --1.61,-0.21,-0.71,0.23,0.30,0.56,1.60,2.86,2.14,3.93,1.61,2.24,2.91,2.44,4.41,3.28,3.37,0.82,0.53,2.44,0.56,0 -0.92,1.09,-0.03,-0.80,0.92,1.63,2.10,1.66,4.12,4.84,6.09,5.02,3.27,3.41,0.02,0.93,-1.08,-0.38,-0.96,-1.21,1.65,1 --0.05,-0.32,-0.14,1.29,-2.11,1.62,1.12,2.67,1.75,2.20,3.61,4.67,4.79,3.64,1.39,1.99,2.03,0.26,-0.27,1.67,0.38,2 -1.52,1.82,2.83,2.35,1.94,2.52,4.83,4.64,4.44,2.04,1.63,2.01,0.06,0.16,-0.78,-1.08,0.98,-1.03,1.70,0.95,-0.35,1 --0.43,-0.26,0.15,1.32,4.11,2.95,4.23,2.32,1.64,1.92,0.77,2.90,-0.48,1.80,0.98,1.85,1.92,0.12,2.09,-0.37,-0.47,0 --0.50,-1.10,-0.10,-0.39,0.46,0.65,1.71,1.23,2.50,2.75,5.32,6.25,3.57,2.76,2.71,1.28,0.85,0.01,0.78,-0.20,-1.07,2 -0.68,0.27,1.73,0.35,0.45,0.09,1.07,0.80,0.59,3.00,3.96,2.35,4.62,4.76,4.91,2.67,2.25,1.53,1.61,1.15,1.35,2 -0.35,0.03,1.33,1.40,4.14,4.14,3.92,3.80,5.25,4.46,3.75,1.65,0.39,2.25,-0.88,0.91,0.69,1.10,-1.30,-0.65,0.70,1 -0.81,-0.03,-0.45,2.35,0.75,2.90,0.89,1.02,0.42,0.99,0.90,1.39,2.20,1.25,3.00,2.55,2.76,1.61,-0.77,-0.64,-1.89,0 -1.09,-0.04,1.56,1.13,0.11,0.52,0.61,1.82,-1.00,1.63,3.06,5.24,4.33,3.33,3.63,0.61,4.08,1.99,0.70,2.77,-1.71,2 --0.93,0.88,0.37,1.25,2.29,1.83,1.28,2.83,2.42,5.00,4.97,4.02,3.71,3.28,1.23,0.66,0.15,-0.08,-0.27,1.34,0.14,1 -0.86,0.94,-1.31,-0.69,0.02,1.61,3.36,2.57,2.86,4.62,5.26,4.72,3.52,2.96,4.23,2.16,0.58,2.17,-0.47,-0.13,-0.26,2 --0.50,0.14,-0.43,2.15,1.40,3.07,3.00,2.42,1.41,2.94,1.12,1.20,3.89,3.44,4.37,3.58,3.58,2.22,0.97,0.61,-0.25,0 --0.99,1.84,0.83,3.07,4.12,4.35,2.44,5.06,3.05,4.11,2.78,1.45,0.25,-0.95,0.04,2.08,1.21,-0.20,-1.14,-0.43,-1.02,0 -0.01,1.99,-0.11,-1.06,2.02,1.73,1.23,3.34,3.07,1.99,1.84,1.35,4.12,3.02,5.04,3.83,2.82,1.82,0.02,2.10,0.33,0 -0.36,0.45,0.22,-0.31,0.39,2.64,1.70,3.24,3.43,5.07,5.29,5.91,4.81,2.44,1.94,0.93,-1.39,-0.80,-1.86,1.20,-1.13,1 -0.35,1.10,1.30,-1.65,-0.10,3.45,2.69,3.65,5.02,4.65,3.71,2.65,2.43,0.27,3.46,0.29,0.28,-0.52,0.75,-0.29,1.42,1 -1.05,0.01,0.45,1.05,0.98,2.61,4.17,1.38,1.46,1.86,3.49,1.13,2.09,1.40,5.28,1.22,3.33,1.59,-0.48,-0.72,0.64,0 --0.71,0.81,0.55,3.19,3.39,3.57,4.52,3.91,0.52,3.89,1.26,2.67,2.48,2.61,-0.77,1.67,1.61,1.76,0.07,-0.43,0.47,0 -1.91,2.25,3.53,3.26,3.28,5.33,3.80,4.46,2.98,2.45,2.48,-0.05,1.02,0.70,2.45,1.27,0.27,-0.06,0.33,1.34,0.86,0 --0.42,0.94,2.03,2.13,4.36,5.81,5.89,5.14,4.18,4.48,2.90,0.60,-0.13,-1.26,0.17,0.15,-0.27,1.04,-0.22,0.16,-1.64,1 -1.36,1.10,-0.30,0.43,2.36,1.61,1.35,3.67,2.42,1.26,2.22,1.47,1.32,1.41,5.60,3.61,3.37,2.86,0.37,0.08,-1.23,0 -1.49,0.15,-0.65,2.12,1.26,4.88,4.11,2.92,1.96,2.00,2.35,1.71,1.68,1.62,-0.04,0.85,0.49,2.02,1.55,0.71,0.21,0 --0.94,1.85,-0.68,0.58,-0.62,-0.31,1.04,1.06,3.58,2.96,3.85,3.84,3.42,5.37,6.61,1.68,1.67,1.05,0.35,0.78,0.91,2 -0.18,-0.48,-0.35,-0.72,1.87,3.33,0.35,1.30,3.65,5.21,4.80,6.50,4.61,3.91,0.92,2.21,0.47,0.22,-0.85,0.31,-0.40,2 -0.70,-0.56,1.28,-0.84,0.56,1.58,2.38,2.95,4.85,7.06,6.75,5.61,4.74,4.35,1.96,0.78,-0.75,1.75,0.83,2.05,1.76,1 -0.06,1.51,1.68,1.42,1.12,2.57,1.40,0.87,1.20,2.32,1.73,1.67,0.42,3.72,2.93,2.34,2.06,1.55,1.62,1.46,-0.35,0 --0.52,1.86,1.10,2.90,4.87,5.30,4.37,4.59,4.24,4.36,2.40,1.75,-0.17,0.51,1.66,-0.17,-0.32,0.23,0.36,0.34,2.20,1 --0.18,1.54,0.92,1.84,-1.49,1.90,0.18,1.21,2.41,3.56,4.65,2.41,5.17,4.74,3.81,3.39,3.16,1.61,0.63,-0.14,1.02,2 -1.63,1.15,1.21,0.25,0.99,1.39,1.86,2.87,2.74,2.07,3.11,2.40,2.97,3.45,5.12,1.82,2.90,2.45,2.85,2.09,-0.91,0 --1.29,2.14,1.14,2.22,3.51,4.25,4.73,3.18,2.82,1.78,1.48,2.27,2.18,3.34,3.45,2.67,3.81,2.97,0.82,0.31,1.80,0 --1.56,1.74,1.47,-0.21,0.31,-1.37,3.02,1.92,2.13,6.24,6.36,6.13,3.95,1.92,2.82,1.83,-1.26,-2.24,-1.19,-0.51,0.98,1 --1.89,0.90,2.79,-0.28,1.07,2.18,4.59,3.20,3.55,3.88,4.60,4.03,3.41,0.51,0.78,1.88,1.75,0.46,1.06,-0.91,-0.12,1 -0.91,1.47,-0.73,1.49,-1.16,1.26,0.97,2.41,2.43,4.17,2.60,3.99,3.77,4.95,4.83,3.90,2.56,0.78,1.19,0.08,1.36,2 --1.11,1.13,1.26,0.07,1.23,0.51,1.98,0.90,2.28,1.08,1.24,1.89,2.62,2.55,6.90,3.43,3.79,4.19,0.73,1.21,-0.24,0 -0.54,0.81,1.39,0.41,2.59,2.26,3.34,4.49,3.26,4.89,4.47,1.99,1.56,0.21,0.39,-0.08,1.29,0.07,1.69,-0.21,1.51,1 --1.13,1.37,1.79,1.61,4.15,4.00,5.42,3.47,3.51,4.60,2.80,0.60,-0.88,-1.09,-0.40,-1.52,-0.04,0.04,-0.62,-0.54,0.02,0 -1.31,0.47,0.80,-0.41,-0.47,0.32,0.06,0.00,0.13,2.92,3.41,2.08,4.31,4.06,6.56,4.31,4.52,1.35,2.12,0.16,-0.63,2 -0.34,0.62,0.76,0.41,-0.05,2.97,4.28,2.72,5.12,5.21,1.48,4.18,0.78,1.10,-0.01,1.97,0.35,-0.27,0.78,-0.25,-0.37,1 --0.16,-0.56,-1.50,0.40,1.85,1.46,1.41,2.12,6.07,3.65,6.27,4.71,4.42,3.97,2.31,0.61,0.21,-0.97,2.18,-0.30,-0.57,2 --0.20,0.52,0.73,-1.32,0.79,2.53,2.25,2.61,4.92,4.31,6.56,4.34,3.94,1.06,1.49,-0.41,-0.26,-0.35,-0.93,2.02,-0.48,1 --0.06,-0.02,-0.45,-1.20,-0.38,0.56,0.43,2.72,1.64,2.46,3.50,3.50,3.98,5.54,4.01,1.48,2.90,1.41,0.89,-0.24,-0.13,2 --1.03,-0.21,0.71,2.15,-0.89,1.64,3.22,1.87,3.33,4.96,3.93,3.32,1.53,5.04,2.44,4.17,1.40,1.72,-1.00,2.37,0.04,2 --0.22,-0.87,1.44,0.81,-0.45,2.48,4.00,3.23,3.57,3.83,5.04,2.08,4.22,2.75,1.04,0.28,0.41,-0.08,0.32,1.77,-0.12,1 --0.66,-0.25,2.23,1.07,0.54,0.99,1.17,1.69,4.02,2.59,2.93,3.78,4.25,4.12,2.88,1.20,1.54,1.03,1.73,0.13,0.83,2 --1.80,0.76,-1.21,1.21,0.85,-0.43,0.65,2.94,4.78,4.45,7.09,3.36,3.08,2.61,2.33,2.05,-0.46,0.34,-2.02,1.67,0.77,2 --0.97,-2.31,-0.76,0.82,-0.03,-1.53,3.03,2.44,1.74,3.13,5.58,4.68,1.90,3.98,3.69,0.84,0.36,0.45,0.05,0.59,1.05,1 -1.88,-0.43,0.46,0.50,-0.52,0.36,2.05,3.68,3.12,5.58,3.75,6.35,3.94,0.92,2.01,0.56,0.25,0.25,1.01,2.10,-0.02,1 --1.76,0.29,0.62,-0.55,0.15,0.01,1.71,0.98,-0.77,1.13,1.93,3.66,4.55,3.68,5.86,4.31,3.42,3.14,0.29,1.77,-2.26,0 --1.01,-0.66,1.26,0.52,-0.88,1.42,0.03,0.04,0.24,2.64,1.67,3.42,3.58,3.37,6.73,3.23,2.00,2.96,2.59,2.86,-0.57,2 -0.72,1.62,-0.63,-0.63,-0.21,-0.69,0.81,3.56,1.49,3.59,5.38,5.26,4.94,4.44,2.43,1.73,-0.27,-1.32,-0.71,0.45,-1.23,2 --1.22,1.50,-1.37,1.54,-1.27,1.68,-0.34,1.01,-0.37,3.03,2.72,3.10,4.06,5.55,6.69,4.74,4.37,2.26,3.30,0.80,-0.76,0 -1.82,-0.28,-0.74,-0.26,-1.04,0.14,2.29,0.42,3.44,3.20,4.97,4.93,3.38,5.59,2.12,1.71,1.72,1.48,0.78,0.20,0.78,2 --0.17,-0.39,1.20,2.25,4.60,5.49,5.42,5.50,3.72,3.18,1.78,1.52,-0.29,1.61,-0.28,-0.71,0.74,0.57,-0.61,1.59,-0.42,1 --1.13,0.38,3.45,3.96,4.82,4.11,2.95,4.01,3.16,3.35,2.69,1.28,1.56,-1.06,-0.73,0.46,-0.18,0.29,-0.10,-0.03,0.15,1 -1.42,-1.90,-0.06,-1.01,0.74,1.73,3.31,3.16,2.19,0.23,0.96,2.75,3.87,1.23,4.18,1.90,4.73,2.04,1.18,-0.45,-1.75,0 --0.40,0.79,0.82,-0.08,-0.18,0.52,2.44,0.06,1.56,1.27,3.48,3.89,4.64,2.18,5.59,3.40,1.00,2.39,0.35,0.89,-1.36,2 -1.68,-0.07,0.42,-0.92,2.82,0.84,-0.17,-0.82,0.98,0.65,0.64,2.30,0.77,2.73,4.97,4.23,3.19,1.23,1.45,0.19,-1.17,0 -0.72,2.40,1.11,-1.63,-1.27,-1.21,1.20,0.61,0.68,2.97,4.47,2.11,4.11,4.36,4.25,3.46,3.31,1.40,-0.01,1.28,0.02,2 -1.53,0.48,0.37,-0.04,0.52,1.61,3.12,0.42,0.32,2.41,2.63,2.73,2.42,4.47,3.83,4.56,2.12,1.76,0.42,0.25,0.69,0 --0.71,1.86,1.76,2.40,2.36,2.49,1.87,1.40,3.00,1.82,2.12,3.15,3.38,2.68,3.37,2.57,3.05,1.82,1.95,2.18,0.02,0 --1.14,1.26,-1.73,0.62,0.09,0.63,1.49,2.30,2.33,3.31,3.84,4.67,3.64,1.94,2.81,2.08,-0.14,0.44,0.88,-1.44,-0.57,2 -1.65,1.51,3.30,0.67,2.15,3.22,5.96,3.00,4.48,3.44,6.17,1.35,3.17,1.06,0.46,-0.16,-0.07,-0.53,0.67,0.82,-0.11,1 --1.28,0.11,-0.65,1.01,1.22,-0.60,-0.25,0.63,0.07,4.32,2.12,2.12,2.86,3.16,5.45,3.15,3.77,1.78,1.83,-0.44,0.35,2 -0.27,0.25,0.97,1.27,2.46,6.47,4.48,4.69,3.00,3.82,3.59,0.35,2.06,1.65,0.46,0.27,0.80,0.16,-1.42,-0.75,-0.25,1 --1.00,0.35,2.97,2.64,4.77,4.88,5.65,4.56,4.09,3.80,2.40,0.38,1.70,1.29,-0.69,-0.62,-0.30,-1.02,1.03,0.64,0.29,0 --0.23,0.62,2.10,2.24,2.68,4.19,5.57,5.21,2.78,2.58,0.02,1.91,0.65,-0.85,2.64,1.70,1.65,0.41,-0.23,-0.74,-0.06,0 --0.29,-0.24,2.78,1.06,-2.29,1.63,0.46,3.04,2.71,2.79,4.80,4.41,3.24,3.56,3.69,1.76,2.12,1.61,0.53,0.43,-0.82,2 -0.54,-1.53,1.48,1.78,0.86,1.00,2.62,-0.33,2.72,1.80,2.30,2.93,1.74,2.45,5.13,3.75,1.41,2.81,1.10,0.22,-2.07,0 --1.35,0.55,3.42,2.69,2.23,3.66,4.00,3.68,3.78,3.88,2.37,1.83,0.67,1.88,-1.48,0.55,-0.19,-1.34,0.81,-0.46,-1.22,1 -0.25,0.98,1.00,4.55,4.39,4.39,8.03,3.91,3.11,2.90,0.53,0.89,1.30,1.30,-0.03,0.85,0.95,1.10,-0.27,0.41,0.39,0 -0.49,-1.55,-1.62,-0.48,0.74,1.24,1.87,2.36,6.05,5.40,5.93,5.23,4.67,4.66,2.12,-0.01,1.17,0.30,0.78,0.13,1.19,2 -1.50,-0.80,-0.44,0.24,-0.35,0.49,0.97,0.80,2.65,3.92,3.58,3.95,5.18,5.01,3.37,3.92,1.41,-0.08,-2.55,-0.37,-0.42,2 -0.48,0.79,-1.04,-0.88,0.98,1.04,3.25,0.95,4.04,2.76,5.40,4.92,3.17,2.85,2.42,0.21,0.21,-1.49,-1.19,0.50,-0.72,1 -0.46,-0.82,-1.19,1.83,-0.05,1.99,3.53,2.45,3.16,5.31,5.30,4.52,4.02,1.94,0.43,1.85,-0.92,-1.74,0.14,0.64,-0.94,1 --1.55,-0.62,-0.04,-0.31,0.16,1.24,1.68,0.84,2.44,1.41,5.38,4.35,5.22,5.07,1.26,0.85,1.49,0.99,1.09,-0.23,-1.32,2 -1.10,1.46,1.88,1.84,2.21,4.45,4.54,3.90,4.19,3.85,1.03,2.48,1.75,0.25,0.40,0.91,0.89,0.58,1.17,-0.62,0.68,1 --1.54,0.14,1.36,2.46,2.75,2.45,3.81,4.52,3.79,4.79,3.15,3.41,1.67,1.82,1.25,1.48,1.12,-1.03,-1.18,0.03,0.71,1 -0.07,2.29,1.05,3.53,2.64,4.42,5.07,5.06,2.54,4.40,3.81,0.99,1.50,1.49,-0.33,0.06,0.03,-1.00,-0.46,-0.31,2.26,1 -1.47,1.45,0.38,0.06,-1.18,0.72,1.47,3.64,5.09,5.91,6.09,4.58,5.83,2.75,2.90,1.98,-0.99,-0.85,-1.28,0.44,1.35,2 -0.46,-0.32,1.69,0.98,2.22,0.29,2.64,2.46,2.04,2.82,0.72,4.52,1.10,2.17,3.34,2.74,3.19,2.12,1.63,0.48,-0.26,0 --0.37,-0.53,-1.26,1.48,1.95,1.32,1.33,4.10,3.61,4.28,5.09,5.08,2.98,2.37,0.86,0.05,0.23,-0.87,0.81,0.68,2.65,1 -1.22,1.63,-1.71,-0.78,-0.82,2.32,0.94,3.05,2.81,5.46,6.00,5.82,4.27,3.46,3.50,2.18,0.25,1.28,-0.97,-0.24,-0.11,2 --0.48,0.04,1.67,3.92,4.16,3.39,4.43,4.16,1.83,4.11,2.31,1.08,1.25,1.39,0.08,-0.39,0.56,1.69,0.44,0.79,1.05,0 -0.47,0.14,0.40,0.27,-0.41,0.47,0.93,-2.95,-0.33,-0.31,2.39,3.91,5.28,4.74,7.19,5.61,4.32,2.75,2.31,0.21,-0.47,2 --0.51,-0.48,2.40,1.50,3.82,5.35,5.26,4.23,5.03,3.36,3.30,1.23,2.93,0.94,0.21,-0.08,-0.75,-3.15,-0.09,-1.02,0.78,1 -2.18,-0.70,0.20,1.59,0.79,2.84,1.61,3.12,3.87,5.62,5.36,4.02,4.55,1.56,3.27,2.86,0.12,1.65,2.14,1.38,-1.53,2 -0.59,-0.20,1.77,0.37,-0.55,1.17,1.78,1.05,0.65,0.63,3.23,2.65,1.71,4.25,5.04,3.50,3.78,3.75,0.92,1.98,1.23,0 --0.81,0.78,0.18,1.56,-0.59,1.65,3.10,3.84,3.60,4.81,5.16,3.17,1.39,1.44,1.93,1.25,0.02,-0.19,0.35,-1.20,-0.98,1 --1.42,-0.39,1.67,0.09,-0.46,0.08,0.64,5.01,5.94,5.17,6.21,6.03,2.62,2.74,2.70,2.15,0.02,1.71,-0.23,3.09,-1.57,2 -0.52,1.33,0.70,-0.31,-0.10,0.01,-0.22,0.13,2.07,2.67,4.03,2.33,1.66,4.00,6.18,5.44,3.87,1.61,3.24,-0.03,0.15,2 -0.70,-0.53,3.67,2.78,2.62,3.76,5.97,5.56,3.61,3.91,1.98,2.50,1.02,1.31,1.52,-0.79,0.65,0.12,-1.01,1.13,-0.53,0 -0.09,-0.11,-0.95,-0.79,-0.47,1.78,1.40,2.95,2.00,4.32,4.64,5.67,5.87,3.25,1.91,0.67,-0.18,-0.26,0.04,1.25,0.44,2 --0.86,-0.68,0.71,1.93,0.15,0.92,0.30,-0.83,-0.61,3.42,1.61,4.47,2.56,4.14,5.41,4.51,2.52,4.34,2.61,1.93,-0.30,2 -0.49,-0.45,-0.72,0.70,1.53,2.29,5.03,3.52,3.43,4.29,5.31,3.08,2.89,2.49,1.43,-0.15,1.46,0.82,-0.55,-0.20,0.21,1 --1.58,0.01,2.33,3.23,3.43,5.42,4.58,6.79,3.86,4.02,0.99,0.37,0.42,1.30,0.78,2.00,0.08,-0.82,1.37,-0.92,-0.20,1 --1.44,0.98,0.88,-1.07,-0.21,0.80,1.76,1.85,4.77,4.29,4.46,5.79,4.19,4.44,1.79,-0.73,1.61,0.47,-0.28,0.56,0.35,2 -1.18,1.02,-0.27,-1.52,-0.27,2.53,2.42,3.21,3.96,5.00,5.38,5.92,4.81,4.41,2.87,2.01,1.20,-0.03,0.69,0.21,-0.78,2 --0.09,2.03,0.81,2.38,1.22,4.49,4.83,3.51,3.44,2.95,5.66,4.99,1.38,2.83,-0.33,0.43,-0.70,-2.70,-0.37,-0.25,-1.01,1 -0.39,1.69,-0.22,4.44,2.72,2.29,5.25,3.84,2.84,3.53,3.83,2.71,0.24,-0.16,0.88,-0.12,-0.42,0.66,0.94,0.08,1.57,1 -0.19,-0.65,0.60,2.93,1.07,5.29,6.11,4.45,2.47,4.52,3.11,0.73,0.30,0.11,1.95,-0.39,-0.32,0.81,0.88,-0.17,0.25,0 -0.54,0.26,2.76,0.14,1.69,1.32,2.85,3.55,3.26,2.64,5.40,3.82,5.12,3.67,2.10,0.62,0.53,0.09,0.19,-2.25,-0.41,1 -1.19,0.88,-1.00,0.68,2.46,1.43,1.51,-0.04,0.76,1.28,1.37,1.85,2.94,1.94,3.60,4.19,2.51,1.88,1.57,0.45,-1.25,0 --0.42,0.10,1.04,-1.62,0.87,0.73,0.46,-0.31,0.23,0.34,2.90,1.73,5.47,3.88,4.86,4.18,4.47,2.16,2.61,-0.36,0.79,0 -0.04,0.35,-0.72,0.67,-1.73,1.23,1.11,2.82,0.36,6.66,5.46,4.79,5.29,4.18,2.65,2.38,0.16,-0.94,0.89,0.51,1.62,2 -0.98,0.55,1.08,2.29,4.89,3.07,5.43,3.66,3.01,2.21,1.93,3.20,0.32,2.44,1.28,-0.34,-0.04,1.43,1.23,-0.15,-0.68,0 --3.34,-0.36,2.71,3.07,4.40,4.45,4.92,3.57,3.26,1.57,2.11,-0.29,-0.69,0.62,-0.12,-1.19,-0.22,-0.14,-0.19,-0.78,0.81,0 --1.01,1.23,-0.27,1.09,0.13,1.35,0.17,0.55,0.75,-0.94,1.35,1.74,3.51,3.87,5.40,3.01,3.14,3.96,2.56,0.40,-0.86,0 --0.17,0.35,-0.40,0.94,2.69,1.18,3.03,2.34,0.68,1.49,1.79,2.29,3.89,2.19,3.89,5.79,2.09,2.21,1.30,0.74,0.43,0 -0.73,1.08,2.74,0.95,1.50,3.78,4.01,3.58,3.62,5.08,4.95,1.53,0.45,0.90,0.54,1.50,-0.55,1.59,0.65,1.28,0.87,1 -0.82,-0.41,0.38,-0.47,-0.17,-0.79,1.19,1.97,1.51,2.01,5.12,3.50,4.13,3.82,3.92,1.91,2.63,0.61,0.61,0.32,-0.92,2 -0.21,-0.24,0.53,0.22,2.54,1.30,2.16,1.88,3.83,0.82,2.87,1.80,1.19,4.45,2.14,4.25,1.06,0.44,2.09,1.66,-1.25,0 --0.30,2.01,0.33,0.83,1.61,2.26,1.98,2.69,1.49,2.74,2.84,0.35,1.26,2.25,1.60,1.57,-0.72,1.36,0.39,1.52,-0.10,0 -1.04,0.89,1.99,2.26,1.63,4.03,4.44,4.56,4.29,5.07,3.10,0.39,1.27,-0.06,-0.64,0.21,0.12,-0.04,-0.11,0.76,-1.06,1 -0.50,0.68,0.36,-1.76,1.28,0.10,-0.17,0.77,-1.25,1.35,2.50,3.52,3.77,4.63,5.32,3.78,4.02,4.62,4.04,0.36,0.51,2 --0.03,-1.44,-0.63,2.02,0.85,1.98,2.62,3.12,5.55,4.06,5.91,2.72,2.37,2.39,0.79,0.52,0.91,0.60,-0.10,0.18,-0.16,1 --0.52,-1.12,2.50,1.90,-0.11,0.58,1.85,2.62,1.95,4.76,4.91,5.38,2.45,3.15,1.78,-1.11,0.54,-0.41,-0.18,0.66,-0.09,1 --0.02,1.23,-0.31,1.04,2.09,2.02,2.01,1.10,1.94,1.88,2.28,2.11,2.08,1.84,4.43,4.07,3.23,3.47,1.88,-0.51,1.72,0 --0.24,-0.59,0.66,-0.02,1.50,2.01,0.58,-1.49,0.96,2.53,1.23,2.36,3.57,5.04,3.56,4.41,2.94,3.41,1.26,0.95,0.93,0 -0.03,-1.17,1.22,0.19,0.10,1.41,-0.66,-0.47,0.54,3.91,4.01,2.22,4.88,4.76,6.17,5.72,1.77,1.71,2.15,0.68,-0.44,2 --0.26,0.35,1.21,0.28,0.87,1.48,0.93,1.45,3.08,3.80,5.64,3.03,3.43,2.44,4.00,2.20,2.33,-0.49,1.28,-0.13,-0.74,2 --0.42,1.23,-0.45,0.34,1.38,0.10,0.42,1.62,0.58,2.21,1.42,3.22,2.45,3.91,3.84,4.89,1.07,1.75,1.04,1.33,-0.77,2 -2.71,0.57,-1.10,1.55,-0.71,-0.70,-1.49,-0.20,-0.58,1.78,2.66,4.69,3.36,5.17,7.04,5.25,5.69,4.42,3.23,0.84,1.69,2 -1.36,-1.48,1.13,4.24,4.36,5.30,6.00,4.85,6.08,2.42,1.73,0.87,-0.54,1.56,-0.43,-1.35,-1.49,-1.01,-0.06,-0.48,2.04,0 --0.23,0.03,0.71,0.48,-0.38,3.57,3.86,2.90,1.91,4.14,2.63,4.73,4.11,1.44,3.15,0.93,0.04,-0.13,-0.68,1.00,-0.60,1 --0.56,0.53,0.34,0.40,2.83,3.20,3.76,3.35,2.43,3.65,2.77,0.92,1.41,2.59,1.37,1.78,1.20,0.02,0.42,0.42,0.12,0 -0.46,1.04,0.31,1.06,1.40,2.03,2.93,3.88,3.67,4.33,3.50,4.30,2.17,0.15,2.30,-1.19,-0.94,0.07,2.62,2.06,-0.25,1 --0.05,0.48,2.10,2.01,2.96,4.49,6.31,3.89,1.93,4.69,1.89,1.87,-0.46,0.44,1.39,0.57,0.70,-1.75,-1.02,-0.72,-1.10,1 -0.90,-1.57,-2.25,-0.16,-1.41,0.91,0.43,3.54,2.74,5.42,5.65,5.85,5.01,4.11,2.25,1.94,2.51,0.68,1.15,-1.41,0.96,2 -0.65,2.50,1.16,2.14,3.09,4.51,4.46,2.07,3.29,1.23,3.40,1.40,-0.08,2.71,2.72,0.32,1.89,1.48,0.46,-0.56,-1.31,0 --0.50,-0.46,0.00,3.00,1.92,3.11,3.98,2.31,3.09,0.40,3.16,1.97,2.27,2.52,2.54,1.36,0.59,1.99,2.52,-2.77,-1.34,0 -0.36,0.88,0.14,-0.81,1.51,3.51,1.64,3.93,4.89,5.10,6.06,2.95,1.19,2.12,1.45,-0.07,-1.24,1.03,1.04,0.40,1.12,1 -1.07,-0.94,0.32,-1.04,0.41,-1.39,2.39,0.44,0.58,1.54,0.96,4.25,4.42,5.19,5.79,4.92,2.99,3.34,0.29,-1.39,-1.33,2 -0.93,1.41,1.59,1.19,2.47,2.70,1.91,1.31,3.04,3.03,4.64,2.43,3.54,3.11,2.53,3.00,1.85,1.84,0.93,0.03,-0.43,0 --1.50,0.17,2.93,2.51,3.28,4.39,6.34,3.07,2.55,2.58,1.55,1.18,0.19,1.62,0.26,0.93,0.77,-0.67,-0.25,-0.67,1.16,1 --0.52,-0.04,1.59,4.75,3.83,3.33,4.89,4.71,1.55,3.72,2.66,1.39,0.01,1.25,0.70,1.62,0.09,1.63,-1.08,0.77,0.48,0 --0.11,0.41,-0.71,0.25,-0.26,-0.66,1.44,2.37,0.67,3.35,4.12,2.90,4.20,4.80,4.03,2.31,2.90,1.55,1.24,1.43,0.24,2 -2.48,2.22,1.12,2.71,2.32,4.02,6.51,4.35,4.51,4.25,2.69,0.10,0.97,-0.25,0.30,1.23,-0.22,-0.60,-0.26,-0.30,0.10,1 --0.79,-0.38,1.55,1.08,1.14,0.07,0.06,-0.96,2.20,3.40,5.02,3.73,4.45,2.10,3.50,4.08,3.51,-0.43,1.39,-0.68,1.88,2 -0.21,0.25,0.27,-0.43,-0.02,0.58,0.22,-0.35,0.06,2.71,-0.99,2.74,3.21,4.92,4.23,5.47,3.97,3.60,1.86,0.40,0.26,2 -1.01,0.28,2.87,3.04,4.06,5.27,2.47,4.86,5.93,4.35,3.70,1.15,0.77,-0.34,-0.59,-0.40,1.22,0.23,-0.44,-0.48,-1.84,1 -1.28,1.46,0.40,1.03,2.26,1.25,1.47,1.82,-0.30,0.20,2.40,1.91,3.48,4.43,6.99,4.34,2.95,2.88,0.84,1.17,-0.38,0 --0.00,-0.43,-0.19,-0.62,0.26,2.12,2.42,4.62,4.95,4.67,5.71,5.35,2.34,2.44,2.57,0.01,0.30,1.00,0.86,0.78,-0.20,1 -1.82,1.08,0.77,3.48,1.24,5.78,4.92,4.24,4.21,1.88,2.37,0.98,1.53,1.49,0.44,-0.05,0.11,0.44,-1.54,-1.35,-0.64,0 --1.33,-2.15,0.37,0.58,-0.12,1.42,2.64,2.04,0.35,0.88,1.73,3.04,4.03,2.99,1.26,2.55,2.28,1.48,-0.83,1.00,-0.94,2 -0.71,-0.01,1.10,1.52,-0.50,-0.42,-0.65,0.64,2.04,1.52,0.93,3.97,4.07,4.04,4.66,2.90,1.08,2.17,2.59,0.69,-0.78,2 --1.26,0.21,0.91,1.04,0.94,2.15,2.31,3.96,3.96,5.78,5.14,2.25,4.45,2.43,1.79,-0.24,-1.03,-0.34,-0.82,1.92,-1.11,2 --2.52,1.83,0.55,3.47,4.00,6.24,5.37,4.49,4.21,3.01,1.60,-0.03,0.49,-0.34,1.73,0.45,-0.41,-0.02,1.29,0.17,0.50,0 --0.73,1.52,0.99,2.14,0.45,2.34,1.80,4.73,3.91,6.08,5.45,3.89,4.41,0.82,0.33,1.37,-0.83,-1.36,0.73,-0.72,-1.26,1 --0.94,-1.60,1.50,0.45,1.68,3.69,4.44,2.95,1.78,3.01,0.22,3.22,0.61,-0.14,2.90,1.99,1.37,1.70,-0.31,0.95,-1.28,0 -0.38,1.23,1.97,1.78,2.08,2.76,0.69,1.43,1.30,0.86,3.55,1.34,3.80,5.00,2.28,3.80,1.65,1.95,2.19,0.67,-0.21,0 --0.88,-0.57,0.73,-0.96,-0.11,0.36,2.01,1.68,2.38,2.20,1.52,3.26,2.39,3.16,6.43,4.72,3.68,2.10,0.40,1.23,0.80,2 --0.71,1.03,1.44,3.57,3.63,5.23,6.82,5.20,3.12,4.01,3.47,2.55,-0.22,1.39,-0.11,-2.15,-0.22,-0.91,0.24,-0.24,0.08,0 -0.38,-0.70,-0.16,0.31,-0.64,-1.13,0.33,1.98,3.13,3.93,3.91,5.14,2.94,2.80,3.54,2.28,1.61,1.28,0.47,-1.09,-0.59,2 --0.94,0.98,1.35,4.28,4.46,3.68,6.12,6.07,4.25,2.84,2.37,3.23,0.06,-1.18,-1.31,-2.04,-0.21,1.68,-0.08,0.48,-0.08,1 --2.21,-1.07,0.75,0.95,-0.36,0.37,2.79,1.95,1.60,0.75,1.87,2.21,3.62,3.53,4.84,3.22,3.37,2.42,1.80,1.55,-1.13,0 -0.10,-0.43,-1.65,-1.04,0.58,0.35,1.48,3.11,3.89,5.33,7.11,3.87,2.65,2.73,1.71,0.04,0.26,1.33,-0.66,-1.56,-0.35,2 -0.72,1.53,-0.00,0.50,-0.31,0.41,2.53,1.75,1.07,1.79,2.55,3.29,3.23,5.60,5.18,3.38,3.39,1.82,2.70,2.28,0.18,2 -0.34,1.32,0.16,0.50,0.17,1.09,2.20,1.12,-1.00,0.56,1.92,2.12,4.11,4.50,5.94,4.30,2.81,1.01,2.94,0.46,0.96,0 -1.20,-0.37,1.18,2.78,3.57,3.57,6.11,4.47,2.78,2.14,2.36,0.96,0.64,0.25,1.53,1.09,0.78,0.67,-2.15,-0.21,-0.82,0 --0.50,-1.94,-0.51,0.06,-0.08,0.87,0.26,1.47,2.83,1.22,2.97,4.32,6.32,4.77,2.58,2.75,3.76,0.15,1.85,1.90,-0.64,2 --0.76,-0.63,0.78,-0.73,-0.86,1.26,2.94,2.30,1.88,3.34,4.43,3.87,3.65,4.28,2.25,3.18,1.41,0.31,-1.79,-0.64,1.05,2 -0.82,0.55,-0.85,-0.06,-0.45,-0.28,-0.05,2.83,-1.12,1.64,1.52,4.41,4.78,4.19,7.88,5.42,4.76,2.05,1.44,0.74,-0.64,2 -1.73,-1.60,1.08,0.83,1.36,0.41,3.23,0.85,-0.58,0.73,2.86,1.09,2.53,1.84,5.88,3.94,4.32,1.28,0.98,2.28,0.48,0 --0.65,0.11,1.51,0.60,-0.38,1.83,0.26,0.75,1.65,2.09,4.66,4.68,3.49,4.43,2.09,1.17,1.38,1.18,0.08,-0.87,-0.16,2 -0.61,-0.04,0.60,1.45,4.46,4.33,6.63,3.05,3.63,3.04,-0.07,2.78,-0.47,1.20,0.63,2.38,0.52,-0.06,1.35,1.06,-0.92,0 --1.45,2.41,0.36,2.60,3.74,4.05,4.43,3.49,4.02,3.63,1.85,0.37,0.41,-0.38,2.51,2.79,1.06,-0.06,0.25,0.76,1.73,0 --0.07,-0.44,1.94,1.16,-0.23,3.14,3.63,2.83,3.20,4.58,4.56,4.52,4.55,1.45,1.61,-0.32,-0.87,0.24,-0.18,-0.25,0.65,1 --1.17,-0.66,-1.56,-0.75,1.08,-0.06,1.24,2.15,1.12,3.27,2.17,3.49,3.42,3.64,4.22,0.91,-0.93,3.77,0.56,0.05,-0.47,2 -1.53,-0.50,-0.20,1.00,0.75,1.64,3.67,1.92,3.64,4.85,4.65,2.63,1.79,2.60,0.34,2.07,-1.45,-1.09,-1.63,0.82,-0.27,1 --0.66,3.50,-0.62,0.43,0.23,5.29,3.44,4.70,3.51,6.09,4.92,2.33,0.99,4.57,1.80,1.36,0.32,-1.60,-1.21,1.89,0.40,1 -0.51,-0.00,-0.01,2.90,1.84,2.90,3.82,3.30,1.11,2.29,2.63,2.04,3.39,4.46,3.24,2.27,3.69,1.87,2.53,-1.67,-1.12,0 -0.20,0.80,1.14,0.79,0.16,1.48,1.88,3.43,5.44,4.28,7.46,4.96,4.33,1.10,0.25,2.16,-0.40,-0.40,2.14,2.21,-0.16,1 --0.19,1.73,1.68,1.40,1.82,3.96,5.95,4.81,3.83,4.40,2.61,2.60,0.18,0.23,-0.43,-0.95,-0.38,2.17,1.14,1.17,0.11,1 -0.08,-0.42,0.43,0.94,1.44,-0.34,2.83,2.95,4.48,2.67,5.70,3.53,4.35,4.23,0.07,0.71,-0.69,-0.72,0.29,-0.36,0.10,1 --1.41,1.08,-0.65,-0.52,-0.65,0.19,-0.19,0.68,2.31,2.70,3.04,3.36,2.94,5.11,2.99,3.74,1.53,2.76,0.28,2.23,-1.82,2 -0.92,-0.77,-1.21,0.56,-0.96,-1.26,1.05,-0.52,0.05,0.77,0.73,2.93,3.52,4.53,7.77,4.93,3.83,3.29,0.43,0.32,-1.28,2 -1.43,1.82,-0.22,-2.34,0.60,0.40,1.08,0.85,1.63,4.19,5.41,5.82,4.89,2.08,4.25,0.96,2.49,1.84,1.00,0.34,1.43,2 -1.25,0.32,1.51,0.00,0.41,0.78,0.16,1.16,3.07,2.87,4.25,4.37,3.13,3.67,2.97,3.70,2.84,1.52,1.28,0.91,-0.17,2 -0.55,2.53,2.52,1.73,4.94,4.99,6.82,5.52,2.84,3.30,0.83,1.59,-1.45,0.22,1.75,0.02,-0.87,2.78,-0.26,-0.83,-0.52,1 --0.04,0.07,0.44,0.59,0.04,1.94,3.38,3.75,5.12,4.80,5.73,3.94,2.95,1.95,0.25,1.07,-0.64,-1.28,1.24,-0.25,-0.76,1 -0.65,0.03,0.62,-1.25,-1.09,1.05,3.39,4.64,4.62,4.12,6.16,5.41,3.95,4.07,1.73,-0.84,-1.67,-1.09,-0.04,-0.63,-0.98,1 --0.52,-1.25,0.88,1.81,2.43,4.08,3.12,2.60,3.01,1.58,2.03,1.37,1.81,2.98,1.77,1.47,0.40,0.01,0.86,1.96,-0.64,0 -0.32,-0.20,1.63,2.34,3.29,4.38,3.63,4.86,2.49,3.71,3.56,4.85,1.92,2.53,0.53,-0.33,0.87,-1.48,0.40,0.67,-0.98,1 --1.01,-0.17,-0.72,0.51,-1.60,-0.43,1.74,2.86,2.40,3.77,3.12,5.43,6.15,3.77,1.56,3.02,0.16,0.40,1.94,-0.05,1.31,2 -0.42,2.38,1.73,3.62,2.04,4.83,4.98,3.47,3.43,2.46,3.62,1.11,1.23,-1.48,0.23,1.57,1.83,2.10,1.67,0.61,-1.19,0 -0.21,0.22,-0.13,1.13,2.75,3.39,2.38,6.66,3.44,1.81,3.59,3.26,0.15,1.23,0.36,-1.68,2.09,-0.55,0.31,0.59,-0.80,1 --1.05,-0.43,-0.65,0.85,1.12,0.91,2.04,3.93,3.41,3.94,6.22,3.58,3.63,2.85,2.16,2.30,0.55,-2.57,0.76,2.54,-1.68,1 --0.81,0.48,-0.49,-0.69,-0.67,1.05,3.05,4.01,4.28,5.25,6.30,4.00,1.81,4.41,1.98,1.59,-0.23,-0.21,1.30,-0.73,-1.52,1 --0.86,-2.03,-1.80,-0.82,0.32,0.76,1.23,0.71,-0.86,2.12,4.86,4.33,3.40,5.63,5.23,3.59,3.59,2.68,1.67,0.72,1.75,2 -0.28,-1.61,1.45,-0.15,-0.43,0.83,-0.57,0.60,1.75,1.43,3.60,3.01,4.64,5.01,6.08,3.69,1.73,2.23,0.60,1.36,0.32,2 -0.71,-0.47,-1.69,0.07,-0.13,-1.10,2.67,0.71,4.23,3.27,2.99,5.05,4.88,4.22,4.10,2.44,2.43,2.67,2.47,1.54,0.06,2 --1.18,-2.60,2.61,2.75,1.95,2.66,4.57,3.33,4.79,4.32,3.62,3.95,3.21,1.19,0.68,2.06,0.38,-0.78,-1.50,0.48,0.80,1 -0.04,0.71,-1.35,-1.14,0.08,-2.32,-1.77,-0.64,-0.64,-0.27,2.22,2.61,2.47,4.52,6.50,3.03,5.32,4.70,2.10,0.06,-0.52,0 -0.27,-0.45,1.18,-0.34,0.68,-0.01,-0.66,0.27,2.41,2.25,1.89,5.34,3.08,4.37,5.79,7.08,5.21,2.23,0.52,1.50,-2.65,2 -0.49,1.06,1.98,0.38,1.54,3.40,4.94,3.11,4.22,2.45,4.72,3.86,1.83,1.40,1.42,0.32,-0.56,-0.23,0.22,-0.45,-1.57,1 --1.46,-1.46,2.14,2.03,-0.02,2.28,0.95,2.97,0.06,2.82,3.65,1.44,2.30,3.90,5.71,2.39,1.24,2.56,-0.77,-0.02,0.42,0 -1.43,-0.75,-1.80,-1.68,0.15,-0.35,1.01,0.85,2.23,2.69,3.03,4.39,3.61,5.18,4.47,3.34,1.35,2.20,0.58,1.36,0.50,2 --0.95,-0.73,0.24,1.59,-0.08,3.43,5.45,4.54,5.92,3.32,4.93,2.82,1.81,1.55,0.10,0.48,1.60,1.28,-0.24,0.14,-0.86,1 -0.51,-0.16,0.58,-1.54,0.91,-0.08,2.23,0.87,2.37,3.46,2.40,4.87,5.29,2.44,4.34,1.09,1.63,0.77,0.38,0.40,0.22,2 -2.07,0.28,-0.61,0.48,-0.10,-0.89,2.56,0.17,1.73,2.71,1.78,4.44,5.73,3.40,3.45,3.98,2.03,1.67,-0.59,1.78,0.72,2 --0.96,1.21,2.43,2.95,3.63,4.70,5.66,4.41,4.22,4.05,-0.22,-0.03,0.06,1.73,0.88,0.22,-0.72,0.41,0.17,1.16,-0.50,0 -1.28,-1.42,-0.10,-0.96,-0.36,0.54,1.56,3.34,5.08,5.35,5.49,4.70,3.95,3.79,3.92,1.54,2.27,0.93,2.24,1.60,-1.07,2 --0.52,1.84,1.74,-1.00,1.42,1.62,4.78,2.77,3.51,3.32,4.23,4.69,3.42,0.93,-0.41,0.85,-1.38,-1.32,0.39,-0.75,0.17,1 -0.56,2.51,-2.11,0.80,1.38,-0.85,0.45,0.46,0.07,2.01,1.47,2.15,4.15,4.12,5.70,4.27,3.88,3.10,2.37,1.04,0.14,0 -0.07,-0.98,-0.89,-0.72,0.15,1.45,3.70,1.37,2.84,4.47,5.22,3.96,3.35,3.47,1.68,0.82,0.07,-0.47,1.83,-0.43,-0.68,2 --1.19,-0.21,0.96,0.49,-0.58,-0.03,-1.18,0.20,1.22,0.39,3.57,3.66,4.28,4.46,4.88,5.36,3.72,2.27,0.23,0.80,-0.78,2 -1.25,0.64,0.82,1.76,1.13,2.18,3.05,4.15,2.56,4.97,3.45,2.65,2.74,0.70,0.57,0.03,-0.17,-0.57,0.51,0.22,0.12,1 -0.50,-0.26,-0.80,0.02,-0.41,0.56,0.52,0.23,1.10,2.24,2.72,5.07,4.29,2.71,3.64,3.86,2.10,1.45,2.38,-0.57,-0.25,2 -1.24,-0.54,1.29,1.82,2.70,2.69,4.35,2.08,3.88,1.90,1.85,2.79,2.07,1.48,2.57,1.49,1.59,2.12,1.31,0.16,-0.88,0 -0.46,-0.92,3.08,2.48,2.94,4.56,3.96,4.49,4.42,4.02,3.67,3.07,-0.41,1.04,0.22,1.98,0.44,-0.22,1.51,-0.31,0.25,1 -1.34,-1.59,1.10,1.97,-0.45,3.13,1.87,1.09,0.48,3.92,1.72,3.00,2.93,2.55,3.99,4.20,5.11,0.82,1.64,1.48,1.35,0 -0.39,1.48,0.32,1.47,0.41,1.82,3.68,0.32,-0.96,1.66,2.12,3.64,2.33,3.75,3.94,3.10,2.79,2.06,1.02,0.44,1.28,0 -0.87,1.64,2.29,3.41,3.54,4.39,6.18,3.72,2.37,3.45,1.61,2.10,1.08,1.34,-1.27,-0.01,-1.89,-1.36,0.58,0.85,0.91,1 --0.51,-0.25,0.95,-0.16,-1.26,-0.43,0.16,0.16,0.22,1.54,2.64,1.60,2.94,3.75,4.42,3.45,3.58,3.28,0.58,0.39,0.31,0 -0.41,-1.89,0.55,-0.03,-0.17,0.51,-2.06,-0.17,1.06,2.11,1.30,3.91,3.07,5.14,6.22,3.74,0.96,1.98,0.68,-0.08,0.92,2 -0.42,0.41,-1.05,2.07,0.19,-0.58,1.30,3.26,3.68,5.01,5.85,4.96,3.78,2.08,4.53,1.25,1.89,1.33,0.68,0.00,0.80,2 -0.61,1.01,-0.88,0.60,-0.55,1.31,-0.79,3.33,0.48,1.18,5.13,3.72,4.14,5.13,3.48,2.53,0.15,1.65,3.82,0.24,1.01,2 --0.18,-0.16,3.83,1.60,2.97,4.25,3.16,1.49,2.42,3.08,1.55,2.11,-0.19,1.40,3.50,3.31,1.88,-1.07,2.33,-0.90,0.41,0 -1.11,0.05,0.93,3.06,1.58,1.41,2.71,2.22,3.10,2.63,1.01,1.17,3.24,4.94,4.33,2.80,4.15,2.09,2.10,1.07,-3.45,0 --0.57,0.46,2.81,1.61,2.20,4.96,4.90,2.92,3.31,6.24,1.73,1.64,0.34,-0.09,0.34,-0.60,-0.13,-0.12,-2.47,0.08,0.27,1 --0.31,1.31,2.74,1.02,1.57,2.47,2.43,-0.63,0.46,1.91,1.49,2.51,2.92,3.57,4.34,2.53,2.59,3.33,1.90,-0.10,1.56,0 --2.34,-1.95,0.01,-0.75,2.83,2.31,2.86,1.31,-0.11,1.55,2.67,3.19,3.90,3.07,2.41,3.69,2.25,2.03,0.34,0.53,-0.30,0 -0.16,-0.74,-0.14,0.26,0.50,0.94,-0.74,-0.72,-0.53,0.66,1.37,3.98,4.94,5.23,5.46,5.06,2.39,0.55,-0.44,0.86,-0.14,0 -1.37,0.76,3.25,3.29,1.51,3.40,6.09,5.04,4.70,2.34,1.69,-0.07,-0.12,1.19,0.58,0.37,-0.37,1.23,0.46,1.14,1.11,0 -0.10,0.75,-0.77,1.62,1.03,0.12,0.27,3.74,3.07,5.52,5.03,4.51,2.57,4.88,1.63,2.88,1.66,-1.59,0.87,0.73,-0.04,1 --0.56,0.62,1.81,2.52,0.39,2.98,1.60,2.01,1.20,2.55,2.30,2.58,2.35,3.90,5.62,1.13,2.74,1.88,2.08,1.58,2.27,0 --0.34,2.00,0.31,1.55,4.39,3.31,4.71,3.47,3.61,3.39,0.59,0.72,1.29,1.64,2.84,2.40,2.73,1.56,1.41,0.41,0.32,0 --0.84,0.45,4.30,4.16,4.17,4.38,5.37,5.28,4.68,1.51,1.80,1.28,-1.94,1.13,0.77,0.81,-0.15,1.00,1.18,-1.07,1.25,0 --1.11,-0.06,-0.28,0.03,2.10,0.65,2.08,0.95,0.41,1.02,0.90,2.37,1.00,3.42,5.81,4.38,3.55,3.83,2.65,1.87,-0.25,0 -1.87,0.72,2.28,0.60,2.35,4.06,4.97,3.99,2.61,4.02,1.07,0.89,1.24,-0.06,2.14,0.43,0.83,-0.01,-0.25,1.21,-0.61,0 -0.84,-1.58,-1.16,-0.65,-1.77,2.08,0.39,1.15,0.72,3.73,2.95,3.43,4.03,4.68,4.38,5.69,1.53,2.17,-0.64,1.29,-0.45,2 -0.25,-0.55,0.44,3.81,2.94,2.40,3.21,3.97,3.59,1.04,2.76,1.98,0.98,1.91,1.57,1.77,1.66,-0.26,-0.10,2.28,-1.02,0 -1.33,-0.10,-0.45,1.55,-1.10,1.59,0.01,0.67,0.10,0.79,2.13,3.37,4.35,4.70,6.33,5.44,3.90,2.49,0.82,2.72,2.46,0 -0.74,1.06,2.36,2.22,3.59,2.86,4.25,4.57,4.34,2.29,3.31,3.97,0.78,0.20,0.35,-0.02,-1.39,0.17,-1.32,0.99,-1.54,1 -0.53,0.20,1.45,2.67,2.54,1.99,2.71,4.65,3.85,4.19,5.25,3.50,3.91,-0.03,1.44,0.98,-1.10,-0.96,-0.13,0.06,0.41,1 -1.33,1.74,2.32,-0.05,2.04,0.12,4.48,5.88,5.05,3.42,4.11,4.54,2.72,-0.15,2.96,0.86,0.02,0.07,0.81,-0.50,-0.96,1 -0.27,0.99,2.64,2.02,2.50,5.41,7.99,6.17,3.71,3.28,2.96,-0.02,-0.84,1.40,-2.06,0.08,-0.30,1.29,0.64,-0.55,-1.62,1 -0.95,-0.53,1.49,3.08,4.73,4.04,4.45,4.63,4.95,2.39,2.37,1.43,1.37,1.67,0.52,0.13,-0.80,-0.99,-0.30,-0.13,2.02,1 --0.38,2.19,1.97,2.79,3.87,5.16,6.59,4.73,3.57,3.85,-0.31,1.91,-0.15,0.99,1.50,0.42,-0.53,-0.09,-0.07,-0.31,-0.27,1 -1.37,0.63,0.41,0.83,1.40,2.17,3.09,2.66,3.53,4.46,3.82,3.89,3.50,3.07,1.16,1.89,-1.40,-1.78,0.77,0.61,0.96,1 -1.56,0.59,2.25,1.16,2.22,2.78,4.57,3.08,4.82,2.91,1.63,1.23,1.78,0.90,1.53,2.67,0.37,1.31,0.72,1.99,-0.99,0 -1.37,1.79,-0.36,-0.58,-0.10,1.00,2.45,3.86,4.25,4.10,7.66,6.21,5.19,2.68,2.85,1.23,0.02,0.58,-0.51,0.96,1.88,2 --0.28,1.37,1.78,1.01,3.63,5.64,5.59,4.61,3.85,1.63,2.58,1.12,1.72,0.71,0.09,-0.20,1.45,-1.63,0.78,0.29,-1.06,0 -1.43,-0.58,1.43,0.55,0.62,-0.55,0.31,-0.26,-0.20,2.68,1.23,4.02,4.39,5.88,4.72,5.37,3.47,2.18,0.94,2.42,-0.51,2 --0.81,-0.69,1.34,-1.27,-0.45,-2.38,2.31,1.37,0.68,1.79,2.47,3.06,4.03,4.22,3.46,5.16,4.45,1.58,2.20,2.22,-0.10,2 -1.62,1.48,1.15,0.85,1.91,2.40,4.07,5.18,2.67,4.67,3.65,2.35,0.64,0.09,-0.96,-0.07,-1.25,-0.66,0.57,-0.92,0.27,1 --1.32,-0.35,0.11,1.06,-0.37,1.46,2.22,1.78,-0.02,2.00,3.49,1.45,3.60,2.14,4.87,3.53,2.35,2.35,-0.04,1.46,0.24,0 --0.33,0.58,-0.30,-1.22,-0.30,-0.19,1.23,2.73,3.17,2.16,5.05,3.81,3.99,4.73,3.41,3.61,2.27,1.15,-0.58,0.45,-0.83,2 -1.52,-0.87,0.46,0.80,-1.54,1.39,0.10,3.65,1.40,4.31,5.54,3.44,3.72,3.26,4.05,1.21,0.40,0.21,-1.26,-1.79,0.79,2 -0.70,-0.91,-1.28,1.58,0.13,1.54,2.56,2.57,2.55,5.28,3.66,3.98,3.85,4.82,3.86,0.98,3.93,-0.16,0.78,-1.31,0.28,2 --0.86,0.59,0.29,0.47,3.92,3.90,1.14,1.10,2.93,1.86,3.54,1.38,2.79,2.28,2.97,3.06,0.18,3.53,1.05,-0.05,-0.75,0 --0.74,-0.89,-1.40,-0.01,0.23,-0.60,0.58,1.96,3.40,3.99,7.89,4.48,2.97,2.39,5.27,1.98,2.12,0.16,1.20,0.58,-0.48,2 --0.45,-0.35,0.04,-1.26,-0.47,-0.67,-0.01,0.23,1.10,3.28,4.37,3.84,4.85,2.87,4.14,2.95,0.29,2.12,0.96,1.07,-0.10,2 -0.19,1.59,1.04,-1.24,-0.76,0.03,-0.82,0.42,0.07,0.64,3.83,2.84,4.72,7.00,3.92,6.50,2.52,3.91,0.27,-1.05,0.12,2 -0.58,0.86,1.46,1.48,1.41,2.68,4.60,3.47,2.95,4.97,4.05,1.39,2.15,0.92,0.74,1.78,-0.83,0.18,-0.81,-0.22,0.81,1 --0.12,-1.05,-0.30,0.99,0.57,0.12,0.25,2.44,0.05,3.32,2.80,3.32,5.43,4.42,6.26,4.52,3.65,2.86,2.99,1.66,0.12,0 -1.45,2.00,0.10,0.30,0.62,-0.08,2.89,2.22,2.58,1.68,4.10,4.55,3.93,2.62,4.48,4.16,1.56,2.64,2.76,1.13,0.38,2 --0.78,-0.49,0.57,0.26,1.66,1.04,0.08,2.15,2.25,0.82,1.82,1.33,3.98,2.47,5.36,4.44,4.48,2.66,0.62,0.03,-0.73,0 --2.11,0.84,1.80,1.01,1.08,2.33,-1.04,0.54,1.07,0.33,2.64,2.18,3.65,5.10,4.65,4.83,2.05,2.83,1.51,-0.29,2.20,2 --1.14,0.99,1.76,1.24,3.73,3.35,5.48,4.13,4.92,4.74,4.00,2.48,2.10,2.00,0.22,1.88,-0.43,0.73,-2.63,-0.46,-0.38,1 --0.52,-1.41,0.69,1.09,1.50,3.35,2.30,3.13,1.90,4.87,5.65,3.96,2.68,2.92,-0.49,-1.33,0.54,-1.32,-0.99,0.16,0.16,1 --0.19,-0.12,0.95,1.64,4.79,4.47,5.87,4.25,3.67,3.55,1.80,0.29,-1.21,-0.94,-2.19,0.27,0.47,-1.84,-1.13,1.17,0.57,0 -0.19,-1.65,-0.98,1.06,0.21,1.65,1.10,2.00,1.41,3.04,4.35,4.48,4.09,2.45,3.89,1.34,2.37,0.38,0.55,-0.89,0.06,2 -0.34,0.01,-0.27,-0.95,-0.82,2.08,1.52,1.85,2.76,3.11,5.10,4.67,2.05,2.79,3.21,2.20,-0.03,1.91,-0.88,-1.16,-0.48,1 --1.32,0.65,0.34,-1.27,0.25,2.07,4.13,3.25,4.96,4.05,8.05,6.52,3.95,3.29,2.89,1.67,-0.68,-1.54,-0.12,-0.06,-0.29,1 --0.42,0.10,-0.26,0.66,-0.08,2.26,1.99,1.82,2.28,3.31,5.27,2.50,6.62,2.84,3.02,1.23,0.76,-0.36,-2.38,-0.06,-0.27,2 -0.37,1.73,-0.07,2.41,1.79,2.78,5.15,4.00,5.29,4.89,4.08,3.10,2.24,1.03,1.46,3.06,0.36,0.73,-0.49,-0.44,-1.11,1 --0.17,-1.05,-0.16,-0.59,-0.61,0.05,0.23,0.86,0.88,2.64,1.39,4.83,4.44,3.84,5.23,3.69,3.06,2.13,0.96,0.15,-1.10,2 --0.55,-0.32,0.44,1.90,-1.08,2.80,3.90,2.53,1.57,1.89,4.06,1.48,2.55,4.62,3.47,3.78,3.36,3.47,0.99,1.11,-0.63,0 -0.21,-0.60,2.07,1.43,1.65,0.29,0.69,1.99,3.59,4.24,5.55,2.85,6.19,4.00,1.39,-0.67,-2.52,0.52,-1.94,-1.29,-0.91,1 --0.35,0.13,0.73,0.22,1.17,0.23,2.07,0.43,1.77,1.78,3.03,3.53,5.50,2.61,4.22,3.47,2.43,2.74,0.89,-0.72,0.33,0 -0.81,-0.69,-1.10,-2.00,-0.80,-1.04,0.85,1.56,2.12,0.76,4.77,3.12,4.25,5.00,6.96,3.22,4.60,3.79,2.22,0.61,0.63,2 --1.53,1.94,1.58,1.48,3.77,3.71,6.22,3.85,4.66,2.48,0.85,1.04,0.27,0.83,0.74,-0.96,1.21,0.53,-1.61,1.78,-0.84,0 -1.32,0.30,0.32,1.56,1.39,1.04,2.12,1.62,2.09,2.59,2.50,2.52,2.22,5.29,3.81,1.75,1.92,2.34,0.55,0.24,-0.71,0 --0.27,0.86,0.58,0.48,-0.91,2.09,3.95,3.29,3.16,4.48,5.32,3.26,3.21,1.74,1.31,-0.73,-0.74,0.37,0.33,-0.07,0.23,1 --1.36,-0.27,1.93,1.58,0.16,3.43,2.38,4.58,4.18,3.61,4.26,2.66,4.06,1.85,2.95,0.31,0.93,-2.91,0.23,-1.46,0.54,1 -2.66,-0.92,0.51,0.68,-0.11,1.39,1.25,1.11,0.64,1.36,4.58,3.28,3.39,2.96,4.89,3.64,3.12,3.91,1.20,1.72,-0.85,0 -1.04,0.80,0.15,0.11,-0.42,0.11,0.57,3.20,2.99,3.19,5.38,4.69,3.38,2.55,1.74,2.81,2.27,1.38,3.22,0.25,-0.97,2 -0.55,-0.82,-1.80,1.89,-0.27,0.22,1.00,1.04,2.57,1.36,2.61,3.55,2.76,3.73,4.85,4.75,2.82,2.33,2.53,1.64,0.80,2 -2.05,0.07,-0.30,1.48,1.76,3.75,3.03,1.21,2.84,2.18,2.12,3.34,2.67,4.18,4.42,2.87,1.49,2.41,2.00,0.97,0.76,0 --1.43,0.27,0.54,0.89,1.38,1.05,0.69,0.79,0.47,-0.90,4.47,4.16,2.95,4.10,6.06,3.20,2.16,1.12,-1.71,1.10,-0.05,0 --0.12,-0.40,-0.41,2.54,2.88,4.18,5.24,4.28,4.57,3.68,4.38,2.88,2.70,1.80,0.68,0.21,1.04,0.60,-0.44,0.21,-0.79,1 -0.31,1.63,0.39,-0.18,-0.36,-0.26,0.04,1.35,1.86,0.86,2.27,5.36,4.27,4.14,4.67,2.84,1.83,1.33,2.34,-0.42,1.51,2 --1.23,1.35,1.53,0.71,3.91,4.95,5.68,3.46,2.36,2.42,0.94,0.72,1.96,2.75,0.77,2.01,-0.73,0.65,0.27,0.26,0.24,0 --0.62,0.70,2.59,1.28,3.63,3.87,3.83,4.51,3.61,2.48,1.42,1.70,-0.32,-1.97,1.93,-1.11,1.49,0.90,-0.94,-0.78,-0.91,1 --0.26,0.07,-0.56,0.70,-0.64,1.00,-1.12,1.48,3.14,1.53,2.88,3.68,4.38,4.89,3.66,2.07,1.50,0.99,0.91,0.02,-0.24,2 -0.29,-0.93,-0.60,-0.93,1.36,2.02,1.26,-1.52,0.67,3.13,3.05,3.29,5.41,3.43,3.88,2.26,3.24,2.36,0.05,2.84,1.11,2 -0.20,1.70,1.60,3.63,1.54,3.86,2.97,3.45,0.97,2.55,1.97,1.47,3.07,1.42,2.41,1.76,0.77,2.29,1.11,1.90,-0.06,0 --1.94,0.76,3.69,1.97,2.21,4.24,6.78,4.34,5.19,2.85,0.56,1.90,0.04,-2.82,0.03,0.62,0.80,-1.40,0.64,-1.61,-0.61,0 -0.30,0.67,1.15,0.06,1.19,0.78,0.64,2.27,2.21,4.76,5.67,5.55,4.21,2.19,2.93,-0.32,1.34,-1.58,1.64,-0.53,-1.29,2 --1.18,0.45,1.10,-0.39,0.15,-1.37,1.56,0.43,-0.60,1.72,3.45,3.15,4.85,3.88,2.55,4.56,3.36,0.34,1.37,0.94,0.58,2 -1.51,-1.47,2.21,2.87,1.81,3.09,4.70,3.79,2.86,3.71,3.44,2.15,1.85,1.10,1.88,-0.23,-1.95,-0.43,1.10,0.28,-0.39,1 -0.22,0.41,2.89,2.82,3.85,3.40,5.13,4.34,4.74,2.26,2.58,0.01,-0.96,-1.28,1.11,1.20,-0.28,0.27,0.18,1.15,-1.06,0 -0.96,2.38,1.69,2.03,5.80,5.58,4.84,5.34,3.64,2.42,2.25,0.95,1.95,1.78,-0.60,1.14,1.33,1.75,1.23,2.44,1.29,0 -0.77,1.50,0.17,0.69,0.51,1.11,-0.49,4.01,0.77,-0.66,1.68,3.61,3.31,6.34,4.30,4.24,2.67,4.35,0.35,-1.47,-0.78,2 -0.95,0.77,1.86,0.93,2.71,4.17,4.65,3.96,4.91,4.86,2.15,1.55,0.19,0.16,0.40,0.21,-0.48,0.82,0.05,1.13,0.42,1 --0.31,0.85,0.60,0.04,2.03,2.37,3.24,2.46,-0.09,1.83,3.54,2.22,1.81,2.20,3.30,3.86,2.76,0.48,1.78,2.30,0.36,0 -1.33,1.92,1.27,2.87,4.12,4.23,5.16,3.80,3.67,3.57,3.79,0.37,-0.67,1.24,1.48,-0.89,2.29,-0.29,0.87,1.28,-0.11,0 --0.36,0.71,1.63,2.94,3.27,2.61,6.64,4.54,3.87,3.21,4.13,2.20,1.40,2.63,0.62,0.25,0.30,1.48,-0.14,1.39,0.46,1 --1.08,-1.74,0.46,-0.47,-0.63,-0.13,0.17,2.72,1.19,5.20,5.47,3.57,4.44,3.96,2.97,2.23,1.48,1.77,-0.45,0.76,-0.20,2 --0.21,0.89,0.16,1.48,2.25,4.13,4.24,3.61,1.32,5.07,3.70,2.66,1.80,2.56,0.14,0.33,1.03,-0.19,-0.93,-1.79,1.32,1 -0.36,-0.02,-0.96,0.83,0.77,1.50,3.09,2.40,4.08,4.09,5.00,4.71,1.38,2.04,2.90,0.26,0.13,-1.40,-0.10,-0.61,-1.75,1 -0.85,0.10,0.58,-0.52,0.42,2.62,1.56,2.54,4.09,6.11,6.06,5.34,3.75,3.04,1.94,-0.11,1.78,1.82,0.32,0.78,0.82,2 -0.59,1.25,1.11,1.51,4.51,1.83,4.30,4.81,2.57,3.36,3.07,2.43,2.27,1.50,-0.23,0.71,0.94,0.98,0.78,0.39,-1.56,1 -1.89,0.48,-0.70,1.13,1.88,2.45,4.60,3.11,5.98,4.22,5.27,2.00,2.41,2.58,0.44,2.57,0.82,-0.86,0.28,-0.45,1.25,1 -0.84,0.43,0.39,0.08,0.24,-0.06,2.99,2.01,5.59,5.04,4.45,4.69,4.40,4.77,2.65,0.46,1.37,-0.57,-0.50,-1.00,-0.15,1 -0.36,1.02,0.21,0.03,1.24,0.73,2.77,-0.30,4.02,6.63,5.27,3.98,3.96,1.63,1.18,1.98,0.02,-0.11,1.43,-0.08,0.87,2 -0.05,-0.37,-0.00,0.71,-1.07,-0.50,-0.37,1.66,2.05,2.54,4.97,2.73,4.00,4.32,3.36,3.36,0.82,2.96,0.09,0.26,-0.10,2 --0.16,0.27,-0.94,0.54,2.63,2.06,1.14,2.45,-0.64,-0.76,2.30,1.89,4.06,3.73,3.77,5.45,2.81,2.78,0.95,0.04,1.06,2 -2.24,-0.83,-0.57,-0.39,-1.01,0.38,2.25,3.43,4.54,4.69,6.17,4.95,2.71,3.21,2.44,0.92,0.26,2.06,0.36,-0.76,-1.31,2 --0.67,0.68,1.66,1.17,0.86,1.27,0.82,-0.06,0.20,2.31,1.65,5.05,3.76,6.47,2.73,3.58,1.51,3.59,1.07,1.62,-0.95,0 --0.56,0.10,-0.25,0.81,0.17,0.55,2.25,2.99,2.57,5.07,4.99,6.48,5.78,2.74,2.35,-0.10,-0.62,0.05,-1.40,1.34,0.58,1 -0.43,0.91,2.61,-1.67,2.35,0.10,1.55,1.63,-0.90,-1.15,1.68,2.55,4.35,4.40,5.93,5.22,3.08,2.98,1.15,0.05,0.52,0 --0.68,-0.59,0.24,2.74,1.86,1.71,4.51,4.03,2.29,2.46,2.69,2.39,0.10,1.12,1.18,1.94,1.30,1.34,0.62,-0.07,1.84,0 --1.24,0.64,-0.58,0.04,-0.40,-0.11,2.24,1.73,0.16,1.46,4.08,3.78,4.30,3.10,3.77,3.68,2.44,2.35,1.00,0.73,-0.54,2 -0.17,-1.07,1.74,-0.38,2.27,3.99,3.69,2.20,-0.39,3.13,1.01,1.47,2.46,4.19,2.49,2.46,2.19,0.54,-0.02,1.96,1.75,0 -0.40,0.53,1.51,-1.06,0.55,-0.09,2.40,3.39,3.42,3.89,4.79,6.74,5.19,0.74,2.58,2.35,0.99,0.26,1.37,0.10,-0.02,2 -1.29,1.38,-0.71,-0.46,1.55,-0.07,2.15,-0.36,1.77,2.23,5.08,5.09,4.48,5.66,4.59,3.09,2.21,1.70,1.68,-0.14,-1.35,2 -0.31,1.60,3.22,0.55,2.57,3.90,2.32,2.29,5.54,3.70,4.05,2.90,3.14,2.85,1.43,0.86,-0.35,0.63,1.59,2.15,-0.18,1 --0.68,1.17,0.85,1.22,-0.10,-0.80,-0.96,1.27,1.03,2.62,1.30,2.97,3.45,4.09,5.54,4.28,2.11,2.96,3.16,1.06,1.21,2 -1.35,-0.11,0.83,0.58,0.78,-0.88,1.75,2.18,2.08,4.20,4.85,4.27,4.14,4.24,3.84,2.49,2.16,0.64,-0.27,0.57,-1.68,2 -0.16,0.47,-0.53,1.55,-1.12,0.30,1.24,3.40,4.05,3.28,5.01,4.56,2.73,4.42,3.53,2.56,1.03,1.94,-0.47,1.54,-0.55,2 -0.31,1.38,0.48,-0.25,0.15,-0.46,1.30,1.63,2.20,0.49,2.66,2.73,3.78,3.34,4.68,4.62,1.69,2.50,2.87,0.05,-0.36,2 --0.52,-0.56,1.64,-0.12,0.26,0.11,2.24,2.82,1.32,4.26,6.57,3.52,3.71,4.21,2.39,1.59,0.52,0.01,-0.13,-0.18,-0.56,2 --0.34,0.19,2.58,4.61,4.76,5.52,4.84,4.44,3.72,2.66,4.09,1.15,1.87,0.33,0.57,1.19,-1.15,-0.93,-2.19,-0.62,0.96,1 -0.98,1.46,-0.08,1.71,1.72,-0.69,0.42,3.19,2.11,1.55,2.94,3.17,4.38,4.06,4.39,4.17,2.42,2.34,2.25,2.71,-1.71,0 --1.05,0.91,0.76,-0.85,-1.39,1.22,2.06,1.03,1.25,2.58,4.00,4.78,3.66,5.17,2.80,3.29,2.98,0.73,1.52,-0.15,1.38,2 --1.84,-0.93,1.22,0.51,0.10,-0.03,0.33,1.63,4.56,4.92,5.05,3.95,3.66,3.00,2.39,2.16,1.48,0.30,0.17,0.78,-0.79,2 --1.06,2.02,0.62,2.14,4.10,6.39,7.27,4.58,3.15,1.85,2.05,2.19,-0.11,0.57,-0.42,0.23,0.03,1.90,0.23,3.70,-1.15,0 -0.35,-0.15,-1.89,-1.85,0.05,-0.10,1.20,0.20,0.01,1.41,1.39,4.04,3.97,5.40,4.69,4.22,3.49,3.85,3.85,0.52,1.41,2 -0.09,1.22,3.67,3.55,4.18,3.42,3.43,4.56,3.01,2.34,1.67,2.64,1.27,1.65,2.80,-0.57,0.62,1.20,-0.37,-0.13,1.67,0 --0.06,1.25,0.77,3.22,3.02,3.31,4.10,4.10,2.42,2.46,1.03,-0.05,0.89,0.24,2.29,0.15,2.18,-0.32,1.99,-0.23,-1.43,0 --1.73,0.59,-0.76,-2.23,-0.82,0.75,0.42,0.26,0.99,0.83,1.75,3.69,2.96,4.22,5.68,2.19,3.97,1.61,0.81,0.67,0.59,2 -0.26,-0.15,0.71,2.17,2.84,3.02,2.93,3.03,3.17,0.51,3.50,1.38,2.30,0.62,3.61,0.40,3.55,3.62,0.34,-0.91,0.27,0 -0.04,-1.40,0.58,2.40,0.30,-0.21,0.95,1.10,0.90,0.87,4.95,4.81,2.74,3.20,4.05,4.18,1.84,1.72,1.06,1.81,1.17,2 --0.85,1.31,0.07,2.00,-0.37,2.13,-0.10,0.89,1.07,2.92,3.88,3.98,3.07,2.70,3.72,2.85,2.43,2.05,1.36,1.04,-0.43,2 --1.32,2.33,2.06,1.20,0.70,3.02,6.09,4.46,2.54,2.70,1.07,2.03,0.71,1.38,0.46,0.35,1.40,0.98,-0.74,-1.10,-1.76,0 -0.21,1.09,2.11,2.01,2.50,3.79,5.38,4.41,4.22,4.65,3.14,1.43,-0.31,1.27,-0.38,0.13,0.03,-1.71,-0.26,-1.23,1.61,0 --0.47,-1.10,0.10,1.28,1.19,0.63,2.53,3.67,5.17,3.22,3.93,4.32,2.44,3.54,0.49,-1.64,-0.60,-1.35,1.86,-2.03,-0.48,1 --0.85,0.19,-1.02,1.18,-1.03,1.20,0.88,-1.24,-0.24,-0.52,1.59,3.13,3.03,4.58,5.76,3.96,3.42,1.56,3.28,3.41,-2.06,0 --1.99,0.05,0.58,1.37,-0.22,1.63,1.11,2.85,2.61,2.68,6.28,6.79,6.10,0.60,1.35,2.28,0.66,-0.93,-0.72,-0.04,2.24,1 -0.44,-0.18,-1.90,0.56,0.49,1.23,2.21,0.29,0.93,3.42,2.80,4.73,2.37,4.77,4.87,3.58,2.71,4.39,0.50,1.26,-1.87,2 --0.17,2.76,1.92,3.56,2.93,3.16,5.17,4.32,3.55,2.80,0.96,1.89,2.27,0.71,0.22,0.51,0.03,0.25,0.30,0.80,2.34,0 --0.90,0.66,-0.33,1.56,3.94,3.04,5.49,3.06,5.46,3.16,3.19,0.93,-1.47,2.64,-0.70,0.81,0.39,0.24,2.03,-0.77,0.99,0 -1.58,-0.77,-0.06,0.58,0.07,2.92,0.72,2.63,2.48,2.74,4.27,2.57,2.52,4.22,4.69,2.64,1.85,0.02,1.32,2.07,-0.22,2 -0.59,1.47,-0.66,0.07,0.51,1.15,3.17,2.50,4.12,3.02,3.26,1.27,3.10,1.18,3.98,-0.02,0.21,-1.53,-0.90,1.00,0.54,1 --1.39,0.15,-0.07,1.70,3.07,4.58,5.06,5.32,3.89,3.49,1.37,-0.16,1.48,0.58,1.35,1.45,1.55,-0.22,0.50,0.05,-0.12,0 -1.07,-0.12,0.77,1.49,2.82,1.90,5.91,4.85,3.00,1.92,3.06,2.00,1.23,0.63,-0.48,3.54,0.19,0.45,1.98,1.16,-2.36,0 --1.02,0.83,-1.34,1.13,-0.83,0.44,-0.18,0.16,0.75,0.50,0.27,0.42,2.92,2.86,4.82,3.74,2.03,4.44,2.05,2.43,-0.03,0 -1.12,0.58,-0.07,-0.37,-3.48,-1.00,2.19,-0.00,1.88,3.21,3.22,4.47,5.06,4.61,4.01,3.73,3.63,2.94,1.14,-1.06,0.18,2 --1.54,0.42,1.02,2.64,3.71,4.36,5.61,3.21,3.17,5.03,2.90,3.00,1.38,2.48,1.20,1.22,-0.64,-0.39,0.96,0.07,0.57,1 --0.02,0.84,0.12,3.21,4.41,1.80,5.79,6.28,2.82,4.74,4.70,0.60,-1.02,-0.09,0.76,0.86,1.53,0.78,-0.98,-1.13,0.30,1 --0.33,1.35,2.05,1.35,1.03,2.42,3.81,1.62,4.32,5.21,4.77,2.92,1.88,0.51,2.32,0.44,-0.58,1.72,1.47,-0.14,1.18,1 -1.74,0.17,1.96,1.51,0.34,-0.13,-0.07,0.35,-1.81,3.39,3.35,2.43,6.57,4.07,4.61,4.69,3.75,4.47,1.55,1.78,1.06,2 -1.66,-3.12,-0.08,-0.29,-0.46,1.00,0.81,0.18,0.54,1.41,2.65,3.07,4.90,4.26,4.67,3.58,3.93,3.94,2.51,-0.57,-0.19,2 --0.02,1.25,0.21,1.55,-0.30,2.03,2.68,3.30,3.65,2.88,5.26,4.07,3.83,2.11,2.04,1.72,0.33,1.09,-0.37,-0.59,0.43,2 --0.68,1.15,-0.52,2.18,3.01,5.19,6.11,4.52,2.06,2.14,4.66,2.62,-0.10,1.37,1.09,1.60,0.72,-0.24,-1.37,-2.98,-1.81,1 --0.19,0.46,0.48,0.55,1.00,1.65,4.61,1.97,4.52,5.59,5.40,3.57,2.99,3.46,1.79,1.60,0.46,0.12,-1.65,0.51,-0.82,1 --0.32,0.08,2.34,1.62,2.59,3.14,1.34,2.22,1.79,2.01,2.74,2.49,1.59,2.61,3.01,2.47,2.11,1.73,2.21,1.30,0.24,0 --0.91,2.05,0.32,4.06,0.83,5.94,6.80,6.23,4.13,2.28,3.41,2.86,-0.75,-0.60,0.09,-0.03,-1.76,-0.56,0.23,2.01,0.17,1 --0.04,-0.05,1.28,0.48,1.53,4.88,3.70,3.90,4.99,2.82,2.85,2.65,0.29,1.35,-0.18,0.55,0.96,0.04,1.05,-0.43,-0.16,1 -0.06,-0.82,0.60,1.98,-0.14,-0.20,0.48,3.01,2.63,2.85,4.56,4.15,5.53,4.63,2.48,2.40,0.15,-0.58,3.09,0.98,0.82,2 --0.41,1.02,0.31,2.56,3.46,5.44,5.34,3.74,2.58,2.53,1.66,1.46,0.50,0.17,2.62,0.50,0.15,0.53,0.01,0.72,0.21,0 --0.03,0.79,0.89,0.18,-0.36,0.16,1.34,1.27,0.67,3.16,1.71,2.74,4.14,4.75,4.77,1.92,2.52,4.07,1.65,1.01,-0.66,2 --0.13,0.58,1.55,1.06,3.30,2.32,5.56,3.38,4.17,2.31,4.57,4.39,2.97,2.67,2.31,1.74,0.62,0.81,0.04,0.05,-0.95,1 --0.21,-0.17,1.52,1.08,0.24,4.02,2.27,5.72,3.10,3.02,3.51,4.86,4.30,2.13,1.19,0.55,0.25,0.13,-1.32,1.08,0.74,1 --0.46,0.99,-0.09,1.61,3.69,3.39,5.75,2.61,3.49,3.88,2.45,-0.51,-1.28,3.02,-0.73,-1.24,0.49,2.15,-0.91,-0.46,-0.37,0 -0.85,0.44,-1.16,1.69,-0.42,1.90,-3.28,-0.35,1.02,1.44,1.49,3.77,4.52,4.85,4.96,3.82,2.60,2.80,2.72,1.96,0.49,2 -0.21,-1.90,0.84,-0.01,-0.06,-0.48,0.66,1.87,0.42,0.17,1.60,3.65,3.79,4.55,6.26,3.63,3.74,2.04,3.34,0.52,0.41,2 --1.33,-0.46,3.63,3.13,3.62,4.12,5.06,3.99,4.72,3.44,2.88,1.65,0.45,2.06,-0.26,0.26,-1.23,-0.05,-2.27,0.74,-0.05,1 --1.39,-0.07,0.08,1.06,0.97,0.93,-0.52,0.28,0.02,1.75,3.23,2.98,6.48,3.08,6.32,3.45,3.31,2.97,2.74,2.26,0.30,2 -0.48,1.10,1.47,2.32,3.06,4.11,4.11,5.71,4.01,4.39,3.26,3.97,3.44,-0.13,0.52,1.64,-0.05,-0.30,-1.01,-0.36,1.50,1 --0.10,0.42,-0.06,0.63,-0.26,0.88,0.01,-0.49,0.45,1.45,0.15,0.87,3.33,4.38,4.87,2.62,3.19,4.53,0.84,1.27,1.06,0 -0.15,0.38,1.05,4.52,3.92,4.41,7.63,3.06,4.29,3.08,0.68,1.80,0.20,1.33,0.80,0.58,0.09,1.32,0.58,0.10,-0.11,0 -1.49,-0.17,1.85,1.85,1.65,4.76,3.59,2.84,4.16,3.22,3.22,1.59,2.50,-0.04,2.75,1.93,2.03,0.00,1.12,1.24,1.66,0 -0.40,0.31,1.86,-0.03,2.74,4.40,3.64,4.74,2.56,4.45,3.84,-0.24,0.17,2.66,2.02,0.33,0.68,0.54,-0.23,-0.18,0.10,1 -1.07,0.22,-0.63,1.76,1.73,0.85,3.62,3.02,1.72,1.68,4.74,2.62,0.73,1.72,3.55,1.30,0.08,0.48,0.99,-0.66,0.95,0 --0.55,-0.23,0.06,0.20,0.85,0.57,1.67,3.06,2.18,4.24,5.37,7.32,4.38,3.03,3.92,0.30,1.46,0.49,0.84,-1.16,0.29,1 --0.15,2.54,-0.55,1.16,1.83,3.71,3.56,2.69,2.19,3.77,0.82,1.68,2.83,2.78,2.91,1.56,3.11,0.64,3.39,1.11,0.04,0 -0.89,0.65,-0.30,0.95,0.23,1.25,2.65,1.67,0.81,2.44,2.83,4.94,4.61,4.03,4.98,5.25,2.48,1.47,0.90,1.30,-0.16,2 -0.39,0.74,-1.17,-0.72,-0.36,1.01,-0.38,0.31,-0.84,1.17,3.90,4.32,4.75,4.18,4.75,4.26,3.26,2.18,2.84,1.00,2.95,2 --0.22,-1.42,2.10,1.98,0.26,3.77,4.67,4.49,3.68,2.93,5.26,1.97,3.97,0.08,1.91,1.16,-0.23,-0.01,0.17,-0.76,0.44,1 --0.71,-1.15,1.97,-0.28,0.38,0.36,0.33,1.39,-0.42,1.63,2.26,2.55,3.59,5.80,5.58,5.28,3.04,2.43,1.96,-0.53,-0.18,2 --0.14,-0.62,0.63,0.56,0.36,2.44,0.55,1.56,-0.31,3.05,3.10,2.89,4.58,4.35,3.35,2.42,1.43,3.10,0.91,1.62,-1.34,2 -1.39,0.05,-0.24,0.41,0.47,0.10,-1.19,0.93,0.56,1.28,3.93,3.47,2.34,3.48,5.29,1.74,3.87,2.41,0.21,1.61,1.32,2 -0.16,1.24,0.30,0.06,0.85,-1.58,1.66,2.08,2.91,3.21,2.83,4.63,3.44,4.63,2.76,3.00,0.56,1.82,0.87,0.73,-0.89,2 -2.48,-0.00,-0.05,0.10,-0.59,0.04,1.00,0.48,0.64,0.66,1.99,5.20,4.21,6.18,5.63,5.31,4.15,1.33,1.89,-0.26,-0.28,2 --0.32,-1.60,1.12,1.48,0.58,0.77,0.54,1.15,0.16,2.90,1.11,0.47,0.73,3.05,5.49,4.19,2.96,1.12,1.31,1.04,-1.36,0 --1.77,-0.09,1.02,4.04,4.34,4.28,7.06,4.46,4.24,2.56,2.34,1.55,2.85,1.59,-1.56,-0.30,0.26,-1.72,1.24,0.88,1.16,1 -1.45,-0.51,-0.07,0.27,-1.81,-0.17,0.81,-0.59,-0.24,1.77,1.86,3.65,2.57,4.54,7.21,5.97,4.03,3.13,0.97,0.39,-0.56,2 --1.15,-1.79,-2.66,0.26,1.74,1.35,2.01,2.02,3.80,3.12,3.56,5.20,2.24,3.61,2.37,1.32,-2.13,-1.02,0.31,-2.47,0.51,1 --0.51,-1.20,0.90,0.43,-0.70,2.45,2.96,5.10,4.12,3.70,3.78,5.75,5.73,3.71,0.89,1.77,0.60,-1.13,-0.66,-0.82,1.45,2 --0.82,-1.79,0.67,0.61,-0.11,0.47,-0.05,0.73,2.93,3.41,2.67,3.86,4.87,5.79,5.00,3.71,2.84,0.85,1.23,1.39,-0.31,2 --0.24,2.61,-1.12,1.96,-0.40,1.61,1.56,1.86,2.53,4.02,4.23,3.95,4.59,3.53,2.96,1.96,2.66,1.14,1.00,-0.36,-0.18,2 --0.24,0.63,-1.10,-0.68,1.15,-0.52,0.19,2.14,0.64,4.25,4.82,4.60,4.57,4.18,5.16,3.26,2.58,2.15,1.99,1.17,-0.96,2 -0.88,1.93,1.87,0.89,1.13,2.82,6.55,3.84,4.22,4.08,4.99,3.67,2.34,0.25,-1.34,1.42,-1.85,1.54,-0.79,-0.82,-0.87,1 --1.12,0.62,-0.03,-0.59,0.28,1.17,0.05,0.57,1.35,1.60,3.88,2.41,3.02,6.54,5.33,5.26,4.13,3.77,1.27,1.25,-0.16,2 --0.33,0.17,0.38,2.21,3.34,2.76,5.67,4.86,4.29,4.73,2.60,2.59,1.03,0.49,0.74,1.09,-0.51,-0.24,0.62,-0.99,-0.58,1 --2.81,2.79,2.20,3.03,1.07,1.73,2.83,4.57,5.42,5.47,3.37,3.53,1.98,0.73,2.91,0.16,-0.98,0.01,1.00,-2.53,-1.00,1 --0.77,-0.01,3.93,2.41,3.05,2.10,5.12,4.59,1.82,1.63,1.89,2.54,1.23,2.41,-0.38,0.96,1.15,1.51,1.64,0.08,1.02,0 --0.51,-2.00,0.00,1.50,-0.00,-0.55,0.67,3.05,2.74,2.12,2.95,2.05,4.94,3.68,3.64,3.84,2.00,3.18,2.23,0.27,2.32,2 --2.69,0.25,1.14,1.40,2.82,2.82,4.02,5.76,3.73,3.71,4.21,1.72,1.87,1.40,0.62,-1.07,0.31,-1.24,-0.58,-0.16,-1.23,1 --1.60,-1.03,1.84,0.96,2.28,2.62,5.51,3.48,4.55,4.72,3.95,2.49,3.95,1.32,1.49,1.99,1.11,-0.88,-0.18,-0.14,-0.94,1 --1.10,0.18,-0.29,1.79,3.12,2.40,3.95,3.83,2.57,2.34,0.74,2.43,1.40,2.20,2.96,3.43,1.71,0.25,0.87,0.41,1.00,0 -0.46,0.80,1.03,2.67,1.76,4.34,3.41,3.94,4.78,3.95,2.40,2.90,0.84,1.75,2.86,0.73,0.41,0.55,0.56,-0.67,-0.13,1 -0.40,-0.97,0.05,0.57,0.66,-2.59,-0.45,0.14,0.17,0.54,1.19,2.41,2.78,3.72,6.42,7.39,2.85,1.45,2.90,0.38,0.51,0 --0.24,2.72,1.85,3.00,3.18,2.70,3.56,3.19,2.53,2.59,1.78,-0.81,0.47,1.54,-0.39,1.69,2.02,0.99,1.68,0.38,-0.73,0 -0.76,-0.50,0.52,3.37,4.97,5.36,5.46,4.82,2.09,4.69,1.15,1.86,2.09,0.19,-0.89,0.61,1.98,-0.01,-0.84,0.04,0.90,1 --1.37,-0.03,0.43,2.35,3.79,2.17,5.14,3.94,3.56,3.95,3.21,1.47,2.37,0.54,1.76,0.52,-1.23,0.56,0.27,-1.46,-0.34,1 --0.77,-0.03,-0.43,0.33,0.56,2.06,0.47,-0.32,1.84,2.91,2.61,2.39,3.57,5.33,3.70,4.62,4.25,2.86,2.02,-0.53,-0.79,0 -0.12,-0.29,0.38,-0.20,0.96,0.21,-0.99,1.10,3.27,1.45,0.74,1.91,4.51,3.96,6.43,3.84,5.40,-0.07,2.88,-0.14,0.18,0 -1.13,-1.47,-1.29,0.12,0.05,0.24,1.47,1.53,1.28,4.77,4.79,6.21,3.53,4.09,3.68,3.04,-1.12,0.43,-0.92,0.40,-1.82,2 --0.64,-0.78,0.11,1.46,1.18,0.68,0.32,2.37,3.37,2.36,2.70,3.99,2.93,1.58,4.13,3.98,5.07,2.65,0.99,2.64,0.14,0 --2.95,-0.11,-0.15,-0.60,0.59,3.37,2.63,2.77,4.50,4.01,4.02,4.80,3.93,2.21,2.30,0.11,1.16,0.39,0.73,-0.24,-1.68,1 --0.19,1.42,1.36,2.29,3.19,1.79,5.16,4.52,3.92,4.32,5.24,4.05,2.89,0.78,-0.36,-1.41,1.46,-1.58,-0.26,-0.26,0.63,1 --0.44,-1.31,4.09,1.04,4.26,4.02,5.80,3.88,2.26,3.47,3.57,3.22,0.34,0.73,0.32,1.29,-1.30,0.72,-0.93,1.32,-0.46,1 -0.75,3.83,0.84,3.24,5.45,1.35,5.38,4.25,3.20,5.37,3.33,2.31,0.59,-0.51,0.59,-0.49,-1.22,0.46,-1.17,0.93,-0.07,1 -1.95,-0.44,1.66,2.20,2.83,3.95,4.26,4.31,4.72,4.29,2.65,1.84,0.49,0.06,1.60,0.85,-1.65,0.47,0.82,-0.67,-1.98,1 --1.24,-1.43,-0.85,1.54,0.94,-0.06,0.93,0.66,0.66,-0.45,0.44,4.87,3.39,4.91,5.50,4.72,3.13,2.40,0.82,0.32,0.54,2 --0.25,1.15,2.44,3.95,3.08,2.64,4.26,2.66,2.22,2.05,3.61,1.10,0.63,1.74,0.37,2.97,2.30,-0.64,0.32,-0.79,-0.74,0 -0.77,-0.11,-0.90,-0.14,0.73,0.70,-1.02,-0.22,0.38,3.76,4.01,5.03,5.71,5.78,5.70,3.51,1.91,2.83,1.47,-1.11,-0.82,2 --2.18,0.38,2.65,3.27,3.02,4.61,4.07,1.72,3.49,3.80,1.97,3.33,1.15,0.02,1.99,0.31,1.01,0.53,0.63,-1.20,-1.74,0 --1.80,0.10,0.00,-0.26,-1.92,0.38,1.95,2.62,3.70,3.37,4.03,3.91,4.20,4.11,3.30,2.18,1.64,1.07,0.90,1.20,-1.11,2 -0.08,0.42,0.55,1.20,0.78,0.68,1.59,2.60,0.84,1.77,2.47,3.80,1.99,3.74,4.53,5.75,2.54,0.70,2.75,1.23,-1.39,0 -1.03,1.27,0.62,1.49,0.65,2.16,2.96,-0.48,-0.58,-0.69,0.30,3.20,3.06,3.72,4.33,3.98,2.93,2.11,1.04,-0.10,2.02,0 -1.89,0.34,0.20,-0.47,-0.16,0.18,0.43,2.03,1.78,2.21,2.05,3.75,3.80,3.41,3.75,4.60,2.77,0.95,0.54,0.07,0.06,2 -0.95,1.02,0.73,1.30,-0.06,2.36,0.79,2.29,2.03,1.68,0.94,2.43,1.91,4.64,5.11,3.28,2.00,2.26,1.49,-1.03,-0.61,0 -0.45,-0.15,1.20,1.65,2.24,2.56,4.36,4.22,4.39,4.57,3.58,3.53,1.87,1.84,0.88,1.37,0.70,0.67,-0.36,-0.44,-0.74,1 -0.86,-1.86,0.61,1.03,-0.05,1.75,0.51,0.70,1.28,2.33,1.50,4.31,1.75,6.48,5.91,4.22,3.87,3.49,2.16,1.35,-0.21,2 --1.26,1.21,2.07,1.76,2.58,5.33,6.48,4.67,4.44,1.87,1.25,0.74,1.46,-0.56,1.30,0.76,-0.94,0.33,-1.82,0.69,0.57,1 --0.50,-0.38,0.39,3.44,3.42,4.39,6.94,6.41,4.24,2.80,2.65,1.68,0.97,1.73,0.88,1.07,0.78,0.18,-1.66,0.12,0.50,1 --0.77,2.46,1.06,-0.80,0.19,2.58,1.71,1.62,2.37,1.74,1.54,3.02,3.36,5.16,3.37,3.85,4.37,-0.36,0.03,1.13,-1.17,0 -1.01,0.56,0.46,2.82,3.45,2.33,4.91,3.65,5.07,4.05,3.54,2.80,1.61,0.66,1.78,-1.25,-0.35,-0.11,-1.13,-0.28,-0.02,1 -0.99,-0.03,0.26,1.77,2.24,4.13,5.14,3.15,3.29,2.93,2.45,2.33,2.35,-1.50,-0.54,-0.03,0.86,-0.20,1.36,-1.12,-0.72,1 -0.95,-1.15,-0.11,1.58,1.00,2.33,3.46,1.99,4.24,3.67,5.33,5.45,2.46,6.08,1.44,2.30,0.91,0.22,-1.29,1.16,-0.22,2 --0.49,1.39,-0.24,0.10,1.30,1.00,4.51,2.05,2.02,1.73,2.72,1.01,1.83,1.69,2.57,3.41,1.66,1.88,2.74,1.56,-0.06,0 -0.90,1.05,1.71,-2.40,0.92,1.90,2.18,3.11,4.23,5.29,5.48,5.33,3.61,1.62,1.59,0.33,-0.22,-1.38,-0.00,-0.19,-0.09,1 --0.52,1.10,0.65,1.61,0.94,3.56,4.88,3.98,4.27,6.00,3.46,2.26,1.74,3.72,2.43,-0.73,-0.80,0.89,0.85,-2.06,1.42,1 --0.08,-0.09,-0.96,1.80,2.86,2.44,2.46,1.30,3.13,5.90,5.01,5.54,5.21,4.19,2.10,-0.22,0.27,-0.45,-0.86,2.29,-0.04,1 -0.59,-0.37,0.18,0.99,0.09,-0.29,3.39,2.43,3.83,4.55,7.40,5.27,5.52,1.41,1.28,1.67,-0.54,-0.15,2.01,-0.40,-0.65,2 --2.13,-0.84,2.69,-0.21,1.19,1.67,1.05,1.31,0.10,2.26,2.82,1.31,2.07,3.73,4.53,4.70,2.84,0.53,0.77,0.02,0.41,0 -0.30,1.54,-0.82,-1.61,-0.10,0.54,1.17,3.01,3.80,4.10,4.67,3.71,5.03,1.63,3.30,0.93,0.15,-0.57,-1.18,-0.69,-0.31,1 --0.70,-1.30,-0.15,0.91,2.40,4.27,2.73,3.97,4.61,2.65,3.94,2.30,3.02,0.91,0.01,-0.86,0.48,-1.01,-0.82,-0.68,0.44,1 --1.57,-0.13,1.31,1.67,2.73,2.55,2.96,3.52,1.81,2.27,1.21,0.91,2.40,2.42,3.86,2.78,3.89,2.16,1.25,2.16,0.47,0 --0.53,0.83,-0.22,0.78,-0.41,0.28,1.54,0.67,2.22,3.33,5.77,4.61,3.27,4.30,3.86,3.34,4.72,2.37,0.53,-0.02,-0.19,2 --0.16,0.91,1.30,-1.60,0.07,0.20,-0.73,0.37,1.70,0.68,3.02,4.92,4.38,4.88,4.52,3.21,3.20,1.19,3.38,0.68,-0.81,2 -1.03,1.86,-1.07,-1.37,1.29,-0.59,0.45,1.51,1.96,0.62,2.67,2.16,4.00,2.86,4.56,4.40,2.23,2.63,2.00,1.12,-0.59,2 --0.07,1.62,2.76,0.58,5.30,4.24,5.62,5.26,4.07,2.20,2.80,1.14,0.49,-0.33,-1.05,-0.96,0.77,1.04,0.23,0.42,1.50,0 -1.21,2.28,-0.20,-0.87,1.81,-1.04,1.21,0.78,3.06,3.99,4.42,2.74,3.08,4.75,4.33,4.78,1.73,2.63,-0.40,2.03,-1.07,2 -0.35,0.58,0.74,-0.46,0.72,-0.21,-1.11,2.17,2.94,2.43,1.48,1.65,4.48,4.80,6.07,4.73,2.96,1.43,0.31,1.39,-0.15,0 --1.18,-0.03,-0.46,-0.00,-0.41,1.77,2.06,2.17,0.87,3.60,3.59,4.05,3.74,2.36,3.02,4.11,3.00,0.79,-0.61,-1.25,0.79,2 -0.31,0.02,0.78,2.40,1.97,3.12,0.91,2.95,0.17,2.98,2.68,2.98,1.36,0.10,1.31,0.70,0.18,0.88,1.40,-0.77,1.15,0 -0.59,0.92,-0.33,-0.79,-0.71,-0.95,0.64,-0.67,0.89,0.34,1.73,3.02,4.32,5.54,5.60,4.40,5.19,2.77,1.72,1.35,0.21,2 -0.54,1.11,-1.36,0.96,-0.77,0.77,0.78,3.31,4.30,1.74,3.35,4.24,3.62,3.91,2.08,2.21,0.79,0.13,1.03,0.57,-1.59,2 -0.56,0.20,1.43,0.57,3.63,1.17,-0.06,2.44,0.74,2.62,3.14,1.24,1.17,3.36,1.98,3.88,3.14,0.38,2.82,-0.08,-0.56,0 --1.45,-0.21,1.34,2.69,2.04,4.63,7.07,4.58,3.22,3.58,4.31,3.51,1.16,1.33,-0.07,0.26,-0.97,0.83,-0.92,0.87,-0.20,1 -0.41,1.38,1.40,1.35,3.45,4.98,3.70,3.55,3.25,3.09,2.01,1.94,2.23,0.59,2.12,-0.04,1.48,-1.89,1.04,0.32,-0.03,0 -0.67,1.57,2.71,-1.44,0.30,2.24,1.37,2.49,0.40,0.88,1.79,1.52,4.79,4.74,3.21,3.11,2.09,3.29,2.74,1.33,-1.17,0 --0.91,0.12,-0.26,0.33,1.46,2.18,2.45,3.77,3.93,2.53,5.06,3.51,2.34,0.89,0.64,-0.01,-0.70,-0.08,0.64,-1.13,-0.19,1 -1.29,0.88,-0.64,-0.88,-2.07,0.03,0.77,-0.25,0.98,2.58,1.31,3.78,5.08,6.11,5.39,6.89,5.93,3.54,3.17,1.40,0.82,0 --0.24,1.12,-0.36,-0.44,-1.02,2.15,0.84,2.00,1.04,4.34,3.19,2.00,3.25,4.89,3.96,2.85,1.83,2.19,1.09,-1.34,0.61,2 -0.24,1.14,1.95,-0.31,-0.61,0.76,1.16,1.50,2.30,3.32,4.54,4.72,4.17,3.66,1.91,-0.80,1.29,1.38,2.08,0.54,0.01,2 -1.84,-0.95,-0.01,0.63,2.48,2.04,3.03,3.61,4.28,5.49,6.50,4.24,3.90,2.82,0.42,-1.16,0.38,-1.75,0.85,0.61,0.96,1 -0.45,0.17,0.39,0.14,-1.50,2.08,2.71,3.83,4.70,3.17,6.52,3.93,3.92,2.05,1.78,-1.17,0.06,-1.99,0.18,0.70,-0.18,1 -0.02,-0.42,1.56,0.78,0.16,-0.24,1.27,-3.52,0.09,2.53,2.22,4.06,3.67,3.91,6.19,3.80,4.26,2.09,1.67,1.65,1.00,2 -1.78,0.26,0.27,-1.28,-0.64,-0.71,-0.81,1.58,1.67,0.51,1.47,3.84,2.14,5.41,5.90,5.47,2.99,3.85,1.06,1.13,0.29,2 --0.09,1.44,0.38,0.80,-0.16,0.09,0.81,2.04,3.64,3.08,2.80,6.00,3.67,1.43,3.31,2.24,0.36,-0.35,-0.23,-0.50,0.65,2 -0.14,-0.79,1.27,1.63,0.80,3.69,3.10,2.64,4.84,4.73,2.53,4.01,0.29,2.00,-0.11,-1.90,-0.08,0.59,1.09,-0.35,0.43,1 --0.69,0.61,3.51,0.21,0.61,1.76,2.02,1.35,1.35,1.42,2.42,1.18,2.44,4.46,4.83,4.64,3.72,2.79,0.76,2.27,-0.43,0 --0.88,0.50,2.62,3.71,3.71,4.70,5.65,2.61,3.54,2.08,2.50,2.90,0.48,0.27,-0.05,0.36,-0.84,0.24,0.37,1.22,-1.05,1 -0.57,-0.33,2.15,1.36,-2.66,0.47,-0.87,1.50,0.54,2.78,3.16,3.29,3.78,3.82,5.89,4.16,3.37,1.02,0.59,0.42,0.92,2 -0.69,-0.58,-0.15,0.19,2.44,1.13,3.98,2.52,3.92,5.68,5.91,2.94,2.25,2.50,2.47,0.35,0.12,2.77,-0.89,0.41,-1.63,1 -0.71,1.08,2.34,0.23,4.40,4.72,6.31,6.00,3.46,2.63,1.52,2.33,1.98,2.10,0.15,1.54,0.71,0.77,-0.89,-0.91,0.16,1 --0.17,0.56,0.49,0.68,2.20,2.73,3.54,4.79,1.52,3.16,3.28,2.00,3.08,3.81,3.40,2.77,1.80,3.08,2.32,2.17,-0.48,0 -0.93,1.52,2.10,4.53,2.94,4.06,6.15,5.04,2.61,2.54,2.25,1.21,-0.62,1.14,0.87,0.54,-0.59,-0.56,0.30,0.03,0.92,0 -2.44,-1.34,-0.15,-0.28,0.93,1.00,-0.41,1.14,-1.68,2.32,2.78,3.33,3.49,4.93,3.95,4.75,2.92,1.53,1.24,1.26,-0.37,2 --0.49,0.48,0.16,-0.29,-0.33,0.69,4.03,2.35,4.54,6.29,6.03,7.30,2.38,3.03,2.98,0.47,-0.40,-1.35,0.32,-0.48,0.20,2 -1.14,1.52,1.96,2.80,2.09,4.86,2.24,4.55,1.10,1.24,3.03,2.50,0.01,3.19,2.22,2.23,0.53,0.57,-0.12,0.45,0.01,0 -0.59,0.38,-1.84,1.14,0.22,2.00,0.05,-0.83,-0.04,2.87,2.49,1.11,3.72,3.11,4.21,4.15,1.71,4.09,1.56,0.53,-0.99,2 --0.57,1.14,-1.48,2.26,-0.10,3.29,4.23,2.75,4.02,3.51,3.04,2.04,2.37,2.51,0.38,-0.45,0.49,-0.35,1.91,-0.78,-1.16,1 -1.43,0.19,0.74,0.19,0.68,1.02,-0.19,0.67,0.32,2.37,2.55,4.42,4.34,3.44,5.39,2.91,1.53,1.97,0.93,0.66,0.54,2 -0.98,2.21,1.61,3.62,3.72,3.26,6.17,6.28,4.06,1.38,1.61,0.79,2.34,0.28,0.01,-2.44,0.31,2.70,-0.13,0.21,1.11,1 --0.46,0.21,0.76,2.16,-0.99,-0.47,2.48,1.32,2.31,2.54,4.20,5.20,3.86,3.81,1.81,3.55,1.91,2.42,1.33,-1.28,-2.14,2 -0.49,0.36,1.28,0.73,2.04,3.80,4.05,4.41,1.80,3.90,4.54,1.12,0.66,0.16,2.23,1.42,1.56,-0.49,0.84,-0.87,1.30,0 --0.41,0.02,-0.19,-0.86,-1.05,1.11,0.98,3.65,5.70,3.90,7.00,2.69,3.04,2.27,0.45,0.74,-0.04,-0.34,-0.07,-0.87,-0.56,1 --0.35,-0.39,0.01,-0.70,1.31,3.32,2.06,4.43,3.71,4.16,5.83,5.40,2.75,3.09,2.17,1.95,0.68,-2.24,-0.46,0.58,0.73,1 -0.61,1.40,2.06,0.48,2.66,2.52,2.97,1.25,3.25,0.82,4.01,2.15,2.63,2.48,2.85,3.22,3.15,3.13,1.38,1.11,-2.23,0 --0.68,-0.94,-1.80,0.81,-0.37,-0.30,0.89,1.45,1.40,3.40,3.05,3.31,5.04,5.20,3.09,3.85,1.82,0.54,1.00,1.71,1.42,2 -0.27,1.55,1.52,0.87,2.78,3.56,2.75,2.09,2.96,1.38,0.82,2.77,0.98,3.88,2.84,2.59,1.68,1.56,2.54,-2.34,-0.33,0 --1.22,0.31,1.36,1.09,1.02,0.83,2.92,4.08,2.90,4.64,5.64,6.79,3.90,3.04,1.87,0.24,-1.81,-0.20,-0.57,-0.74,0.25,1 --0.00,-1.03,-0.12,-0.06,-1.34,1.71,2.38,2.49,3.11,3.31,6.22,4.43,3.35,4.40,2.89,1.88,1.70,0.06,-0.81,-0.16,-1.10,2 -1.34,-0.45,2.28,2.38,2.19,2.70,3.66,2.66,3.33,3.14,0.95,4.05,2.16,1.40,2.26,1.67,2.06,-0.41,-0.82,0.12,-0.23,0 --1.36,0.80,0.88,2.47,0.97,3.90,4.10,2.71,1.80,2.72,0.32,1.17,0.84,1.67,0.22,1.64,0.30,0.93,1.33,1.27,0.55,0 --1.00,-0.05,0.85,2.04,0.48,2.07,3.69,-0.44,0.53,2.37,2.35,2.90,1.82,3.45,4.83,4.55,3.43,3.46,1.66,3.29,1.39,0 -0.42,1.68,2.26,0.25,2.04,0.54,2.09,-0.52,-0.75,1.66,1.60,3.19,3.08,3.75,6.03,3.74,5.99,1.99,2.66,1.30,1.40,0 -0.09,1.53,-0.13,1.09,2.86,1.88,3.78,6.88,3.91,2.50,2.97,4.04,-0.01,1.78,2.41,-0.20,0.39,0.94,-0.44,1.35,-0.63,1 --0.46,1.40,-0.95,0.92,2.72,2.79,1.44,2.87,2.45,0.35,2.77,1.70,2.66,3.84,3.09,1.12,2.77,1.16,0.18,-0.88,1.49,0 -0.21,0.57,1.06,3.12,4.50,4.21,4.24,5.02,4.54,2.81,1.17,1.18,-0.26,1.18,-0.34,1.69,0.27,1.53,-1.01,-0.55,-0.42,0 --0.02,1.13,1.70,-1.12,1.11,0.17,1.50,2.11,2.39,4.99,4.09,3.98,4.97,5.12,4.60,2.19,1.34,2.59,1.17,0.38,0.07,2 -0.89,1.18,0.42,-0.33,-0.17,2.15,-0.44,0.49,0.53,-0.15,1.32,1.51,3.61,3.36,6.92,7.11,5.15,1.22,3.02,0.69,-0.43,0 -0.11,-0.49,0.83,0.77,0.31,1.21,4.52,3.50,3.35,4.47,3.83,4.67,4.01,2.07,0.96,1.20,0.47,0.61,-0.26,-1.34,-0.88,1 --0.38,0.72,0.46,1.00,1.97,2.10,1.85,1.34,0.97,2.56,3.78,2.62,2.80,4.25,3.02,1.95,1.46,1.78,1.42,0.04,-0.75,0 -0.52,-0.93,0.19,0.82,-0.46,1.95,1.16,1.98,3.51,2.36,5.16,2.70,2.63,1.82,4.42,1.41,0.29,0.72,-1.16,-0.39,0.94,2 --0.72,2.24,0.84,1.93,2.02,3.40,3.29,3.36,2.87,3.50,2.95,1.85,0.90,0.85,1.53,0.78,0.92,0.90,-0.12,0.01,1.88,0 --1.04,0.59,0.25,1.13,1.96,1.54,2.29,3.59,5.81,4.88,5.08,2.77,2.78,3.43,1.85,-1.02,-1.24,1.00,0.20,0.02,-1.01,1 --0.10,-1.16,1.51,1.42,2.63,2.25,3.80,2.50,2.90,3.66,0.30,3.91,0.20,1.54,4.55,2.48,1.57,0.16,1.43,-0.57,0.21,0 --1.49,0.16,2.73,3.81,3.61,4.14,6.25,6.85,2.77,1.70,2.67,1.61,-0.62,-1.57,-0.87,0.07,1.40,0.67,-0.17,-1.68,-2.06,1 -1.23,-0.87,0.98,0.60,1.85,3.97,4.79,4.85,2.45,5.70,4.90,2.79,2.56,1.16,-0.46,0.39,1.67,0.37,-1.05,-1.14,-1.13,1 --1.52,0.05,0.35,0.48,-0.77,-1.77,2.06,-0.48,-0.18,0.50,2.61,2.02,4.02,5.15,5.84,3.94,4.69,1.56,1.30,0.63,0.56,2 -0.84,0.22,0.24,0.70,4.55,1.64,4.21,5.12,4.19,3.76,4.92,2.12,0.64,0.09,0.89,2.13,0.10,0.69,-0.06,1.11,-1.14,1 --0.78,0.00,-0.01,1.85,-0.87,0.38,-0.86,1.38,-0.24,2.56,1.63,2.34,2.50,3.78,4.12,3.77,4.54,4.24,0.06,0.35,1.84,2 --0.60,-0.51,-0.67,-1.17,0.67,-0.13,1.25,2.64,2.98,4.32,3.29,4.74,4.85,3.65,1.83,0.12,2.34,-0.88,1.57,1.12,0.51,2 --0.63,-0.63,0.19,0.87,1.39,2.13,-1.00,2.14,0.65,0.70,1.72,3.13,3.49,4.54,4.58,4.10,4.86,3.72,0.62,-0.02,-0.97,0 -0.54,-0.58,1.93,-0.01,0.10,2.41,3.57,3.30,3.33,4.99,4.61,3.00,6.12,1.71,2.99,-0.17,-1.27,-1.32,0.13,-1.00,-1.52,1 --0.03,0.28,2.02,-0.31,3.27,3.95,5.02,3.22,4.25,4.38,2.81,0.60,2.10,2.27,1.22,0.88,-0.79,0.79,-1.01,0.13,0.68,1 -0.96,3.32,1.94,2.28,2.98,4.46,6.14,3.83,4.40,4.49,2.31,3.83,1.03,0.14,0.59,-0.65,0.71,-0.73,1.10,-0.58,-0.59,1 --0.44,0.84,2.39,3.15,0.73,3.45,2.62,4.88,3.77,3.82,4.01,0.13,1.47,1.78,1.21,0.38,-0.30,0.85,0.88,0.78,-0.46,1 -0.49,0.70,-0.23,1.58,2.33,3.39,2.26,5.13,6.11,4.08,2.83,2.70,3.06,3.10,2.59,0.35,-0.96,1.14,-1.07,-0.38,-0.12,1 -0.32,0.13,1.11,0.88,-0.87,3.93,3.19,4.35,6.21,4.48,3.87,2.05,3.44,1.31,1.16,0.14,0.38,1.55,-0.54,-1.59,0.32,1 --0.10,1.40,-2.28,0.66,1.09,2.50,3.77,3.42,3.26,5.22,5.38,4.79,2.87,4.61,1.63,-1.40,-0.89,-1.05,-2.46,-0.91,-0.98,1 --0.30,1.46,0.33,-1.94,0.35,0.11,0.10,-0.41,0.94,1.71,3.50,0.91,4.67,4.44,6.56,4.93,2.74,2.56,1.03,1.36,-0.50,2 --0.59,0.68,1.57,1.55,2.57,4.68,4.20,7.10,5.38,2.47,1.04,1.34,1.95,-0.21,2.77,0.77,-1.54,0.54,0.38,-0.86,0.51,0 --0.55,-1.18,1.31,1.77,1.56,1.62,3.20,1.36,6.09,5.54,3.57,3.10,3.16,2.54,0.88,-1.24,-1.31,0.23,-0.47,1.15,1.14,1 -0.56,0.62,-1.40,0.57,2.15,0.36,0.75,0.80,-0.55,1.39,2.47,2.01,3.42,3.60,4.36,3.43,3.69,2.39,1.43,-0.27,0.50,0 --0.78,-0.70,0.12,-0.12,-0.56,0.00,0.57,0.65,0.84,2.19,3.48,4.85,3.93,5.39,5.81,2.38,4.05,1.63,1.63,1.31,-0.21,2 --0.08,1.87,2.91,2.43,2.50,5.06,4.87,4.43,3.93,1.89,2.39,0.84,-0.50,0.72,1.78,2.29,-0.40,0.28,1.73,-0.41,-1.47,0 --1.59,1.70,-1.70,0.79,0.41,-0.29,0.91,2.45,4.30,3.46,5.43,5.37,3.18,3.14,2.92,2.54,-0.17,1.52,1.41,2.34,0.72,2 -1.10,1.62,0.38,1.20,4.10,3.93,7.06,4.02,4.79,3.11,3.16,2.33,-0.63,0.89,-0.10,0.58,0.96,0.66,-0.71,-0.53,0.62,0 --1.88,0.83,1.01,1.29,1.32,2.30,5.65,5.23,4.20,4.59,2.54,0.61,2.14,1.71,1.63,0.45,0.49,-0.11,1.00,0.91,1.17,1 -0.69,-0.25,1.35,0.97,-0.22,1.66,0.99,-0.18,0.77,2.09,3.49,3.28,2.52,4.38,4.07,3.54,3.05,3.15,-0.10,0.20,1.04,2 -1.37,0.31,-0.29,-1.54,1.51,3.05,4.22,2.46,4.10,5.01,3.54,4.28,2.04,2.25,0.51,-0.05,-0.96,0.25,-1.29,-0.40,-1.24,1 -0.29,0.44,1.16,0.88,3.02,0.76,3.73,5.48,3.64,3.65,4.89,3.39,0.66,1.95,0.30,-0.44,-0.18,-1.56,-1.29,1.36,-0.02,1 -0.03,0.72,-0.44,0.20,3.14,2.92,3.42,3.04,1.76,2.20,0.82,0.98,1.80,3.06,2.83,4.49,3.48,1.79,1.53,1.55,1.27,0 --0.97,1.84,0.82,-0.56,3.96,4.42,4.74,4.75,3.61,2.48,0.95,0.97,1.69,-0.18,1.88,1.91,0.34,1.40,1.21,0.92,1.10,0 -1.61,1.87,-0.15,1.36,3.04,4.33,5.58,5.75,5.69,3.76,0.66,2.16,0.77,-1.23,0.91,0.81,-1.47,-0.71,1.42,0.30,0.13,1 -0.29,-1.24,1.49,1.96,1.82,2.78,4.71,4.91,3.25,4.18,3.76,3.29,1.72,2.23,1.67,1.46,0.21,0.35,-1.31,-1.08,-0.29,1 -0.60,0.13,-0.46,-0.38,0.17,0.95,0.57,2.85,1.57,5.68,5.95,4.32,4.34,4.10,2.64,0.77,0.59,0.49,-0.97,1.82,0.61,2 --0.41,-1.09,-0.52,1.65,-0.45,-0.47,-0.14,2.17,3.18,2.51,3.68,2.83,2.70,4.77,2.62,2.97,1.66,2.15,0.14,0.80,-1.40,2 --0.80,0.09,1.96,2.44,2.05,2.99,3.01,2.65,2.70,2.01,1.26,3.01,2.78,3.39,3.39,2.81,0.14,1.89,1.82,-0.82,-0.78,0 -0.16,0.01,-1.09,0.28,0.36,0.94,0.46,4.14,3.02,5.28,6.16,4.81,3.49,2.28,1.20,1.37,-0.33,1.40,-0.34,-0.74,-0.99,2 -0.09,1.77,1.36,1.95,2.21,4.02,4.07,4.46,4.20,2.74,2.80,1.67,1.96,0.19,1.42,2.36,0.62,-0.87,-0.57,-0.09,-0.69,1 --1.58,1.79,1.33,3.23,1.98,3.38,5.54,3.94,2.84,2.46,2.12,2.64,-1.51,0.80,1.88,1.57,-0.37,1.72,-1.15,-1.43,-1.21,0 --0.06,1.44,1.23,2.17,2.63,2.88,1.94,3.71,2.69,5.13,2.01,1.28,1.44,1.55,2.28,2.25,1.21,1.36,3.21,0.77,0.64,0 --1.72,-0.64,-1.44,0.16,0.05,1.20,1.36,-0.07,0.53,2.68,2.00,3.29,2.27,5.99,5.65,6.08,3.20,3.34,1.68,1.01,-1.69,0 --2.21,0.29,1.25,1.47,-0.57,-0.72,3.10,-0.53,-1.42,2.46,1.74,3.58,3.46,3.88,5.61,5.91,3.16,3.77,2.03,0.90,0.66,2 --0.79,2.19,2.29,0.64,3.15,1.64,2.29,4.56,5.22,5.12,5.58,3.37,2.90,0.40,1.95,-0.68,-1.76,-0.44,0.52,-0.06,-1.05,1 -1.01,0.56,-0.19,-2.36,1.33,1.05,1.55,0.89,3.55,4.97,6.28,4.93,2.75,2.70,1.09,2.14,-0.30,0.37,-1.68,0.76,-0.47,2 -1.20,1.26,-0.41,-0.40,0.38,-0.92,-0.66,-0.18,1.06,1.04,0.63,3.91,4.00,5.58,5.33,2.87,4.22,3.16,2.99,0.22,-1.53,0 -0.25,2.37,1.01,2.47,2.79,5.82,5.27,3.76,5.37,1.43,1.73,1.23,0.07,-1.25,1.37,0.87,-0.39,1.94,0.27,-0.89,-0.22,0 -0.62,-0.10,2.55,1.52,3.02,3.04,5.89,4.25,4.62,3.87,0.66,0.45,0.33,2.01,0.07,0.44,1.00,0.52,2.78,0.75,-0.71,0 -1.34,0.20,0.79,1.35,2.88,4.04,5.49,5.41,4.29,3.35,4.07,0.82,2.29,1.69,-0.65,0.57,0.52,-0.09,-0.26,-0.27,1.35,1 --0.81,1.08,-0.55,-0.56,-1.14,2.52,1.57,2.25,2.54,2.98,6.25,3.41,5.69,3.06,2.55,3.33,3.37,-0.33,1.85,2.19,-0.50,2 --0.28,1.54,1.08,-0.16,1.66,-0.29,3.53,3.12,3.00,5.13,7.42,5.05,4.10,1.62,3.09,0.66,-0.81,1.28,0.25,1.35,-0.81,1 --0.52,-1.24,0.33,0.63,4.30,3.43,4.24,1.56,2.00,1.95,2.92,0.97,3.71,0.43,1.04,2.09,3.26,0.42,1.15,0.74,-0.07,0 -0.08,-1.87,-0.25,1.52,1.28,1.61,3.39,3.77,3.78,3.19,6.53,4.85,3.81,3.34,2.64,0.77,1.46,-0.74,-0.41,0.60,-1.43,1 -1.37,0.38,1.42,1.10,0.24,2.97,3.38,2.44,2.39,-0.45,3.21,1.38,3.58,2.79,4.63,2.62,3.83,1.75,2.25,2.35,-0.38,0 --0.28,1.47,1.34,0.80,0.62,0.06,0.99,1.12,-0.44,0.03,2.90,3.43,4.42,5.24,7.67,2.24,2.86,3.67,2.85,2.67,0.30,0 -0.08,0.30,-0.59,0.22,2.38,2.76,2.68,2.08,1.26,0.72,2.64,1.95,0.47,3.57,1.80,1.72,2.48,0.91,0.51,-0.74,1.43,0 -0.76,-0.67,-0.39,0.54,-0.55,-1.25,0.25,1.31,0.12,0.24,0.66,4.80,4.42,3.86,5.46,4.07,5.21,2.61,2.05,0.62,0.39,2 -0.87,0.96,0.99,0.54,4.22,1.18,3.53,3.12,5.68,4.25,4.91,3.82,4.05,1.72,0.18,0.19,-0.69,1.55,0.84,1.60,0.06,1 --1.34,0.75,1.10,1.74,1.22,2.48,3.85,2.27,3.69,3.49,1.82,2.19,0.59,0.89,1.05,1.60,0.19,0.12,0.95,0.80,-2.15,0 --0.32,0.32,-0.62,-1.15,2.25,3.48,4.94,5.38,4.18,3.74,4.28,4.32,2.48,3.59,0.88,0.24,1.11,-1.14,-0.91,0.35,1.48,1 --0.86,-0.63,-1.12,-0.60,-0.32,-0.28,1.87,5.23,2.83,2.91,6.70,4.44,5.74,2.36,2.42,1.42,0.98,-0.24,1.46,0.10,0.82,2 --1.35,-0.08,1.79,1.69,1.27,1.44,1.92,0.51,1.83,5.40,2.71,2.81,3.44,4.82,2.41,4.04,1.54,2.59,2.26,-0.36,-0.66,0 --0.93,0.90,0.67,3.31,2.35,4.74,5.23,5.55,4.54,2.10,1.63,-0.22,-0.41,0.58,-0.97,0.55,-1.32,-0.45,0.36,0.63,-1.81,1 --0.38,1.18,1.07,1.23,3.57,6.10,3.73,3.47,3.81,4.56,3.52,1.08,0.58,0.35,0.06,1.44,0.51,0.66,0.97,-0.72,0.26,0 -1.67,1.97,0.75,2.76,3.25,4.51,6.99,3.68,3.87,3.21,1.14,1.55,0.74,-0.81,0.53,0.40,1.31,-0.15,0.19,0.94,0.06,1 --0.14,-0.68,-0.70,-0.96,1.49,1.85,3.62,2.77,3.08,5.83,4.65,4.94,2.35,4.50,0.79,1.65,2.22,-0.94,1.65,0.78,-0.64,1 -0.70,-1.91,-0.30,0.39,-0.15,-1.10,-0.27,-0.89,0.04,1.56,3.68,4.18,4.08,5.65,4.39,1.90,3.13,1.98,2.69,0.24,0.83,2 -0.13,0.58,1.12,2.35,3.71,2.68,4.38,3.46,1.06,1.64,1.77,2.88,1.56,2.48,3.02,0.85,2.46,1.93,1.18,1.71,-1.61,0 -1.88,-0.91,-0.64,1.10,-0.38,1.41,0.51,1.13,-0.11,2.33,5.47,4.62,3.51,6.24,6.25,2.38,3.90,1.78,1.30,0.61,-0.41,2 --0.23,-0.61,1.00,0.14,-1.56,1.55,2.34,3.92,5.61,4.71,6.14,4.36,1.95,4.85,1.95,0.68,-0.64,-0.69,-0.27,-0.74,0.56,2 -1.44,-0.87,-0.91,-0.12,-1.16,-0.10,1.28,4.12,5.13,3.60,5.36,5.57,3.30,3.46,0.51,0.04,-0.25,-0.02,0.10,-1.17,-0.50,1 -0.94,-0.90,1.28,1.47,-0.13,-0.15,0.52,0.37,0.22,0.90,4.33,2.24,3.98,4.53,4.79,4.31,2.41,1.16,0.37,1.53,-0.40,2 -0.30,-0.48,0.11,-0.94,0.34,0.35,1.90,0.39,1.02,1.98,3.99,4.57,3.61,2.73,2.90,4.43,1.97,1.40,0.49,2.76,2.25,2 --0.57,-0.12,1.06,1.49,2.68,0.69,2.01,3.06,4.76,4.26,8.56,4.82,3.91,2.59,3.66,1.31,1.22,-0.38,0.72,-0.03,-1.00,1 -2.41,2.48,1.17,2.32,2.62,3.37,5.51,4.64,4.02,2.32,2.06,1.93,1.64,1.19,1.34,1.40,0.99,-0.03,1.18,-0.52,1.22,0 --0.89,0.06,0.97,-0.86,2.56,1.89,1.23,0.57,3.61,2.67,1.81,1.49,1.80,4.34,4.46,5.17,2.72,2.21,2.13,0.12,0.18,0 --1.32,2.23,1.85,2.03,3.06,4.86,3.92,5.17,3.40,4.17,3.73,1.24,0.66,-0.24,-0.11,0.33,1.81,1.02,-1.32,0.59,-2.70,1 --0.60,0.93,2.12,1.32,2.72,2.66,4.69,4.16,5.08,3.25,3.09,0.99,1.56,-0.63,0.16,-0.88,0.48,0.16,-1.62,-2.07,-0.22,1 --0.59,0.14,3.44,1.66,2.75,2.49,1.67,2.79,2.73,1.31,1.06,0.84,3.63,0.50,1.56,3.01,2.54,2.17,1.29,0.84,2.21,0 -1.21,1.49,1.94,-0.92,-2.85,1.41,0.53,3.86,3.83,6.84,5.68,5.82,3.35,2.41,2.44,1.84,0.85,-0.40,1.01,-0.42,-1.34,2 --1.50,0.41,-0.06,-0.55,2.86,1.96,1.48,0.69,2.66,2.44,1.56,2.75,4.30,4.27,4.49,2.39,2.89,2.08,-0.38,-0.13,-1.13,0 --1.36,2.84,1.14,0.40,2.01,0.68,2.86,3.67,2.41,3.13,1.43,3.15,1.08,3.33,4.50,1.97,1.34,1.51,3.61,0.45,-1.18,0 -0.70,0.13,1.71,2.53,4.21,5.74,5.91,4.94,3.72,4.24,1.74,2.09,1.46,-0.80,-0.71,1.69,0.75,-2.21,-0.42,-2.33,-0.88,1 --1.32,-0.54,1.09,1.81,1.02,1.65,3.06,3.21,1.96,2.86,1.84,3.16,4.48,3.02,3.69,2.29,2.06,3.45,2.27,0.40,-0.39,0 -0.42,-1.72,0.06,-0.68,-0.63,-1.05,-0.27,3.26,3.93,5.37,5.58,3.61,2.75,3.93,3.64,2.45,0.86,-0.86,-0.00,0.93,-1.01,2 -0.57,0.62,0.86,3.38,2.65,4.10,6.40,4.78,3.17,4.03,0.96,2.36,0.85,0.89,0.69,1.39,0.49,0.03,0.74,0.07,-0.86,0 --0.21,0.59,0.76,1.89,4.43,5.73,4.39,3.39,3.92,4.57,0.76,-0.32,1.30,-0.81,0.17,0.26,1.35,-0.13,-0.37,-0.31,0.90,1 -0.53,1.48,2.16,4.09,2.41,3.07,5.76,3.52,5.43,3.11,1.81,0.77,-0.37,0.59,0.73,-0.80,-0.64,-1.63,-1.18,-0.29,-0.59,0 --0.21,-0.08,-0.24,-0.42,-0.62,1.26,0.25,-0.05,-0.26,0.98,1.38,2.30,2.54,4.54,3.16,6.22,4.92,1.62,1.62,-0.16,-0.46,0 -0.27,-0.94,-0.23,1.10,0.49,1.67,2.38,4.14,4.40,6.72,7.88,6.12,3.45,2.98,3.04,1.76,1.14,-0.16,0.63,-1.77,1.40,2 -0.48,1.59,0.83,0.03,0.12,0.06,1.70,-0.46,0.94,2.46,4.83,3.58,2.59,4.75,5.07,3.24,1.48,1.38,0.27,0.47,1.24,2 --0.93,-0.23,1.06,-0.22,-1.21,1.75,0.61,0.74,2.32,2.31,6.38,4.65,4.48,3.93,2.61,4.84,0.97,-0.35,-0.24,1.46,0.55,2 --0.62,2.72,0.37,2.55,4.39,3.69,4.22,3.49,2.94,3.04,3.11,1.98,0.94,1.05,-0.30,0.91,1.06,0.78,-0.65,-0.56,1.07,1 -1.76,-0.84,0.54,0.10,1.16,2.94,4.63,2.43,2.05,3.15,5.45,2.22,0.96,1.05,3.80,1.30,2.92,2.33,1.64,2.03,0.92,0 -0.74,0.42,1.01,1.85,1.56,2.91,2.88,3.05,4.88,1.25,6.60,4.09,5.19,2.34,4.90,1.85,-1.31,0.86,0.68,1.11,1.28,1 -1.91,-1.85,0.14,0.07,-0.10,2.27,-0.05,-0.40,1.71,2.73,2.33,3.70,2.44,6.33,5.24,5.03,4.16,2.11,4.54,1.12,0.96,2 --0.91,0.12,0.48,0.31,-0.99,0.32,0.78,2.69,2.38,1.94,3.95,1.70,3.04,5.80,4.78,4.66,2.01,1.57,1.50,0.79,0.63,0 --0.37,0.01,0.10,1.62,0.51,1.88,1.91,0.20,1.86,1.12,1.58,2.41,1.50,3.04,4.69,4.25,4.45,2.29,1.63,2.72,-0.99,0 --0.73,-1.60,1.17,-1.44,2.58,0.52,2.70,0.92,1.88,2.26,5.72,4.06,3.78,3.52,4.03,3.47,0.15,2.17,1.30,0.71,-1.34,2 --0.19,1.11,1.22,-1.57,-0.10,1.49,0.08,3.21,1.88,3.09,4.51,2.62,4.92,3.27,2.31,3.02,2.56,0.71,0.32,2.21,-1.34,2 -0.04,1.59,2.10,2.39,5.42,5.41,3.49,3.84,5.53,0.90,4.15,0.90,1.12,0.56,0.50,0.55,0.56,0.22,-0.90,-0.99,-0.57,1 --0.20,-0.79,1.58,2.23,3.50,4.37,3.06,4.01,2.36,5.54,5.02,2.12,1.45,1.22,-0.77,0.09,0.08,0.88,-0.49,2.08,-1.10,1 -0.39,0.69,-0.10,-0.09,0.21,0.49,3.70,1.68,2.07,1.12,0.47,1.64,1.54,3.13,4.83,3.85,2.74,-0.24,2.91,0.71,0.68,0 -0.33,1.14,0.02,2.30,1.81,3.11,2.21,5.02,4.15,4.34,4.40,3.26,1.67,2.30,1.21,-0.63,0.64,-1.15,-0.56,-0.99,0.11,1 -0.57,0.13,-1.13,0.51,-0.32,0.02,0.36,1.57,0.08,2.38,3.79,4.09,3.76,3.96,4.40,4.78,3.31,2.16,2.30,-0.49,0.53,2 -0.79,2.02,1.95,1.63,4.06,6.13,5.53,4.13,1.50,1.08,2.66,1.88,0.03,1.10,1.24,1.33,2.17,0.22,1.47,0.98,0.30,0 -0.64,0.79,0.26,0.39,2.25,2.86,2.54,2.26,3.99,1.25,3.01,3.73,2.72,1.32,-0.01,-0.34,0.22,0.90,1.02,-1.28,-0.66,1 --0.58,0.99,1.74,0.60,-1.72,-0.25,1.54,2.63,5.82,5.95,5.99,4.74,4.63,2.85,0.73,-0.67,-0.41,0.20,-0.65,-1.57,-1.12,1 --0.23,-0.40,2.44,4.46,1.57,4.35,6.21,6.20,3.34,2.73,2.12,3.35,1.46,1.58,0.02,0.90,0.18,-1.39,-0.58,-0.56,-1.48,1 --2.05,-0.45,-0.44,0.99,-0.43,-0.42,2.73,1.20,2.56,4.53,4.01,4.54,5.19,3.45,2.74,3.13,-0.26,0.42,0.26,-0.54,0.21,2 -0.57,-0.22,0.34,-0.02,-0.57,0.50,1.15,1.30,1.86,0.48,1.86,1.95,3.80,3.92,4.59,2.88,2.41,1.97,1.06,0.01,-0.82,0 -1.22,-0.71,-0.44,-1.03,0.77,1.24,0.33,-0.65,1.97,-0.46,2.24,4.89,3.71,4.41,4.89,5.18,4.70,2.76,1.85,1.40,0.90,2 -0.10,0.07,-0.21,-1.14,-1.23,1.49,0.16,-1.07,-1.36,-0.11,0.73,3.16,2.77,5.53,6.56,4.61,3.92,2.89,0.10,0.41,-2.56,2 -0.79,-0.45,0.12,0.83,0.64,-0.02,0.14,0.72,1.06,1.62,-0.23,2.46,4.23,3.08,7.06,5.02,3.24,4.03,0.72,1.89,1.68,0 --0.45,0.26,2.08,3.34,3.01,3.49,4.71,5.27,6.42,3.12,3.68,1.98,0.26,1.88,1.36,0.15,-0.77,0.03,-0.47,-0.12,0.24,1 --0.25,-0.21,-0.07,-0.20,-1.05,0.48,-0.35,0.11,2.87,-1.12,2.81,2.37,4.26,3.00,5.17,4.01,5.70,2.44,1.02,-0.54,-1.35,2 -0.25,-0.23,0.10,1.23,0.23,1.61,3.44,2.23,3.91,4.08,2.76,4.29,2.66,1.74,1.56,-0.85,0.28,-1.23,0.61,0.56,-0.03,1 -1.31,-1.75,-0.22,0.96,0.75,1.94,3.03,2.43,1.77,2.29,1.14,2.47,1.45,2.66,3.37,1.17,1.73,2.70,0.60,0.79,-1.17,0 --0.47,0.23,0.22,1.07,0.03,3.46,2.37,1.24,4.16,5.21,5.79,5.76,3.14,3.11,0.99,1.49,-0.20,0.84,-1.29,-0.16,-0.79,1 -0.45,1.83,0.40,2.34,1.65,4.35,5.97,5.80,3.97,2.35,1.54,0.65,2.29,0.69,-2.10,1.00,1.08,0.09,0.50,-1.03,0.76,0 -0.12,1.67,1.37,1.44,3.17,4.32,6.48,3.90,4.17,1.83,2.19,1.25,-0.37,-0.22,1.35,-0.02,1.72,0.15,0.86,0.76,-2.77,0 -0.24,1.29,-0.49,1.86,1.27,0.90,2.15,2.11,0.90,1.56,3.91,1.99,3.21,4.17,4.73,2.47,1.67,2.99,0.61,0.93,0.84,0 -0.56,-0.02,1.58,0.64,0.48,-1.06,0.56,1.65,0.89,3.63,2.94,2.06,3.17,3.36,4.71,3.11,2.97,0.24,1.46,3.08,-0.58,2 -0.67,2.02,2.24,3.24,3.33,1.89,3.01,6.03,5.25,2.98,3.76,3.74,1.32,0.27,0.56,1.11,0.19,1.53,-0.73,-0.56,0.39,1 -0.11,0.43,1.73,2.91,2.58,4.59,4.35,4.37,3.54,0.15,4.21,2.75,1.17,2.04,1.22,1.88,1.26,0.53,1.52,-1.07,0.11,0 -0.12,0.32,1.36,3.10,2.39,2.93,3.98,6.30,6.00,5.11,3.74,1.50,2.35,1.85,1.09,1.03,-1.12,1.87,-1.70,0.17,-0.02,1 -0.69,1.04,0.31,4.29,4.87,4.36,4.49,5.05,4.14,4.23,1.10,0.75,1.74,-0.05,-1.01,0.48,-1.27,1.03,0.16,1.79,0.02,0 --0.16,0.62,-0.17,-0.02,-0.55,-0.98,1.00,-1.22,-0.41,1.68,0.80,2.94,3.01,5.17,6.96,4.27,4.20,0.90,4.04,0.53,0.77,2 --1.51,0.68,1.73,1.67,4.86,4.74,4.39,4.85,1.73,2.54,2.28,0.11,-0.10,0.20,1.26,-0.91,-0.85,-0.24,0.78,0.32,0.35,1 --1.32,1.21,1.58,3.18,2.11,4.15,3.24,3.86,1.98,2.42,1.94,1.90,0.41,2.79,2.58,0.09,-0.29,1.32,1.15,0.05,-0.74,0 -1.05,2.29,0.83,0.30,-1.51,1.62,1.66,3.56,3.20,6.18,5.49,3.33,3.52,3.54,-0.50,1.74,0.39,0.16,-0.62,0.46,0.15,1 --1.16,1.08,0.81,1.60,0.93,2.51,0.80,0.10,1.15,0.33,0.44,1.91,3.66,3.33,3.26,3.35,3.79,1.59,2.00,1.45,-1.18,0 -0.00,-0.65,0.75,0.90,0.99,1.50,2.64,2.39,3.23,4.52,5.84,3.76,4.70,1.21,1.27,0.48,0.60,0.55,-1.49,0.29,1.33,1 --0.85,-0.55,0.39,0.31,1.19,-0.75,2.25,2.10,2.22,3.62,6.30,4.14,5.07,2.63,3.42,-0.03,-0.11,0.09,-0.20,0.73,1.13,2 --0.37,0.41,1.59,1.89,1.75,2.33,4.09,3.21,1.54,3.72,1.23,1.00,0.51,4.62,5.17,3.83,2.32,1.76,0.52,0.02,-1.03,0 --0.41,-0.08,1.53,2.50,1.04,2.46,2.18,2.35,2.37,2.75,4.36,3.69,1.79,2.77,1.00,-0.52,-0.97,-1.36,0.77,-0.66,-0.58,1 -0.92,0.83,1.07,2.04,4.27,4.76,3.37,5.60,3.28,2.51,3.00,0.65,-0.30,0.62,2.35,-0.33,0.52,-0.06,1.78,-0.53,-0.44,0 --0.17,-0.98,2.27,2.97,2.00,4.39,5.72,3.27,4.02,3.58,2.76,3.25,2.18,1.55,-0.67,0.25,0.50,-1.02,0.02,-0.09,0.25,0 -0.03,0.96,2.71,1.57,0.62,3.80,5.65,4.40,2.24,2.81,2.66,1.88,0.14,3.14,2.22,3.84,2.51,3.12,1.29,-1.10,0.59,0 --2.65,-0.09,-0.38,1.11,0.12,1.11,1.57,2.59,-1.27,-0.96,3.52,3.29,3.69,5.96,4.08,6.31,3.31,1.91,1.11,3.01,1.92,0 --0.19,0.61,-0.25,-1.28,-0.02,0.68,-0.13,2.07,4.59,4.22,6.09,6.02,3.71,2.71,1.90,0.67,-1.35,2.54,0.80,-0.89,0.66,1 -0.63,-1.62,1.06,0.26,1.14,0.07,3.43,3.67,5.02,5.51,5.41,4.09,2.83,1.65,2.06,0.46,-0.03,0.43,2.11,0.72,1.34,1 --0.06,0.18,0.13,-0.74,-0.44,1.21,0.53,1.72,0.80,2.49,3.53,3.39,4.12,2.89,4.47,3.79,2.13,2.52,-0.07,-0.15,1.64,2 -0.90,1.36,0.30,0.68,0.16,2.40,2.44,3.64,1.57,4.33,5.28,4.39,4.62,1.55,3.86,0.66,0.62,1.51,0.40,1.26,-1.46,2 -0.67,-0.21,0.32,-0.53,1.10,1.42,3.69,3.92,2.14,6.01,5.24,4.51,3.60,1.22,2.17,2.48,-0.43,0.83,1.80,1.05,0.62,1 --1.41,-2.23,-0.62,-0.10,-0.15,1.07,1.32,0.05,0.30,2.58,2.13,2.76,2.55,5.77,3.85,3.73,2.23,2.27,3.12,0.22,0.70,2 -0.43,0.21,-0.60,0.37,2.00,1.45,1.46,1.93,3.67,5.26,6.85,3.32,3.72,2.41,3.07,0.11,0.11,-0.26,1.04,0.82,2.05,1 -0.88,0.51,1.11,2.64,2.65,3.30,6.28,6.09,4.45,2.47,2.89,2.28,1.95,2.74,-0.06,-0.01,1.24,-0.30,-0.34,0.90,0.81,1 -0.59,1.22,-0.45,1.18,1.69,0.80,1.78,1.55,2.25,2.30,2.77,5.03,5.91,5.04,3.71,0.96,1.17,0.95,-0.46,-0.86,-0.20,2 -1.14,0.52,0.78,0.62,1.30,2.52,4.52,4.50,3.82,3.08,2.37,3.11,0.37,2.66,0.91,0.66,1.38,1.47,1.31,1.62,-1.19,1 --0.39,1.22,1.01,2.74,3.81,2.52,5.65,3.76,3.78,3.88,1.65,-0.34,0.51,0.88,0.76,-0.45,-1.05,-1.21,1.32,-0.89,0.66,0 --0.03,0.09,0.10,3.18,2.89,2.93,5.16,1.93,5.16,3.32,2.59,4.29,0.19,2.37,-0.16,-2.15,-1.48,-1.61,0.11,0.60,1.37,1 -0.51,-1.40,-0.80,-1.65,-1.12,-1.22,1.50,2.05,3.56,4.51,6.06,5.10,2.83,5.13,2.74,-0.32,-0.59,1.33,-2.23,-1.21,-0.32,2 --0.82,0.89,0.35,0.51,3.15,2.03,3.98,3.01,0.75,2.43,2.20,2.24,0.67,1.37,3.66,2.93,4.20,1.18,1.15,0.85,0.35,0 -0.81,-0.46,1.44,0.79,3.32,3.17,3.49,3.72,1.57,1.28,3.85,2.86,3.02,2.07,2.77,2.42,0.29,1.62,0.42,-0.37,-0.97,0 -0.05,1.69,1.67,2.11,5.00,3.39,7.36,5.93,3.81,2.97,2.31,1.60,-0.28,-1.10,1.09,-0.35,0.11,-1.72,-0.40,2.33,0.19,0 -1.24,0.23,-0.11,3.43,3.44,5.38,4.21,1.98,1.75,3.78,2.84,2.17,0.52,0.89,1.63,0.61,-0.55,0.44,0.36,-1.59,-1.47,0 -0.69,0.21,0.38,-0.56,1.57,1.20,1.89,1.16,1.13,0.55,2.34,3.81,2.32,5.22,3.81,4.15,4.08,1.64,4.70,1.44,0.38,0 -0.85,0.63,1.69,0.88,1.26,2.29,2.11,1.51,1.32,1.79,2.33,1.90,2.03,3.08,4.92,1.84,1.97,3.07,0.87,0.11,0.24,0 --0.01,1.39,0.29,1.36,2.07,4.22,5.23,2.13,2.79,1.38,2.25,0.61,2.03,1.33,0.20,1.00,1.43,1.69,0.45,0.97,0.07,0 --2.50,1.96,1.07,0.38,1.68,-1.11,1.42,1.01,-0.53,2.06,1.84,1.89,2.73,5.80,5.36,5.12,3.95,2.78,1.73,1.06,-0.97,0 --0.05,0.77,0.90,2.22,5.21,5.58,4.91,5.71,5.56,2.81,1.92,1.95,-0.70,0.83,-0.12,0.03,-1.86,-0.04,1.04,0.52,-0.78,1 --1.73,-0.01,0.77,2.31,0.02,1.50,0.07,2.43,2.50,5.37,5.98,5.16,3.37,3.00,1.11,2.73,-0.23,0.40,-0.17,0.63,-0.33,1 -0.43,0.87,-0.69,-0.31,-0.71,1.27,0.54,2.63,2.76,2.95,6.22,6.75,2.93,2.52,2.93,0.94,1.15,0.70,1.53,2.19,-0.20,2 --1.77,1.58,1.02,0.26,3.20,3.06,4.21,2.87,1.83,3.64,4.17,4.55,1.88,1.54,1.30,2.17,1.36,-1.65,1.74,-0.36,-1.73,1 -1.37,-1.04,1.76,0.92,2.78,3.22,5.24,3.74,2.96,3.44,2.45,2.11,2.40,0.76,0.64,1.01,-0.28,0.26,-1.19,-0.73,-0.09,1 -1.23,0.11,-0.44,-1.74,-1.01,1.05,1.11,0.97,2.79,5.13,5.63,2.90,3.32,3.44,1.93,0.62,2.70,2.03,0.52,1.61,0.82,2 --0.95,-0.14,0.81,-0.31,1.62,3.05,2.61,1.14,0.11,1.98,0.31,3.26,2.26,3.16,3.87,5.40,2.75,1.40,0.69,0.73,1.82,0 -1.68,1.28,1.78,1.76,2.16,1.36,2.13,4.44,2.57,3.01,5.10,3.11,2.23,2.44,-0.38,0.65,-0.20,-1.31,1.44,1.43,0.82,1 --0.84,-0.35,0.72,1.51,-0.49,0.86,0.58,1.46,2.62,1.57,5.40,4.11,4.81,3.49,4.45,3.16,1.49,1.62,0.19,0.50,1.14,2 --0.55,1.25,0.19,0.86,-0.23,-0.36,0.76,0.56,0.08,2.98,1.05,3.44,3.88,1.79,4.18,6.23,3.07,2.33,2.40,-0.15,-0.27,0 -0.54,0.33,1.55,-0.18,1.95,2.22,1.90,1.49,1.21,1.51,1.45,1.92,1.72,4.90,3.07,2.83,1.02,0.76,0.83,2.38,0.20,0 --0.66,-1.47,-0.40,-0.20,-0.06,0.91,-0.45,3.76,3.60,5.00,5.92,4.09,3.93,3.57,2.12,-0.18,1.97,0.05,-1.87,2.04,-0.74,2 -0.32,-0.30,-1.28,-0.06,1.71,1.93,2.34,0.24,2.57,0.55,4.04,3.13,3.11,2.96,6.34,2.91,3.03,2.04,1.84,0.06,0.97,2 --0.39,-0.39,0.66,1.78,1.78,3.35,5.55,4.20,2.83,3.84,2.56,0.55,1.63,2.15,1.19,1.74,-0.77,-1.26,-0.11,1.56,0.87,0 --1.32,-0.67,0.48,1.25,-1.18,-0.15,0.98,1.41,1.64,2.80,3.09,3.48,2.37,4.39,5.13,3.87,2.91,1.67,1.88,1.46,-0.37,2 --1.44,-0.02,-0.08,1.37,0.63,0.59,1.44,2.31,3.61,3.92,4.87,5.27,5.66,4.49,4.75,4.10,1.01,-0.65,-0.51,0.11,1.93,2 -1.03,0.33,-0.75,-1.74,-1.39,0.41,0.99,0.89,1.78,3.60,6.95,1.90,6.24,3.41,3.33,2.91,1.44,0.51,1.93,1.75,-1.43,2 --1.63,2.46,2.61,0.75,2.55,4.65,3.01,1.50,2.70,3.20,0.50,1.14,1.46,0.93,2.79,2.44,1.49,-1.03,1.39,0.89,-1.15,0 -0.71,0.79,0.01,0.61,2.17,0.43,-0.44,-0.39,1.06,1.42,2.67,1.73,4.73,3.75,3.98,3.57,2.61,1.92,1.33,1.01,1.30,0 -1.19,-0.70,2.09,0.22,0.44,0.77,0.49,-0.41,-1.10,1.20,3.58,5.03,4.80,3.64,4.76,4.31,2.74,1.25,1.01,0.37,-0.61,2 -0.25,1.30,0.19,2.84,0.70,2.86,4.06,4.84,5.01,4.00,3.43,2.56,0.56,0.63,1.79,-1.14,0.38,1.03,0.38,-0.13,-0.61,1 -1.87,-0.12,1.35,2.36,4.04,3.01,5.07,5.25,4.47,2.10,2.30,1.81,0.80,2.50,0.21,-0.81,0.01,-0.38,-0.08,-0.91,-1.53,1 -0.08,-0.67,0.18,0.39,-0.74,-0.49,4.22,3.75,2.60,3.59,5.84,2.52,3.82,1.08,4.07,1.26,1.51,0.58,-0.12,0.52,-1.99,2 --0.33,1.29,1.51,1.41,2.09,3.82,3.07,5.84,4.44,3.47,2.89,1.19,1.57,0.19,1.31,1.21,0.26,-0.43,-0.57,-0.26,0.23,1 -1.77,0.68,-1.70,0.75,0.40,-0.43,-0.87,-0.16,0.35,1.76,3.41,2.98,3.31,3.32,4.01,4.64,2.24,2.00,2.34,-0.18,-0.01,2 --0.66,-0.82,1.32,1.19,-0.27,0.69,1.45,0.24,1.93,1.72,3.29,2.10,4.76,5.08,4.22,4.83,3.84,1.19,1.78,0.03,0.71,2 -0.71,1.24,1.39,3.11,3.34,5.95,5.37,4.79,4.62,2.25,2.40,0.99,2.36,-0.52,-0.10,0.21,0.11,0.36,1.15,0.63,0.35,0 -0.41,1.13,0.70,1.06,0.90,2.46,3.47,5.41,1.96,4.72,4.05,3.64,1.75,0.97,1.65,0.16,0.90,1.47,-1.97,-1.41,0.30,1 --1.35,0.45,0.76,0.71,2.82,3.05,1.54,6.58,4.49,2.78,5.35,3.13,0.74,1.86,0.77,-0.27,0.66,0.76,-0.27,0.63,0.79,1 -0.89,1.90,1.44,0.10,-0.33,1.46,2.18,2.53,3.15,3.69,5.41,3.59,2.77,2.18,2.44,2.63,0.43,0.47,0.96,1.12,0.29,2 --0.69,0.42,-1.21,-0.31,0.29,0.17,1.00,4.13,2.17,5.30,6.61,5.60,4.03,2.86,3.44,2.52,1.61,0.70,-1.24,0.46,2.53,2 --0.33,0.00,1.88,4.81,5.18,4.09,6.16,5.56,2.45,2.70,3.29,0.43,0.92,-1.42,1.61,1.43,0.53,0.05,-1.32,1.66,0.57,1 --0.16,0.13,0.87,1.63,0.61,4.82,3.37,3.14,3.85,4.52,5.18,3.73,3.21,2.66,0.74,2.39,0.29,-0.59,-0.29,-0.06,-0.09,1 -1.54,0.37,-1.01,-1.35,0.59,2.06,1.97,4.55,4.05,1.72,5.07,2.70,5.23,3.37,0.86,2.45,1.09,-1.87,-1.18,1.68,1.35,1 -1.33,0.33,0.16,0.58,0.56,0.52,1.82,3.47,1.76,0.08,1.58,3.90,3.62,4.20,5.29,3.36,4.32,2.58,0.60,1.84,0.27,0 -0.57,-0.39,2.22,4.44,4.90,4.80,4.00,3.77,5.48,3.22,3.45,1.44,0.40,1.97,0.07,0.33,0.39,0.94,0.84,0.59,-0.03,1 --0.38,-0.11,2.05,0.89,1.99,4.53,4.95,3.47,5.88,4.45,3.50,0.06,0.81,0.49,0.30,0.81,-1.08,0.26,0.15,0.42,0.10,1 --0.44,0.60,1.10,-0.90,0.44,2.23,2.42,3.45,3.96,6.39,5.77,5.99,2.94,2.83,1.78,-0.53,0.59,-0.14,-0.66,-0.79,0.49,1 -0.45,0.21,-0.02,0.46,0.06,3.49,2.30,2.38,2.17,0.99,1.16,1.10,1.05,3.15,4.32,3.47,3.08,0.88,0.78,0.79,1.06,0 --1.29,1.36,1.20,3.15,5.33,3.57,2.67,3.65,4.51,3.80,1.98,2.10,0.93,2.36,-0.99,0.38,-0.66,0.92,0.74,-1.50,-0.04,0 --0.99,1.26,2.09,1.61,4.57,4.41,4.92,4.49,2.66,2.67,0.98,2.25,-0.72,1.83,-0.07,-1.22,-1.10,-1.21,-0.16,0.87,0.84,1 -0.75,1.97,-1.47,0.53,-0.76,-0.42,0.76,-0.74,0.22,1.99,1.85,3.71,2.28,5.09,5.87,4.71,3.48,4.12,1.98,0.67,0.21,2 -0.19,-0.86,-1.16,1.51,1.55,2.81,2.82,2.03,2.38,0.28,1.44,1.50,2.60,2.57,4.35,2.96,4.38,0.85,2.43,0.95,0.79,0 --0.07,0.48,-0.93,0.37,-0.59,2.24,1.04,0.14,1.37,3.37,3.46,4.85,6.85,2.96,4.71,2.51,3.08,-0.67,0.95,-1.28,0.49,2 --0.03,0.73,1.02,-0.32,2.35,-0.50,0.40,0.57,-0.28,0.85,0.86,3.74,4.07,5.15,6.25,3.16,3.42,2.52,2.98,0.81,1.21,0 --0.42,-0.15,2.51,2.73,2.92,4.62,4.15,5.17,2.11,2.08,1.37,1.93,0.72,-2.05,-0.25,-0.90,2.14,0.39,1.18,1.95,-1.32,0 --0.03,-1.78,0.68,1.70,-0.15,1.85,1.94,3.84,3.86,5.60,3.34,2.97,4.11,1.56,0.35,2.38,-0.81,-0.29,0.09,0.96,-2.48,1 -1.16,0.41,2.32,0.60,2.78,7.04,4.81,3.90,4.42,3.03,2.18,1.88,2.07,3.23,0.40,-0.02,0.59,0.18,-0.24,0.59,1.08,1 --1.57,1.07,-0.03,2.84,-1.33,1.43,-1.17,-0.62,-1.64,-0.10,0.15,1.34,5.17,3.73,6.32,3.40,3.89,2.60,0.64,1.72,-1.69,0 --0.03,0.51,-1.20,1.81,3.01,4.31,5.33,4.16,4.34,3.48,3.48,1.47,1.25,0.37,0.48,0.01,-0.44,-1.66,-1.00,1.10,-1.90,1 -0.08,1.07,-2.12,0.09,1.74,-1.71,-0.33,0.69,0.88,1.38,4.45,4.97,4.52,3.19,4.79,3.95,2.30,4.13,0.57,-0.50,-0.78,2 --0.26,1.24,1.45,2.20,4.33,3.51,2.70,5.66,2.65,2.89,3.30,0.41,2.04,0.53,1.47,-1.59,1.05,0.26,-0.28,0.47,-0.48,1 -0.39,1.06,0.99,2.95,3.57,3.63,5.76,3.99,3.23,4.26,1.96,1.68,0.75,-0.51,2.78,1.00,1.92,1.60,-0.25,0.42,0.72,0 -1.11,-0.38,0.29,0.06,-1.07,-0.02,0.22,0.69,0.59,1.30,2.07,3.04,2.80,4.10,5.40,3.28,2.99,2.39,1.88,1.28,0.07,2 -0.08,-0.84,-0.34,0.89,1.15,1.32,1.74,1.12,0.24,0.14,3.19,2.66,3.57,5.35,4.69,2.33,2.19,1.44,2.04,1.03,-0.58,0 --1.75,1.71,3.11,2.64,3.05,4.61,3.95,5.09,5.67,2.31,2.21,1.63,0.54,0.11,0.50,2.07,-0.37,0.25,-0.34,-0.73,-0.59,1 --0.05,0.47,1.30,1.52,1.54,1.98,3.91,2.59,3.09,4.67,4.95,4.81,1.91,3.16,1.19,0.09,1.46,-0.07,0.92,-0.92,-1.73,1 --0.97,-0.36,0.37,-0.63,-0.68,0.34,2.12,0.95,3.71,1.91,3.77,2.18,3.83,3.16,6.90,2.75,2.72,1.84,1.74,-0.58,-0.02,2 -0.21,-0.64,-0.96,0.43,2.57,0.53,1.68,3.31,0.94,1.86,1.93,-0.65,3.58,3.38,-0.18,2.37,3.24,2.32,2.33,2.32,-0.42,0 -0.39,0.66,0.53,-0.61,1.15,2.49,0.23,2.77,3.70,4.40,6.37,4.42,3.94,2.43,3.58,1.46,-2.21,0.30,1.19,-1.45,-0.43,2 -0.37,-0.72,2.98,0.01,2.73,4.92,4.77,1.90,4.79,2.37,1.17,2.31,-0.17,0.34,0.80,0.32,1.52,-1.41,-0.48,-0.97,-0.07,1 -1.27,0.88,-0.24,0.21,1.27,0.12,1.74,0.23,-0.42,0.89,3.04,3.64,3.84,4.60,4.29,3.30,2.71,0.83,0.25,-0.96,0.64,0 --1.14,-0.21,0.86,0.18,-0.46,1.62,1.26,0.84,2.00,2.61,4.28,2.87,5.77,3.01,4.49,1.61,1.80,1.10,1.39,1.14,1.56,2 -0.01,0.30,1.28,1.95,2.13,3.08,1.61,0.42,-0.39,2.19,3.83,3.72,4.92,3.02,4.26,3.12,4.15,0.89,-0.13,1.73,-1.03,0 -2.02,-0.02,1.45,2.61,2.53,3.52,5.13,4.58,2.56,3.38,1.83,0.75,-1.22,2.12,0.85,0.73,1.32,0.65,0.51,-0.27,1.28,0 --0.24,0.61,1.00,-0.25,0.92,1.01,1.76,2.02,4.12,6.26,5.31,4.22,4.98,0.92,1.02,1.14,0.04,-1.20,1.18,0.44,0.81,2 -0.13,0.11,-1.91,-0.76,-0.36,-1.38,0.37,-0.55,1.15,2.14,3.19,3.97,4.51,4.43,7.86,4.23,4.50,3.72,2.25,0.79,0.37,2 -0.20,-0.39,-0.31,1.28,1.30,2.33,2.35,2.90,2.29,3.72,4.53,4.31,2.92,1.71,0.57,1.48,0.83,-0.39,0.67,1.07,-2.28,1 -1.18,0.05,2.68,3.36,4.58,5.16,4.99,4.50,4.84,2.88,2.49,2.59,-0.10,0.47,-0.04,0.01,0.27,-0.17,2.21,0.56,0.95,0 -1.92,-0.02,0.89,-0.76,-1.57,0.01,1.73,1.66,4.93,5.42,6.24,4.59,4.52,3.95,1.56,-0.48,0.01,0.60,-0.13,0.74,0.15,2 -0.68,1.31,0.33,0.06,0.13,-1.12,1.07,2.86,0.96,1.20,3.32,2.26,4.23,1.53,2.01,3.71,1.34,2.64,1.73,-0.14,-1.66,2 --0.79,1.91,2.26,1.95,2.14,4.06,4.97,1.65,2.72,1.79,2.00,1.08,2.07,1.66,1.64,1.35,0.34,1.44,-1.38,1.46,-0.66,0 --0.06,1.18,1.18,-0.87,0.22,-0.47,0.12,1.97,0.80,0.34,2.29,2.64,5.53,3.41,4.51,5.70,2.25,2.78,2.30,0.91,-0.42,0 --0.34,1.40,-0.00,2.50,3.67,4.46,2.33,3.33,0.64,1.50,2.17,1.15,1.71,2.27,0.18,2.18,1.52,3.16,0.51,-1.41,0.93,0 -0.39,-0.07,-0.54,-0.18,-0.74,-0.65,-0.10,-0.07,0.03,0.61,1.65,3.34,3.16,5.74,4.93,3.26,2.53,3.66,2.01,0.29,0.70,2 --1.16,-0.83,0.39,-0.23,2.32,2.04,0.41,2.19,-0.29,0.69,2.87,3.33,2.74,4.88,6.66,6.58,3.53,-0.96,1.35,1.32,-0.65,0 -0.60,-0.58,0.68,0.31,0.25,0.18,-0.35,1.54,2.03,1.47,1.34,1.20,4.93,2.94,5.39,4.81,2.74,0.54,1.26,2.26,0.50,0 -0.43,0.77,1.43,-1.43,1.91,1.68,4.10,3.27,5.07,4.39,4.84,4.02,3.07,1.16,0.89,1.47,0.79,-1.09,-0.33,0.36,1.00,1 --1.21,0.83,0.08,3.17,4.82,3.41,6.92,4.70,4.71,2.37,0.39,1.29,1.12,2.42,-0.59,0.58,-0.35,-0.28,-0.29,0.06,-0.80,0 --0.06,1.00,-0.43,0.13,0.71,2.84,1.67,3.59,0.83,1.02,0.62,2.65,2.27,3.85,3.40,2.72,1.39,1.63,1.62,-0.70,2.43,0 -0.75,1.06,2.59,3.88,3.72,4.04,5.86,3.08,3.29,3.77,-0.12,2.08,2.11,-0.33,0.03,0.63,-2.31,1.30,1.88,-1.83,-0.27,0 -0.50,2.31,2.30,2.35,0.38,2.15,5.49,3.63,5.35,4.18,4.01,3.44,0.25,0.58,3.10,1.12,-0.35,0.10,1.30,-0.96,1.31,1 --0.69,0.31,1.93,1.70,1.96,4.04,6.41,5.59,4.59,3.52,4.15,1.63,-0.18,2.29,-0.17,-0.20,0.65,0.84,-1.24,0.74,1.12,1 --1.56,1.01,0.50,0.87,0.08,0.01,-0.43,0.90,1.81,1.56,2.87,3.44,3.67,5.31,3.24,6.13,3.31,1.64,2.18,0.04,0.90,2 --0.81,0.18,1.32,0.75,0.24,1.11,0.69,0.05,1.39,2.82,2.94,2.75,4.63,3.26,5.49,1.55,4.30,1.94,1.38,-0.45,1.12,0 -1.57,-0.17,1.45,1.62,3.76,2.59,3.74,2.48,3.98,2.40,3.86,2.13,1.65,3.20,2.95,1.49,1.51,1.78,0.27,0.70,-0.73,0 -0.16,1.82,2.27,2.04,1.01,1.39,1.82,0.90,1.80,1.20,2.48,3.49,2.83,3.47,3.12,2.90,4.14,3.45,1.45,1.00,0.55,0 --1.06,1.06,-0.68,0.28,2.00,0.30,2.93,3.54,3.30,6.25,7.32,6.44,4.12,2.16,2.83,1.91,-0.34,0.92,0.73,0.01,0.08,2 --0.08,0.49,-0.25,1.20,1.17,1.51,4.96,4.87,3.98,5.79,4.36,2.20,1.61,1.86,1.57,1.13,-1.56,-0.62,-0.45,0.15,0.06,1 --0.55,1.21,3.48,3.17,3.26,5.01,5.99,4.48,4.94,2.99,2.05,0.30,1.33,0.06,-0.55,0.30,-0.39,-0.51,0.50,-1.05,2.94,0 -1.63,2.44,2.09,3.07,5.21,4.59,6.99,5.75,4.73,2.03,2.47,3.18,-0.61,0.52,1.34,-0.03,1.58,0.94,-1.14,1.48,0.07,1 --1.02,-0.12,-0.81,0.08,1.14,0.15,-0.34,0.95,1.07,4.11,4.71,2.86,3.77,3.88,4.17,3.21,0.83,1.70,0.48,0.81,-0.40,2 --1.18,0.68,1.93,1.63,-2.20,1.25,-1.85,0.90,0.72,0.76,3.16,2.10,3.49,5.85,5.47,5.80,3.05,3.01,1.01,0.10,-0.29,0 --0.28,1.74,1.95,1.79,3.90,5.12,5.66,5.58,3.93,5.02,1.32,1.70,0.92,-0.22,-0.11,0.97,0.92,0.09,0.52,2.37,1.08,1 -1.41,0.90,2.72,3.60,3.00,5.24,5.48,6.00,3.19,3.72,1.97,1.17,0.30,-0.55,-0.19,-2.48,1.66,0.30,-0.05,-0.03,1.97,0 -0.54,-1.38,0.91,-1.59,-0.89,0.62,1.14,1.54,2.21,1.55,3.58,4.86,4.58,2.40,4.50,3.02,2.40,1.72,0.92,0.84,0.88,2 --0.78,1.42,0.71,-1.18,-1.99,-0.18,2.55,3.23,2.62,4.44,5.47,1.86,3.20,3.84,1.48,1.89,-0.71,1.29,-0.29,0.76,-1.60,1 --2.05,0.16,0.22,-1.62,0.87,1.98,3.94,3.54,3.85,5.59,7.82,4.12,3.60,3.71,4.57,1.07,1.23,0.32,0.26,-1.07,0.97,2 --1.09,-0.66,0.33,-0.41,0.98,0.55,0.42,0.79,2.34,4.12,2.21,2.81,1.68,4.96,4.10,3.07,2.82,3.00,3.65,0.58,0.99,2 --0.99,-1.69,-0.87,0.23,0.81,1.24,2.31,2.07,4.00,3.24,4.57,4.66,3.22,4.42,2.50,1.27,1.71,-0.96,-0.24,1.07,-0.38,2 --0.09,-0.31,1.00,1.43,-1.06,-0.94,-0.10,1.32,1.15,2.58,4.57,1.92,3.69,4.82,4.71,2.43,2.34,2.80,-0.32,0.77,-1.03,2 --0.45,-0.02,-1.28,-0.09,0.20,1.35,1.07,3.83,2.49,4.47,5.34,4.55,3.89,3.85,3.63,1.01,1.67,1.52,0.96,0.62,1.07,2 -0.39,0.68,2.43,1.99,4.08,4.52,5.42,4.70,5.36,4.28,3.18,1.54,1.64,0.85,0.40,0.91,1.23,1.40,-0.10,0.47,-0.03,1 --0.76,1.94,1.40,2.79,3.34,4.32,4.13,2.62,4.36,3.35,0.77,0.10,-1.62,0.69,-0.44,1.10,-1.47,2.70,-0.63,2.13,-0.16,0 --0.25,-0.71,1.21,1.02,0.82,0.08,1.76,1.64,2.11,3.20,2.44,4.17,5.48,3.74,2.79,1.45,1.70,1.99,2.15,0.06,-1.79,2 --0.80,0.30,0.94,3.16,-0.17,2.55,1.92,2.88,1.95,3.23,3.34,2.21,0.81,1.97,2.35,1.66,4.34,0.46,-0.17,-0.01,1.16,0 -0.91,0.48,-0.22,-1.54,-0.50,1.85,0.71,-1.17,0.87,3.03,4.11,2.35,3.69,3.29,4.11,1.96,0.89,0.02,0.11,-0.81,-2.05,2 -0.59,-0.76,-0.30,0.44,0.25,-0.13,1.49,0.16,0.15,1.69,4.02,3.92,3.60,2.90,5.98,5.19,2.56,1.54,0.99,2.11,-1.75,2 --0.47,0.58,1.11,-0.76,-0.33,0.62,2.23,4.61,4.09,5.61,6.73,4.43,3.81,2.86,2.83,1.64,1.14,1.73,-0.32,-0.05,1.86,1 -0.75,0.72,1.27,2.44,3.29,3.71,2.20,5.02,3.82,3.55,1.61,2.39,1.63,1.67,3.12,2.16,2.39,0.34,2.09,1.42,0.84,0 --0.20,-0.35,0.75,-0.34,2.10,3.88,1.81,3.08,0.69,1.08,2.33,1.08,0.91,3.77,3.31,4.76,2.25,1.38,1.79,0.83,-2.97,0 --0.98,-1.62,2.31,-0.34,0.04,0.58,2.50,1.93,3.84,4.54,6.76,5.59,4.72,4.12,2.21,1.46,1.46,2.28,-0.56,-2.15,-0.15,2 --1.04,1.13,1.88,-1.57,-2.54,0.38,-0.26,0.25,-0.11,2.49,2.00,3.64,4.66,6.24,4.74,6.80,3.93,2.26,1.55,1.35,-0.13,2 --1.26,2.31,1.27,2.64,2.08,3.88,3.87,4.34,4.67,1.62,1.21,3.70,1.24,0.23,1.32,0.85,-0.27,1.09,-1.12,0.07,-0.89,1 -1.11,0.56,-0.46,-0.77,0.72,1.08,0.62,3.04,2.15,3.92,7.68,4.54,3.75,2.80,2.90,0.62,0.04,0.11,-1.06,0.61,-0.43,2 --1.17,-0.45,-0.07,2.47,0.25,3.84,6.20,1.88,3.66,3.06,3.96,2.34,1.70,1.40,-0.01,-0.18,1.03,-1.05,-0.05,0.80,2.25,1 --1.99,-0.37,0.85,1.60,-0.62,1.12,0.24,0.88,1.95,1.50,3.89,3.58,3.75,3.99,3.88,2.51,3.05,1.87,2.33,0.87,1.65,2 --0.47,0.66,-0.98,0.56,-1.59,0.14,-0.06,3.29,2.36,4.16,3.28,3.82,3.75,4.01,4.09,3.05,0.77,-0.06,2.14,-0.35,2.04,2 --1.79,-1.30,1.14,-1.02,0.06,1.18,0.24,1.69,-0.47,-1.10,2.04,3.07,2.90,4.21,3.40,4.37,3.79,3.30,1.84,1.69,-0.95,2 --1.32,-0.62,1.10,2.90,2.58,1.51,5.87,2.59,2.38,1.62,2.31,2.31,2.11,1.42,1.08,1.37,1.47,1.79,1.20,0.21,1.31,0 -0.62,0.86,0.46,1.24,1.15,2.44,4.09,1.59,2.35,2.10,3.45,1.42,1.28,2.59,4.07,3.60,3.26,2.63,2.48,-0.17,0.80,0 --1.13,0.43,1.69,2.79,4.63,5.17,4.48,4.18,4.06,2.68,1.96,-0.81,-0.61,1.06,0.82,0.43,-0.38,-0.38,1.41,0.36,-1.04,0 -0.41,1.03,1.86,2.21,1.79,4.26,5.22,5.72,4.46,3.01,4.75,2.71,3.39,1.93,-0.40,-1.06,0.44,1.01,0.72,0.09,-0.28,1 -1.35,-1.22,-0.17,1.46,-0.81,1.06,1.51,2.84,3.31,5.30,3.89,3.45,4.95,5.73,3.60,4.47,1.60,3.13,0.14,0.09,0.62,2 -0.81,1.21,2.72,3.13,4.82,4.67,5.70,3.74,4.18,2.43,1.95,0.91,1.06,1.72,2.83,0.31,-0.68,0.28,1.24,0.08,-0.55,0 -1.00,1.75,1.52,0.63,2.01,2.31,1.06,2.11,1.36,0.68,1.57,2.51,2.97,4.39,5.20,1.82,1.72,3.64,2.67,0.33,0.22,0 -0.69,1.02,0.95,-0.56,-0.90,-0.45,1.91,-0.32,2.24,3.21,2.77,5.08,3.27,6.20,4.35,3.62,4.13,3.43,0.52,2.75,0.13,2 --0.65,0.80,0.89,2.17,-0.03,2.21,4.19,3.58,3.18,4.13,4.74,2.17,2.70,1.98,1.73,0.12,-1.26,0.38,-2.03,2.10,-0.01,1 --0.38,1.36,-0.02,1.03,0.14,2.08,3.90,3.35,2.86,3.53,1.87,0.76,1.35,1.65,2.08,3.09,1.03,0.73,1.72,0.03,-1.66,0 --1.40,-0.84,0.09,-0.92,0.09,0.91,1.33,3.54,6.44,4.80,5.14,5.97,2.09,3.58,3.66,0.88,0.89,-0.89,-0.01,1.30,-1.39,1 --1.56,-1.00,-0.29,-0.20,-1.93,4.43,2.61,2.92,1.92,2.18,5.46,3.51,4.30,3.51,2.64,1.83,0.81,-0.31,0.16,0.06,1.00,2 --0.13,1.85,-0.50,1.19,-1.48,-0.03,1.79,1.89,2.18,2.27,2.63,5.63,5.05,2.86,2.73,0.53,0.16,1.03,1.50,-0.01,-0.79,2 -0.42,1.62,2.81,1.45,4.59,4.98,4.90,6.15,5.30,1.99,1.54,-0.32,1.69,0.73,-0.41,0.99,-0.80,0.78,0.45,0.30,-0.20,1 --1.16,2.83,0.10,0.69,0.53,2.35,3.53,3.05,5.88,3.87,4.85,3.11,2.56,4.01,1.79,0.83,-0.23,0.54,0.39,0.11,0.66,1 -1.68,-0.01,2.11,1.39,2.23,1.80,3.46,5.33,2.36,4.47,2.22,1.89,1.48,-0.84,2.37,0.77,0.27,-0.72,-0.54,-1.34,1.78,1 --2.04,0.31,0.75,-0.70,-0.32,2.04,2.04,2.86,3.91,3.07,4.23,4.93,2.25,2.55,3.82,3.09,3.21,-0.17,-0.06,-0.33,0.94,2 --0.55,-0.02,3.63,1.00,4.34,4.97,4.50,4.81,4.66,3.19,2.19,-0.10,-0.55,0.31,0.21,-1.24,-0.77,0.43,-0.74,-0.40,-1.74,0 --1.00,0.63,1.59,1.23,2.81,4.22,4.99,3.59,3.15,3.20,2.56,1.74,-0.24,0.14,1.29,0.54,-0.38,0.67,0.95,0.52,0.55,0 -0.83,1.78,2.61,3.86,3.74,4.83,5.10,5.70,2.33,2.42,3.69,2.13,0.79,0.09,-0.01,2.08,0.06,-0.57,-0.06,0.69,-0.18,1 --0.65,0.73,1.45,-0.65,0.75,2.34,1.95,3.08,1.97,1.88,1.74,2.50,2.53,0.84,0.69,2.11,4.03,0.32,2.33,1.25,-1.22,0 -1.05,0.42,0.70,1.11,0.01,1.18,1.65,0.40,-0.22,0.96,2.40,2.28,5.18,4.55,5.71,5.27,2.68,3.22,0.58,0.96,0.07,0 --0.46,-0.36,-0.94,0.41,-0.38,0.74,1.42,1.03,3.29,1.40,3.02,3.12,5.27,3.11,4.90,2.05,1.58,1.72,0.31,-1.03,-0.15,2 --0.81,0.83,-0.18,3.75,3.81,2.65,3.70,2.68,3.02,3.08,1.70,2.77,1.74,0.10,2.18,1.86,0.60,1.54,-0.41,-1.82,-0.69,0 --0.84,-0.10,1.04,-1.23,3.30,0.30,3.62,4.24,5.18,3.12,3.00,4.37,3.37,0.47,1.38,-0.02,1.76,-0.11,-0.82,-0.32,0.65,1 --0.17,-0.10,2.13,1.24,1.35,5.03,4.45,4.84,3.79,3.32,2.46,-0.26,0.68,-0.45,0.53,0.55,0.06,0.80,-0.88,0.54,-1.16,0 -1.18,-0.50,2.60,2.88,2.76,4.13,6.21,3.18,2.89,3.16,3.72,2.06,-0.92,0.99,0.53,1.24,-2.65,0.63,-0.00,1.80,0.07,1 --0.81,0.29,0.70,3.58,3.70,4.48,4.90,3.51,5.01,1.57,3.62,2.47,1.06,0.31,-0.82,2.06,-0.16,-1.24,0.51,0.41,-0.17,1 --0.50,-0.17,-1.99,-0.46,-0.91,-0.15,0.72,0.57,1.47,2.23,3.08,1.38,2.64,3.53,6.22,3.27,4.50,1.39,1.89,0.06,-2.00,2 --0.11,-0.06,0.50,3.43,2.39,6.10,5.62,4.82,5.64,3.66,0.80,1.32,-1.62,0.01,0.84,-0.60,0.62,-2.00,1.34,0.60,-0.07,1 --0.42,0.26,0.73,3.48,-1.59,0.17,2.27,1.87,2.74,3.14,4.36,4.43,4.86,2.43,4.48,0.79,0.31,0.08,-0.38,0.29,-0.54,2 -0.57,0.10,-1.36,-1.20,-0.48,0.89,1.94,2.29,5.24,4.91,6.15,5.54,4.90,2.52,1.83,1.13,-2.37,0.57,-2.85,0.31,-0.32,1 --0.63,0.06,2.32,2.17,2.06,3.07,3.71,2.70,2.47,3.62,4.92,3.43,2.51,2.82,2.20,1.10,1.55,1.67,-0.93,0.50,-0.16,1 --0.95,1.16,1.29,-0.82,-0.25,1.72,2.14,2.38,2.93,3.36,4.57,5.31,3.55,2.28,3.36,3.57,1.46,0.61,2.81,-1.27,-0.58,2 -1.22,-0.63,0.01,0.88,0.46,0.69,1.86,2.59,0.07,1.77,0.97,1.29,3.32,2.88,3.30,4.19,2.97,2.56,0.88,2.41,-1.93,0 --0.36,0.81,-0.01,-1.01,1.84,0.80,0.80,1.85,2.89,4.15,3.59,3.16,2.45,3.16,2.65,1.48,3.48,3.04,1.34,0.29,-0.10,2 --1.06,-1.01,-0.19,0.38,3.61,3.73,4.28,3.29,1.66,1.01,1.49,3.14,1.40,0.23,1.69,3.01,1.00,-0.06,0.42,0.54,0.14,0 -0.11,1.49,1.01,3.39,1.73,4.38,6.65,3.40,2.93,3.82,1.75,2.48,2.35,-0.11,0.18,1.80,0.25,-0.08,-0.36,-1.88,-1.69,0 --1.99,1.14,1.68,1.76,3.36,3.87,4.70,6.51,3.43,3.88,3.35,0.89,1.31,0.06,2.55,1.41,1.51,-1.05,-1.55,-0.03,-0.68,1 --1.30,1.09,0.28,-0.26,0.30,0.68,3.15,2.01,1.43,2.44,3.30,4.34,3.51,3.74,3.95,3.16,2.38,0.23,-1.29,1.83,1.72,2 --0.25,0.77,1.42,2.79,3.89,5.02,5.13,3.05,3.17,3.12,4.17,1.51,1.50,0.56,0.46,1.81,0.43,0.87,-0.54,2.00,-0.06,1 -0.48,-0.72,-1.34,1.10,-0.40,-0.49,2.35,0.88,3.41,3.35,4.33,2.73,2.00,5.61,2.44,2.80,-0.02,2.85,1.09,0.55,0.24,2 -0.26,2.32,-0.76,1.67,1.62,1.91,2.80,3.04,5.88,5.16,4.20,2.93,3.77,2.13,0.12,0.25,-1.56,0.65,0.82,0.18,0.84,1 -0.12,1.17,-0.25,2.67,2.57,2.09,5.28,3.75,4.94,3.94,3.66,2.10,2.51,-0.12,1.43,1.22,1.36,0.22,-1.42,0.43,0.37,1 -1.26,0.86,0.79,-0.99,0.69,-0.62,1.85,0.70,3.19,2.95,5.87,3.40,4.54,2.50,4.39,2.19,-0.41,1.90,-0.81,-0.77,-0.60,2 -0.33,1.76,2.64,1.24,-0.82,0.24,-0.91,-0.47,0.63,1.40,2.62,1.06,4.15,5.21,5.62,3.18,3.55,4.32,1.25,0.07,0.37,2 --0.48,-0.19,-0.45,1.54,5.00,6.51,6.92,4.27,4.71,3.60,4.44,2.96,0.00,0.07,0.89,0.95,0.71,0.02,-1.14,0.88,-1.23,1 -0.24,2.57,1.74,0.62,2.20,2.80,2.61,4.74,4.98,4.34,3.95,4.92,1.83,-0.37,2.02,-0.03,1.06,-0.58,-0.48,-2.85,-1.28,1 --0.08,0.61,-0.57,0.05,0.61,1.25,2.20,2.24,2.02,3.16,5.87,2.99,3.07,4.13,3.54,4.18,1.40,0.63,-0.89,2.72,0.48,2 -0.23,-0.61,-0.94,0.04,0.75,0.74,2.59,4.63,2.39,3.24,3.90,3.31,4.71,4.36,3.48,2.23,3.29,2.54,0.68,-0.17,-1.34,2 -0.76,0.38,1.59,0.53,1.25,-0.31,0.19,2.62,1.54,3.07,4.18,4.04,5.16,2.80,5.79,2.70,3.83,2.38,3.14,0.68,0.05,2 --1.01,1.69,0.37,-1.33,0.34,1.84,3.66,4.50,3.50,3.85,4.33,5.42,3.75,2.91,0.71,0.80,-0.84,-1.16,-1.03,0.78,-0.87,1 --0.94,-0.59,2.09,-0.23,0.76,2.30,1.21,1.74,5.42,3.67,4.55,5.39,5.75,3.99,1.61,3.09,1.53,0.53,0.01,1.45,0.03,2 -0.00,-0.46,-1.14,-0.06,0.97,-0.36,1.30,1.12,0.96,5.66,5.40,5.07,4.74,4.16,2.60,3.22,1.43,0.99,1.67,1.39,-0.59,2 --0.86,0.66,3.17,0.14,0.36,0.33,0.58,1.88,1.89,0.89,1.29,2.18,3.56,2.85,5.01,2.56,3.36,2.94,-0.16,0.29,1.64,0 -0.31,-0.90,0.24,1.86,2.62,5.69,5.05,4.53,3.21,2.52,4.14,0.24,1.36,-0.18,1.10,-0.14,-2.51,0.09,-0.33,2.08,0.42,1 -0.91,-0.46,2.61,3.01,3.42,2.33,3.57,2.66,2.99,0.97,2.11,2.26,2.14,2.26,2.00,1.43,-1.05,1.25,0.89,0.11,1.29,0 -1.90,-1.87,-0.39,-0.20,-0.22,0.27,1.90,2.11,4.09,5.96,7.14,4.03,2.00,3.38,2.32,1.39,-0.22,-1.03,1.39,2.24,1.49,2 -1.26,0.08,-0.92,1.00,-0.26,0.28,0.72,0.61,2.14,4.11,3.49,4.49,5.81,6.19,4.98,2.75,2.61,1.21,0.20,0.90,0.85,2 -1.42,0.46,0.14,-0.97,-1.17,0.60,-0.31,2.87,0.14,2.95,3.86,3.57,3.13,3.34,3.04,3.90,2.50,1.72,-0.14,-0.03,-0.42,2 -0.89,0.32,1.33,2.06,2.59,2.54,2.53,4.19,2.23,2.38,0.52,0.85,0.63,1.25,3.18,2.52,1.80,-0.65,-0.24,-0.40,-1.40,0 --0.12,-0.08,0.48,1.92,1.58,-0.46,0.60,1.45,1.25,2.43,4.26,3.09,3.53,2.90,4.52,2.76,4.01,1.37,2.01,2.01,2.17,2 -0.14,-0.23,-1.44,1.11,-0.60,1.25,-2.30,1.72,0.63,2.72,5.99,4.31,1.96,5.01,3.66,1.99,4.07,2.97,-0.57,-0.09,-0.21,2 -0.52,0.71,1.62,1.63,0.03,1.13,3.34,3.16,2.87,4.67,3.30,4.65,2.82,0.42,-0.54,0.00,-0.66,0.57,0.68,0.35,1.16,1 --2.50,1.39,-2.54,-0.45,-0.49,0.08,-0.18,1.30,1.80,3.00,5.48,5.61,3.52,3.68,1.84,2.07,0.50,0.09,1.36,-0.81,0.30,2 -0.76,0.05,0.08,0.68,1.31,2.33,0.26,2.11,-0.56,1.36,1.37,2.32,2.53,4.18,5.03,4.56,2.67,1.18,2.42,1.88,-1.86,0 -0.00,-0.84,1.32,-1.83,1.86,-0.49,0.89,4.75,2.87,3.92,4.65,3.68,3.28,3.14,1.77,2.94,1.23,0.26,0.40,0.97,1.49,2 -0.11,1.81,1.63,0.48,0.38,2.38,1.99,4.01,4.85,5.27,6.16,3.25,2.61,3.38,0.25,0.49,-0.02,-0.76,-0.73,1.78,0.29,1 -0.09,0.56,-1.27,-0.09,1.31,2.23,-0.63,3.04,0.23,1.82,1.93,1.58,4.69,5.21,5.85,3.14,3.34,3.34,2.38,0.54,1.02,2 -1.01,1.03,-0.23,3.20,3.14,4.21,5.64,4.05,4.49,4.41,2.52,0.76,0.74,0.53,0.14,0.93,1.02,1.61,-1.54,-0.14,0.26,1 -1.42,-0.30,0.10,-0.58,1.01,1.13,2.13,2.28,3.05,3.67,5.04,2.44,3.13,3.21,3.85,4.22,1.12,1.25,0.06,-0.73,1.25,2 -0.72,0.14,-1.20,1.74,3.38,3.20,3.20,4.17,4.48,5.65,3.59,4.44,2.92,1.77,2.11,0.88,-0.24,0.16,-0.53,-1.52,-0.42,1 --0.38,0.74,-0.43,2.02,1.67,2.60,3.20,4.07,5.90,4.72,5.49,4.66,4.53,3.31,2.05,-0.09,0.19,-1.49,-0.01,-2.26,-0.01,1 -0.26,2.58,-0.73,3.47,2.34,2.31,3.18,-0.02,4.08,2.68,5.66,1.30,1.33,2.21,0.88,0.75,0.69,-1.23,-0.28,1.05,-2.58,1 --0.45,1.00,0.91,1.15,0.38,2.93,2.66,2.68,4.55,2.34,2.87,2.13,2.35,1.57,0.71,0.96,0.25,0.94,0.58,0.78,-0.09,1 -0.45,-0.71,2.02,-0.57,1.54,1.94,0.86,2.05,2.85,4.14,5.42,5.57,4.13,4.38,3.11,0.79,-1.43,-0.80,-0.99,1.36,0.21,2 --0.15,-0.29,2.27,0.59,1.59,-0.68,-0.70,0.45,0.50,1.19,4.69,3.61,3.39,4.92,5.48,3.57,4.23,2.34,1.69,2.21,-0.94,2 --1.26,0.07,-0.88,0.81,-0.02,0.20,1.14,0.66,0.87,2.28,1.61,2.48,4.13,5.50,4.79,5.45,2.21,4.05,1.60,1.49,1.42,0 --1.49,-1.89,1.12,0.57,-0.03,2.06,2.24,2.72,1.87,3.89,5.21,3.89,5.75,2.41,3.09,1.18,-0.48,2.00,1.06,-0.20,0.12,2 -1.03,0.60,-1.11,-0.50,-1.63,0.35,-0.51,-0.71,1.88,1.03,1.19,4.68,4.39,4.06,3.45,3.28,3.22,4.43,2.12,-0.21,-0.31,2 --0.27,-0.33,-1.68,-1.32,-2.03,-0.63,-1.11,1.25,1.63,4.53,2.32,3.40,2.86,2.46,3.68,5.05,0.86,2.11,0.52,1.57,0.66,2 -0.98,0.36,1.04,0.25,1.69,3.42,5.22,2.79,2.26,1.15,1.43,2.35,2.85,3.04,2.63,3.28,2.27,1.57,0.20,2.76,0.03,0 --0.37,0.21,0.57,1.67,3.06,2.32,4.36,5.02,4.37,5.19,4.09,3.62,1.10,2.92,1.08,0.75,-1.43,0.87,0.85,-0.30,0.56,1 --0.50,-1.61,-0.82,-0.61,-0.62,0.03,0.34,0.80,-0.68,1.66,3.98,3.63,4.42,5.99,4.58,4.70,3.97,1.27,1.39,0.52,1.07,2 --0.27,-0.77,0.94,1.40,0.63,2.49,2.45,2.56,2.05,1.79,3.08,3.52,3.32,2.57,2.82,4.17,2.38,0.91,1.86,-1.00,-0.67,0 --1.80,0.60,-0.77,0.34,0.61,1.51,1.52,-0.46,1.18,2.12,2.12,3.91,4.61,4.97,5.74,3.45,1.64,2.85,2.90,1.17,-0.78,2 --0.03,1.66,1.16,3.00,5.08,5.74,4.66,5.77,3.81,2.86,1.84,0.33,1.71,0.83,-2.12,0.27,1.77,0.43,-0.77,-0.34,-0.72,1 --1.05,0.91,1.67,-0.75,0.56,-0.50,0.45,-0.33,0.63,1.09,-0.76,2.01,2.24,5.11,3.78,4.83,2.47,1.71,0.80,2.19,0.90,0 --0.80,0.58,0.16,1.84,0.40,0.35,0.79,0.35,2.98,2.73,2.66,5.98,3.60,4.79,4.29,1.54,0.83,1.93,2.28,0.98,-0.26,2 --0.84,-0.18,0.49,1.55,2.88,1.27,3.01,4.00,2.32,3.64,0.61,1.41,2.34,0.53,1.36,0.58,0.95,0.79,0.24,0.70,2.03,0 -0.67,1.23,1.98,3.56,2.49,2.72,4.66,4.51,2.05,1.91,1.55,1.85,1.10,-0.31,1.38,0.91,1.89,1.21,0.69,0.54,-1.29,0 -0.02,-0.65,2.48,1.23,2.93,4.03,4.58,3.65,2.98,3.44,2.92,0.86,0.12,0.59,1.94,3.13,0.50,-0.03,-0.54,1.36,0.12,0 --0.51,1.21,-1.09,0.83,0.36,0.97,1.58,3.24,4.22,3.18,5.67,5.08,2.95,3.58,1.56,2.15,0.48,0.07,-1.10,-0.92,-0.56,2 -0.14,0.73,2.70,0.06,0.77,2.58,1.91,3.53,2.52,1.17,2.40,1.17,2.66,0.98,3.04,1.76,0.57,1.67,1.01,1.56,-1.08,0 -0.68,0.25,0.41,-0.26,0.67,1.73,-0.65,1.07,1.85,2.97,5.70,5.27,3.06,4.99,5.46,3.11,3.31,3.04,2.46,0.72,-0.49,2 --0.15,-0.77,-0.44,-2.43,2.11,0.66,1.58,1.81,1.19,5.52,3.61,6.03,4.03,3.20,2.45,2.94,1.38,1.16,-1.06,0.91,-1.46,2 -0.33,1.10,0.50,1.41,0.27,-0.68,1.64,1.51,3.17,6.79,7.24,5.34,6.37,2.87,1.81,0.95,0.26,-0.44,-2.04,-1.26,-0.20,2 -0.34,1.75,0.39,1.62,3.96,4.56,6.52,6.29,4.83,3.82,3.74,0.68,-0.44,1.38,0.64,0.81,1.34,1.93,0.03,-0.03,0.44,1 -0.29,0.87,-0.07,-1.40,-1.46,1.21,-0.95,1.53,1.68,1.47,2.96,2.99,3.70,3.76,5.51,4.13,4.10,2.01,2.05,0.64,-0.29,2 -0.10,0.71,0.14,2.42,1.13,2.62,1.11,1.24,1.63,0.07,2.23,1.79,1.60,2.40,3.27,1.80,3.10,2.01,1.02,-0.29,-1.43,0 --0.69,0.27,0.35,-0.31,-0.87,0.24,0.95,3.74,3.27,4.34,6.63,4.78,3.96,3.77,2.47,0.31,2.28,-1.11,1.58,-2.68,0.24,2 -0.72,0.05,0.24,1.20,-0.87,-0.60,2.67,3.32,2.72,3.90,6.46,2.05,4.38,2.35,1.68,4.52,0.91,0.56,2.23,0.88,-2.37,2 -0.67,0.25,0.85,0.56,3.36,2.35,1.97,2.10,1.52,1.49,1.86,1.79,1.89,3.28,3.46,2.61,1.82,1.36,0.11,2.06,-0.56,0 -1.36,1.11,-1.65,-0.73,0.03,-0.78,1.24,0.69,-0.59,2.37,2.13,1.68,5.05,4.88,2.66,3.33,1.32,2.84,0.81,0.52,0.45,2 --0.55,0.07,-0.35,-0.48,1.05,-0.45,-0.19,-0.82,1.26,0.36,1.24,1.86,5.27,2.92,7.16,5.87,2.09,1.05,2.05,1.89,0.72,0 -0.22,2.10,0.64,2.06,2.77,4.70,6.49,4.10,4.95,2.53,2.72,1.58,1.36,0.69,0.31,0.96,0.58,-0.36,0.12,0.34,-0.92,1 -0.51,0.69,0.86,1.95,0.68,5.36,5.21,5.53,7.90,2.24,3.74,0.33,1.17,0.68,0.98,-1.86,-0.50,0.04,-1.29,-0.57,0.77,1 --0.34,-0.40,-0.29,2.22,2.52,6.25,3.17,3.77,3.01,4.42,5.12,2.88,2.45,-1.53,1.53,2.13,0.63,-0.32,0.48,0.92,-0.39,1 --0.07,0.83,0.99,2.06,2.51,2.21,2.48,4.33,0.51,1.71,0.88,3.12,-0.24,2.39,3.07,2.79,1.02,2.00,-0.32,1.72,0.06,0 --0.17,-0.24,-0.81,-1.56,0.83,1.64,0.80,-1.27,-1.08,1.63,0.68,2.68,3.10,4.52,5.80,4.07,2.57,1.97,0.99,0.19,-0.12,2 -0.74,0.17,0.39,0.38,0.41,2.15,4.40,4.27,4.65,7.49,4.19,2.56,3.36,2.11,1.23,0.30,1.07,-0.23,1.70,0.14,-0.30,1 --0.43,-0.50,0.43,3.24,3.64,4.18,5.77,4.02,3.39,3.52,1.81,3.05,2.02,-0.22,-0.61,-0.07,-0.45,0.45,0.02,-0.14,-1.22,1 -0.25,-0.44,1.22,1.48,-1.00,1.12,1.52,1.41,5.25,2.40,5.70,4.53,2.52,2.53,3.65,-0.79,1.35,1.26,1.08,0.41,-0.79,2 -0.42,1.48,2.35,2.63,2.66,3.97,5.05,3.81,4.87,-0.39,1.59,1.19,0.36,0.11,0.12,-1.29,-0.62,1.06,-1.14,-0.61,-0.71,1 -1.32,-1.22,-0.62,-0.46,1.50,-0.89,-0.03,-0.28,-0.09,2.06,2.84,2.76,4.65,4.43,6.73,7.86,4.96,2.40,3.17,3.35,1.41,0 -0.02,-0.13,-0.23,1.50,1.91,3.36,6.34,4.16,3.04,3.24,1.03,1.86,-0.26,0.86,0.32,-0.80,1.59,1.72,-0.66,0.23,-0.47,0 --0.50,-0.54,-0.07,0.30,0.44,1.40,1.90,4.16,3.43,2.82,5.77,5.56,5.03,3.40,0.44,0.95,-1.18,-0.97,0.32,0.30,-0.50,1 -0.91,0.13,-0.01,-0.66,-0.46,0.98,1.74,2.37,3.56,5.37,4.91,5.05,4.23,0.58,3.69,-0.34,-0.74,0.65,0.53,1.13,-0.16,2 -0.04,1.83,3.30,1.13,2.97,3.69,6.38,5.99,3.23,3.89,4.34,1.63,3.26,0.12,2.50,-0.06,2.31,0.10,-0.22,-0.24,1.42,1 -0.28,0.12,-0.37,0.14,2.20,1.04,2.18,0.86,3.43,-0.67,1.75,3.38,2.18,3.30,3.74,5.84,2.45,1.83,0.93,0.37,-1.27,0 -0.12,1.15,1.84,0.86,0.65,0.59,-0.66,0.70,1.69,3.16,3.32,3.86,4.44,3.94,4.55,2.52,1.83,1.63,0.75,-0.70,-0.95,2 -0.39,0.61,-0.08,-0.37,1.09,-0.81,0.56,-0.10,3.50,4.20,2.40,4.86,4.85,4.64,4.25,3.49,1.99,3.30,1.61,0.56,1.80,2 -0.66,0.08,-0.80,2.80,4.80,5.23,5.68,2.99,2.41,1.38,2.49,1.58,0.73,1.71,2.61,-0.71,2.20,-1.24,-1.45,-0.04,0.60,0 --0.51,2.58,1.41,1.63,3.92,5.27,5.60,4.61,4.38,2.37,3.36,1.46,2.12,0.01,0.30,0.94,-3.56,-0.84,2.04,-0.54,1.46,1 -1.33,1.51,0.14,-1.23,-1.26,0.90,-0.32,-2.15,0.71,0.93,-0.17,2.66,3.64,4.84,6.12,3.97,1.80,3.71,2.58,0.39,0.65,2 -1.29,0.13,0.97,2.67,2.62,4.04,4.18,4.59,3.69,2.86,3.48,2.03,1.93,2.62,1.23,1.89,-0.21,1.55,-0.60,1.37,0.46,1 -1.45,0.25,-0.83,0.48,0.76,3.89,2.23,2.07,2.26,2.96,1.62,2.73,1.30,3.37,4.60,3.78,3.52,0.89,0.69,-0.75,0.41,0 -0.60,0.36,-1.35,-0.00,-1.48,0.68,0.21,1.12,2.62,2.91,4.02,3.77,2.94,3.82,3.63,1.74,2.16,0.01,-0.53,1.38,-0.85,2 --0.20,1.36,1.81,1.12,2.91,4.44,5.78,3.88,2.21,4.47,1.36,2.86,1.54,1.20,0.54,-1.94,0.25,-0.44,1.34,-0.87,-0.57,1 -1.44,0.36,-0.61,0.83,-0.62,1.94,3.33,2.45,3.67,4.36,4.00,5.54,1.18,3.34,2.35,2.67,1.92,1.49,-1.25,0.84,-0.19,2 -0.24,0.87,0.47,0.69,1.32,0.40,1.44,1.44,-0.09,2.29,2.40,4.50,2.10,1.72,3.39,2.24,3.00,2.80,2.28,2.16,-1.16,0 -0.08,-0.12,1.60,3.66,2.96,4.54,4.49,2.45,3.95,2.33,2.84,2.51,1.18,-0.13,0.55,-0.47,0.82,0.44,-0.65,2.93,-0.24,0 -1.24,-0.29,-1.43,2.34,0.73,-0.10,4.00,2.22,3.07,2.65,4.77,5.28,2.67,2.31,0.42,0.98,-0.60,1.23,-0.54,-0.84,0.72,1 -1.75,1.07,1.69,3.47,3.49,2.83,4.60,5.45,6.38,0.77,1.16,1.59,1.28,2.20,4.48,1.49,0.47,2.21,-0.51,0.09,-0.24,0 -1.45,1.88,-0.30,1.48,3.20,-0.43,3.06,0.43,1.16,1.43,3.30,0.08,3.85,2.96,5.10,4.37,3.63,0.94,1.35,1.44,1.40,0 --1.67,-2.47,0.59,1.08,-0.49,1.11,2.28,2.30,2.62,2.92,6.99,3.17,4.34,1.90,4.41,3.16,0.32,2.33,0.38,-0.33,0.80,2 --0.33,-1.03,0.86,0.15,-1.39,0.15,1.25,1.25,1.34,3.15,4.56,4.80,4.93,3.76,3.15,2.43,0.89,2.53,-0.17,0.41,1.75,2 --0.77,-0.57,1.29,0.17,1.76,2.36,3.56,5.45,5.00,3.34,2.46,2.00,2.31,2.40,1.64,0.84,-0.25,-0.02,-0.27,-0.50,0.28,1 -1.23,1.13,0.65,0.73,1.13,2.29,2.07,4.89,1.48,3.55,1.63,1.20,1.23,4.15,0.72,2.73,2.92,0.88,0.31,2.07,0.42,0 --0.30,1.11,1.71,0.34,-0.53,0.77,3.27,2.94,2.12,2.11,4.81,4.03,4.34,2.47,4.44,4.29,1.60,1.68,0.60,1.22,1.68,2 -1.08,0.26,-0.95,-0.75,-1.06,5.58,2.40,4.76,3.27,6.07,5.20,3.37,3.18,2.62,0.04,0.54,0.97,0.01,-0.44,-0.46,1.34,1 -0.11,0.34,0.35,-0.51,0.50,1.65,0.36,1.40,2.94,3.24,4.63,5.78,4.18,3.98,1.77,4.34,1.65,1.21,-0.47,-0.12,0.05,2 --1.86,-0.42,0.72,3.90,2.87,2.16,5.70,3.13,3.60,3.70,2.62,1.22,-0.48,1.27,-0.35,1.73,1.59,0.09,-0.04,0.27,0.39,1 --2.20,-1.42,-1.36,0.69,0.67,1.22,1.12,-0.26,0.74,2.98,2.47,1.77,3.70,2.16,4.98,2.90,1.24,1.25,0.47,-0.77,-0.09,2 -1.04,2.57,1.00,1.65,2.77,3.15,6.23,5.05,4.29,4.09,3.69,3.25,1.67,1.07,1.46,1.24,-0.59,-0.10,1.81,0.76,0.70,1 -0.83,-0.17,-0.02,-0.11,0.65,1.39,0.04,-0.18,0.14,1.55,3.15,2.64,3.22,3.00,6.23,2.88,4.72,1.85,1.67,2.02,0.79,2 --1.01,1.68,0.37,5.19,3.56,3.37,5.58,5.70,5.03,4.44,2.55,3.29,-1.31,-0.52,-0.29,1.67,0.96,-0.09,-0.64,-1.44,2.47,0 -1.06,-0.92,0.81,0.78,-2.55,-0.56,0.72,-1.08,0.88,2.20,2.99,5.12,3.50,5.40,4.30,3.52,4.61,4.46,2.90,2.28,0.87,2 -0.75,1.19,-0.17,0.54,0.72,-0.27,2.71,2.63,1.72,1.89,3.95,5.94,3.98,2.85,1.94,1.46,0.36,-0.16,0.13,1.73,0.34,2 -0.86,-0.81,0.80,0.74,1.60,2.34,0.50,2.05,2.14,2.25,3.45,2.93,3.28,4.82,3.93,3.61,1.91,1.15,0.23,0.70,-1.13,2 -0.91,-1.74,-0.01,-0.03,-0.84,0.61,1.98,2.80,4.38,5.08,6.14,5.55,2.53,2.50,2.32,0.93,2.90,0.49,-0.46,-0.51,-0.37,1 --0.89,2.01,-0.28,-1.34,-0.44,-0.24,2.46,0.45,-0.18,1.20,0.39,4.30,4.77,5.64,7.19,5.28,4.88,3.10,2.87,0.20,0.75,2 -1.78,2.86,-0.78,-1.09,0.39,-0.23,2.61,1.35,4.22,4.26,7.28,3.37,3.75,2.62,0.24,1.35,0.36,2.39,-0.33,2.49,0.35,2 -1.63,1.75,0.04,3.15,4.12,3.37,4.77,3.23,5.00,2.20,3.41,3.23,0.84,-0.45,1.47,1.43,0.97,0.50,-1.41,-0.32,-0.91,1 -1.43,-0.09,0.24,0.18,2.24,0.45,-0.20,1.23,-0.41,2.40,2.37,3.20,4.27,2.82,6.34,5.05,5.24,1.74,2.93,0.17,-0.80,0 -0.01,0.96,0.55,0.73,2.50,3.87,3.40,4.18,2.97,1.45,1.36,1.33,1.27,1.16,4.05,-0.11,0.05,-0.06,1.16,-0.02,0.43,0 --0.75,0.20,0.51,-0.24,-0.19,-0.58,3.27,2.58,2.09,4.26,6.51,5.53,3.35,1.48,4.31,0.54,-1.13,0.36,1.03,1.08,0.01,2 --0.76,0.90,0.84,3.95,1.96,0.80,2.90,2.07,1.28,0.50,2.96,0.33,2.88,2.28,1.53,1.16,3.63,-0.49,1.80,1.16,-0.16,0 --0.55,-1.01,1.39,1.53,0.42,1.74,1.02,1.20,0.47,1.42,1.23,3.15,2.54,3.25,4.02,4.10,3.37,2.72,2.54,0.31,1.07,0 -0.49,0.66,0.58,1.25,-0.17,2.46,2.62,2.98,3.39,5.22,6.31,4.02,2.17,2.46,3.46,0.73,1.98,-0.54,-0.38,-0.33,-0.41,1 -0.34,0.53,-0.65,2.01,0.23,-0.61,-0.07,0.66,1.72,2.93,4.02,3.96,4.68,3.59,3.09,2.54,0.45,-0.52,0.31,0.09,-1.25,2 -1.40,1.59,-1.23,0.34,1.25,1.75,1.66,1.24,0.91,0.45,2.95,2.42,4.01,2.76,5.57,3.20,2.22,1.45,0.29,-0.15,-1.26,0 -0.09,2.86,0.92,2.10,0.59,2.20,1.15,2.05,4.06,3.91,6.61,4.65,2.26,1.90,1.25,-0.60,-0.21,0.47,-0.36,1.24,-1.24,1 -0.08,-0.85,-0.16,0.72,1.11,2.66,2.16,5.62,3.69,5.50,5.93,4.82,3.27,2.52,2.25,0.82,0.46,-0.24,-0.45,0.88,0.03,1 -0.18,0.88,2.58,0.67,0.92,2.60,2.28,2.68,1.44,1.02,2.65,1.96,1.77,2.09,5.01,4.41,3.43,0.92,1.48,1.23,-0.56,0 -0.49,0.62,-1.50,2.11,0.18,2.38,2.65,3.99,3.03,3.92,4.81,4.25,4.13,2.37,1.76,0.60,-0.30,1.65,-1.37,-0.16,-1.97,1 --1.26,0.95,-1.43,0.26,0.50,1.20,1.05,4.02,3.59,4.99,6.73,4.97,4.12,3.49,4.66,1.43,0.50,-0.14,0.46,-0.26,2.21,1 --2.31,-1.15,-0.86,1.40,-0.49,0.53,0.74,2.77,2.09,3.53,5.29,1.95,3.69,2.63,3.73,2.68,1.54,1.03,-0.22,-2.08,-0.38,2 -0.55,-0.50,-1.38,0.68,1.53,1.03,1.52,1.61,-0.30,3.34,3.66,2.97,3.97,3.40,5.18,3.55,2.58,2.07,1.92,0.69,-0.74,2 --0.94,2.52,-0.46,1.73,3.58,0.86,1.17,3.08,2.41,0.98,1.09,3.27,1.69,1.96,3.25,2.10,1.98,1.86,-0.41,-0.11,-0.27,0 -0.85,-0.66,-0.60,-0.08,0.56,-1.09,-0.91,0.39,2.86,-0.53,3.29,5.50,3.42,4.38,5.02,5.64,3.08,3.32,2.86,1.35,-0.66,2 --0.45,0.60,1.21,-1.07,1.73,0.50,2.88,3.55,1.40,0.35,0.54,2.14,1.69,2.35,3.52,3.38,3.10,1.75,1.47,1.89,0.75,0 -1.55,-0.00,2.34,2.70,0.57,4.43,4.46,1.76,1.76,2.22,1.00,1.64,2.16,0.57,1.37,1.66,4.06,2.39,2.25,-0.16,1.16,0 -1.84,1.11,-0.14,-0.21,4.18,3.31,2.03,0.48,1.44,-0.21,2.27,1.98,2.63,2.28,2.97,2.22,2.70,0.84,1.21,1.09,0.03,0 -0.44,0.24,0.46,3.07,0.12,0.93,0.40,0.53,3.54,0.77,1.75,1.99,4.89,4.93,4.55,4.57,2.72,2.50,2.53,-0.28,-1.17,0 --0.86,-0.62,0.65,-0.29,1.01,0.31,-0.14,1.85,1.69,4.27,3.86,3.19,5.29,4.85,2.62,2.38,2.26,-0.24,0.15,0.37,-0.15,2 -1.23,0.16,2.17,5.12,4.67,4.60,2.99,3.72,2.80,3.76,1.24,-0.09,3.34,0.04,2.24,1.08,1.15,1.97,-0.09,1.43,0.04,0 --1.58,-1.45,-0.60,0.35,2.00,-1.06,1.88,1.50,0.17,1.54,2.59,2.12,3.54,5.19,3.67,2.93,3.38,1.92,1.55,0.79,-0.63,2 -0.12,0.84,1.01,1.88,2.85,3.75,5.68,5.99,3.92,4.50,1.94,0.99,-0.18,1.59,1.76,0.64,-0.65,1.34,-0.39,-0.11,2.63,1 --0.54,-1.02,2.28,0.60,2.38,3.90,1.71,3.65,1.27,2.91,1.03,2.24,4.28,2.12,4.78,2.59,2.41,2.10,0.69,1.45,1.32,0 --1.18,-0.26,2.03,1.81,2.64,4.19,3.27,3.82,1.93,1.09,1.38,2.54,1.65,2.11,1.51,3.33,1.64,2.38,0.32,-0.65,-1.07,0 -0.12,1.58,0.62,0.39,0.31,2.88,2.66,4.93,2.73,2.82,5.29,1.90,1.97,1.44,0.37,-0.10,0.49,1.26,-0.51,0.10,0.18,1 --1.04,-0.37,2.04,0.91,2.37,4.70,5.28,4.19,3.79,5.11,3.84,2.02,0.68,0.57,0.88,-0.76,-0.22,-0.76,0.29,0.03,0.26,1 --0.26,1.67,-0.25,0.78,0.51,0.45,0.59,-0.20,0.71,0.93,3.34,2.58,1.83,2.38,3.46,1.94,2.41,2.75,2.41,0.94,1.42,0 -0.15,-0.96,-0.10,0.08,1.91,1.57,2.85,2.57,-2.05,3.04,1.72,2.15,2.38,2.31,2.94,-0.03,0.13,2.26,-0.10,1.64,0.46,0 -0.88,1.16,0.69,0.34,-0.15,-0.33,2.17,-2.16,1.43,2.92,3.08,4.20,4.29,4.81,6.69,3.43,3.59,3.46,2.34,0.05,0.03,2 --1.86,0.66,1.70,0.04,2.29,3.40,2.36,1.85,1.18,-0.04,2.44,2.37,2.77,3.42,5.88,1.85,1.97,2.26,0.32,1.13,-0.51,0 --1.15,-0.54,-0.19,-1.26,-0.50,-0.37,0.26,1.23,3.37,-0.36,5.02,2.74,4.20,5.80,2.57,4.72,2.50,1.96,2.47,0.78,-0.49,2 --0.44,2.37,1.24,1.00,0.22,1.19,2.93,4.23,4.10,3.93,4.04,3.53,1.72,3.41,1.39,0.78,-0.53,-0.33,1.97,0.69,0.30,1 -1.00,2.44,1.27,1.84,2.67,3.65,5.14,4.16,2.75,2.38,3.22,1.62,0.67,1.65,0.49,0.44,0.62,1.22,-0.12,0.03,-0.41,0 --0.58,0.34,0.29,1.61,2.74,3.29,4.05,4.22,3.22,5.27,5.09,4.23,1.97,1.95,0.15,0.66,1.54,-0.67,-1.02,-0.57,-1.96,1 -0.88,0.20,-0.33,0.14,1.93,1.76,1.37,1.66,2.58,2.13,4.14,2.83,5.76,4.79,3.69,2.70,3.82,3.47,0.30,1.23,-0.19,2 --0.03,0.78,1.90,2.88,4.78,3.40,4.11,5.25,3.95,3.96,3.98,3.86,-0.42,-1.00,2.55,2.98,1.49,0.98,0.72,2.03,-0.63,1 -2.17,1.10,0.63,0.91,2.56,2.38,5.00,3.29,2.39,2.59,5.32,1.78,3.21,2.05,1.72,-1.38,1.44,-0.07,0.72,1.06,-1.17,0 --0.72,-1.21,-2.31,1.70,-1.68,1.81,1.38,1.16,0.83,2.13,2.55,2.68,2.26,5.27,4.52,5.62,1.75,0.90,1.72,0.05,0.03,0 --0.21,-2.78,-0.57,-0.17,2.30,2.74,4.69,4.00,3.42,5.19,4.25,1.39,2.74,1.01,1.10,-0.15,-0.15,0.10,1.09,1.26,0.38,1 -1.01,-0.33,-0.99,-1.21,0.66,1.91,0.56,2.42,4.69,4.81,7.70,5.99,3.66,4.05,3.34,1.54,0.34,-0.68,1.41,-0.83,-1.52,1 -0.82,0.02,1.39,3.43,4.13,2.87,5.28,4.34,4.98,4.70,1.46,2.15,0.59,-0.98,2.22,0.05,1.09,-4.08,0.34,-0.81,-0.86,0 --1.07,1.54,1.60,1.05,1.26,1.40,2.39,1.94,1.41,2.48,1.01,4.88,3.49,1.62,2.33,0.92,2.35,1.35,2.16,-1.37,-0.22,0 -2.42,1.84,0.56,1.36,-0.55,0.24,-0.22,-0.18,0.43,1.07,2.21,4.98,3.63,5.28,4.60,3.34,3.24,2.92,0.85,0.36,1.17,2 --0.26,-0.17,0.53,0.26,0.94,2.29,1.58,0.76,3.15,1.06,1.60,3.53,1.48,4.81,3.74,0.67,2.69,0.90,0.49,0.72,-0.88,0 --0.80,-1.73,1.19,0.63,2.05,3.92,4.59,5.19,1.96,5.86,4.04,2.61,2.50,0.93,0.67,1.13,-1.17,0.39,0.01,0.68,-0.81,1 --1.78,-1.07,1.25,0.75,0.37,0.53,1.01,-0.59,2.76,1.03,2.83,5.11,4.44,5.37,4.18,2.94,4.86,0.83,0.50,0.73,1.31,2 -0.40,1.15,3.60,3.26,4.15,4.45,6.13,3.96,5.08,1.74,1.21,-0.78,0.71,1.93,1.65,-0.02,0.13,1.93,3.17,1.33,0.06,1 -0.03,2.35,2.97,0.81,1.55,2.79,2.28,3.80,5.81,5.91,3.84,4.29,2.54,1.02,1.52,1.64,-0.73,1.21,0.84,0.53,1.59,1 -0.93,2.08,0.61,-0.27,0.81,0.15,-1.25,-0.25,0.56,1.48,2.39,2.54,4.36,5.54,5.37,6.22,5.48,2.78,2.84,-1.26,1.28,2 -0.63,-0.90,-0.83,1.93,-0.96,-1.09,1.09,0.75,2.54,3.11,0.23,2.93,4.50,3.67,4.30,3.84,2.21,2.45,1.54,0.62,-0.64,0 -0.07,1.21,2.21,2.52,3.02,4.14,6.94,5.03,2.11,2.99,3.11,-0.35,0.19,-0.61,1.01,0.50,0.43,0.77,1.09,-1.47,1.23,1 --0.20,0.71,1.77,1.21,0.59,0.92,1.18,3.09,4.42,3.43,5.78,5.37,4.46,3.06,1.84,0.48,-0.72,-0.12,-0.49,1.78,-1.30,2 --0.37,0.34,1.08,2.49,2.64,2.46,6.29,5.39,4.02,2.93,2.20,2.73,1.47,1.08,0.61,0.39,-1.11,-0.21,-0.13,2.25,-0.30,1 --0.68,-0.97,0.02,1.99,-0.50,0.64,0.88,2.03,3.85,4.38,4.16,4.26,4.59,2.78,1.20,2.04,-0.31,1.17,-0.75,-1.31,-0.79,1 -0.28,0.60,-0.21,-0.85,-0.70,0.70,-0.42,-1.63,1.05,2.00,1.98,3.41,4.97,3.13,5.51,5.86,2.23,2.04,0.85,0.36,0.10,2 --1.08,0.11,1.19,-1.39,0.68,0.77,0.49,-0.04,0.41,3.80,2.77,3.70,3.00,6.11,6.24,3.25,6.71,4.00,0.35,0.24,0.59,2 --0.89,-0.08,0.98,1.60,0.40,3.92,2.87,2.15,5.21,3.97,2.57,2.40,3.21,0.62,0.36,1.16,-1.27,-1.63,1.38,1.31,-1.08,1 --0.05,2.12,3.05,3.10,3.24,5.92,5.32,4.66,3.91,2.21,1.57,1.96,0.08,1.09,1.00,0.24,1.19,-1.25,1.32,-1.44,-0.16,1 --1.30,0.12,1.59,3.03,2.17,2.72,3.14,4.18,3.36,2.64,1.96,3.74,0.73,0.59,0.41,-0.42,-0.68,0.79,-0.44,0.33,-0.04,1 --0.21,0.47,-0.65,-1.32,0.66,0.26,2.00,1.26,0.80,-0.06,0.68,3.40,6.09,4.92,6.34,5.47,3.53,3.59,1.84,1.59,0.36,2 --1.65,0.28,-0.57,0.01,1.88,0.94,0.40,1.35,0.97,2.36,0.97,3.45,3.79,6.62,6.39,4.23,2.59,3.01,1.77,1.70,-0.14,2 -0.10,0.33,-1.00,-1.56,-0.70,0.71,0.44,1.71,1.63,3.65,5.14,4.80,5.18,3.55,3.71,1.62,2.17,0.23,0.42,-0.08,1.91,2 --1.67,-0.52,-0.87,0.22,-1.91,0.18,0.92,-1.03,-0.33,1.36,2.13,1.81,4.74,5.01,5.44,6.17,2.30,1.42,1.72,1.89,0.64,2 -0.69,0.48,2.66,3.26,3.32,3.17,3.84,4.07,2.94,3.64,3.53,3.11,1.17,0.40,0.34,0.95,-1.24,0.20,-0.35,1.29,-1.44,1 -0.46,-0.51,0.57,1.63,-0.78,1.05,3.18,1.32,-0.20,2.38,1.43,1.57,1.76,4.20,6.17,4.90,4.97,3.93,2.97,1.82,-0.21,0 -0.12,-0.14,-1.20,0.16,-0.95,2.06,3.13,2.29,2.45,4.63,7.50,5.76,4.96,3.58,3.45,1.19,-0.19,-0.46,0.40,-0.06,2.92,2 -1.36,-0.79,0.33,3.82,0.47,3.48,4.17,3.17,3.23,0.93,1.67,1.64,2.56,2.61,1.53,1.83,3.99,1.58,-0.05,0.86,-0.75,0 --0.94,1.03,2.43,1.72,2.71,4.32,5.11,4.18,3.47,3.47,0.91,0.63,1.91,1.74,1.59,0.38,0.74,0.46,0.11,0.39,0.26,1 -0.21,-0.53,0.38,-1.37,-1.17,-0.10,0.70,-0.36,-0.10,0.93,0.49,2.45,4.68,3.73,4.52,4.20,2.57,3.25,2.10,-0.79,-0.05,2 --0.76,1.25,3.06,5.27,2.24,5.44,5.33,3.48,3.82,1.10,3.72,2.26,1.20,1.60,-1.28,3.33,-0.01,0.12,-0.10,2.53,0.63,0 -1.20,-2.29,-0.43,-0.00,0.40,-0.98,2.11,1.09,1.09,2.41,4.42,4.39,4.16,3.78,5.22,3.76,3.40,2.82,0.35,-0.14,-0.23,2 -0.65,0.45,2.25,1.67,5.32,5.24,4.93,2.95,4.08,3.01,2.51,0.52,2.37,-0.28,-0.12,-0.07,1.25,-0.62,-0.32,-2.82,1.86,1 -0.57,-0.57,2.84,-1.02,1.26,0.27,0.48,2.45,3.70,2.93,6.45,4.66,2.62,3.10,2.86,2.53,-0.04,-0.34,2.13,0.52,-0.41,2 --1.15,0.80,-2.65,0.83,0.45,-0.49,0.49,1.26,2.09,1.61,5.38,1.88,4.04,5.87,4.56,1.80,2.41,1.44,3.01,0.48,1.02,2 -0.06,0.68,0.27,0.14,1.14,1.64,0.69,2.87,2.90,0.91,4.42,2.95,4.48,4.50,8.04,4.10,2.81,3.49,0.66,-0.49,0.61,2 --0.02,1.17,-0.10,-0.54,-1.56,0.25,0.85,1.54,2.81,2.63,2.81,3.31,6.18,6.61,4.27,2.62,1.20,0.20,1.63,1.58,1.43,2 --0.87,2.31,-0.09,-1.01,-0.22,1.76,-0.08,2.36,1.98,2.18,1.59,2.04,3.42,3.81,5.49,3.74,3.43,2.16,1.87,-0.18,-0.43,0 -1.46,1.21,0.39,1.61,-0.17,-0.22,1.10,1.29,1.08,0.58,2.16,3.38,3.90,4.82,4.51,5.24,3.30,4.27,0.27,1.33,-0.87,2 -0.42,-0.75,-0.93,0.07,0.06,0.65,1.75,2.21,3.98,3.59,3.65,3.70,5.53,2.65,3.87,1.11,-1.32,0.98,-0.83,-0.12,-0.66,2 -1.05,2.56,2.77,1.84,2.87,2.76,2.55,3.64,2.91,0.85,1.85,2.56,2.85,1.31,2.84,1.29,1.81,1.55,-0.71,-0.11,0.25,0 -0.95,-0.20,1.13,1.65,-0.46,-0.05,1.46,2.63,2.63,3.96,4.83,3.33,3.34,3.02,3.31,2.29,0.79,1.08,-0.20,-1.47,-0.65,2 --0.03,-1.01,-0.59,-0.48,0.76,-0.60,1.76,0.24,2.76,1.35,3.39,4.35,1.82,5.74,3.32,1.57,3.53,1.29,2.44,0.03,-0.62,2 --2.75,0.32,0.28,-1.29,0.24,1.13,1.61,0.88,2.55,4.46,2.86,6.76,4.10,4.06,3.69,2.42,-0.69,1.28,1.65,1.19,0.02,2 --1.20,0.89,1.97,1.40,2.78,2.20,3.19,4.10,2.21,2.03,2.41,2.36,2.33,3.28,2.98,2.83,-0.03,1.36,2.28,-0.11,0.20,0 -0.54,0.11,-0.26,1.32,2.66,5.24,2.17,3.71,3.49,2.85,2.21,2.38,0.64,2.26,-0.34,0.96,0.89,0.03,2.45,1.34,-0.14,0 --1.06,0.09,2.16,1.01,-0.06,1.81,1.70,1.27,1.99,2.46,1.58,1.91,2.76,2.54,3.08,2.17,4.36,2.67,0.86,-1.55,-1.02,0 --0.17,2.86,1.75,3.80,2.02,1.23,2.50,2.57,1.11,1.00,0.96,1.91,3.38,3.43,4.11,1.73,4.02,3.29,3.19,0.42,1.94,0 --1.29,-0.03,0.19,1.20,0.20,1.74,2.60,3.97,4.18,4.25,6.05,4.35,2.12,4.25,-0.04,-0.10,-1.17,-1.30,-0.19,-1.11,-0.76,1 --0.08,-0.46,0.93,5.22,3.33,2.05,5.75,1.52,2.47,3.52,3.27,0.18,-0.07,1.49,2.56,2.82,1.21,0.35,0.32,-0.24,-0.52,0 --2.77,1.16,-1.86,-0.91,0.04,2.05,3.04,1.41,5.23,4.72,6.60,4.54,4.06,2.67,2.46,-0.86,-0.28,-0.84,1.02,0.41,-0.35,2 --0.01,0.24,-0.22,-0.19,3.17,3.46,2.82,4.59,2.62,3.92,5.85,4.63,2.99,3.50,0.52,0.04,-1.11,0.75,0.49,1.57,-0.73,1 -0.17,2.72,1.03,2.24,0.01,0.19,0.92,0.88,2.07,0.98,3.07,3.74,3.89,2.55,3.78,1.99,2.58,0.84,1.08,1.63,-0.40,2 -0.18,1.44,-0.67,0.77,1.61,1.47,1.96,4.90,4.06,5.19,4.43,3.87,3.00,2.52,1.16,-0.35,-0.35,0.47,-1.34,1.25,-1.71,1 -0.35,0.48,-0.77,0.61,0.33,0.11,0.64,3.17,0.97,1.64,1.07,3.25,4.19,4.10,3.45,4.75,1.01,4.51,1.49,1.79,-0.27,0 -2.21,1.86,0.37,2.30,2.56,4.53,5.90,5.59,4.30,3.74,4.30,4.04,0.06,0.89,-0.48,2.39,1.90,0.30,-0.53,-0.74,-0.90,1 -0.02,-0.84,1.45,2.76,0.55,1.33,4.25,3.53,3.82,4.28,5.17,2.45,3.57,1.50,1.30,0.68,-0.59,-0.51,-0.95,1.58,1.05,1 --0.71,1.03,1.98,3.95,2.47,3.84,4.74,3.17,3.94,2.98,1.72,-0.53,-0.56,1.00,-1.38,-0.68,-1.22,0.17,-0.36,1.36,0.79,1 -1.85,0.30,0.20,-0.22,0.48,0.37,-0.38,-0.24,1.06,1.79,5.33,3.90,4.56,5.84,3.60,2.78,5.55,1.19,2.03,-1.18,-0.43,2 --0.99,0.12,1.65,0.71,2.34,2.94,4.28,2.66,3.15,5.46,5.22,3.33,3.93,0.41,-0.23,0.62,0.78,-0.16,-2.08,-1.20,-0.37,1 -1.04,0.63,2.33,-0.89,-0.74,0.54,1.69,1.31,1.43,3.21,4.16,3.64,3.01,4.22,4.55,1.98,1.55,0.33,1.31,0.23,-0.18,2 --0.62,-0.39,1.04,0.55,1.86,0.93,1.38,1.22,2.40,3.59,6.86,5.13,3.80,2.71,2.47,1.44,0.05,1.76,1.49,0.84,0.76,2 -0.63,1.67,2.55,0.84,-0.74,-0.54,0.71,3.48,3.47,3.59,5.14,3.95,5.67,2.95,1.62,2.38,1.15,1.29,0.44,-0.75,-0.29,2 --0.02,0.56,0.97,0.59,2.04,3.90,2.34,0.80,1.91,1.96,1.90,3.13,4.22,2.74,2.50,3.09,2.10,-0.26,0.36,0.37,0.62,0 -0.70,0.96,2.36,4.00,4.15,4.18,6.74,4.94,4.03,5.66,2.63,1.50,0.32,-0.77,0.13,-1.63,-0.13,0.30,-0.23,-0.24,0.98,1 --0.01,2.38,0.25,3.27,-0.20,1.55,2.54,2.06,2.68,0.64,3.26,1.82,2.34,3.36,2.64,1.71,2.59,1.36,1.35,-0.81,1.93,0 --0.37,-1.38,0.47,1.53,2.25,4.70,5.11,4.06,2.91,2.40,0.69,3.04,0.99,0.71,-0.64,-0.11,-0.03,0.84,-0.54,-0.69,0.35,1 --0.03,-0.36,0.72,2.59,2.49,3.76,4.92,4.73,4.04,3.15,4.76,3.67,1.11,2.31,-1.77,-0.61,1.57,-2.14,0.92,-0.17,-1.29,1 --2.09,0.38,-1.48,-0.65,-0.32,1.48,1.06,2.56,2.05,3.71,4.80,3.57,5.34,2.93,2.26,0.56,1.58,0.66,0.30,0.90,2.18,2 --1.48,1.56,-0.77,0.31,1.87,1.28,3.73,4.31,0.73,3.42,6.04,3.15,6.25,1.87,2.69,-0.47,-0.56,-0.68,1.26,0.54,0.36,1 -0.05,0.22,1.31,3.30,3.54,5.39,6.25,4.57,4.50,3.93,2.02,1.92,3.20,0.26,0.48,1.16,-0.35,1.37,0.10,-0.45,1.35,1 --0.03,0.26,-0.89,0.14,0.41,1.21,1.60,2.29,2.15,2.81,3.35,2.19,3.47,4.00,4.37,3.83,4.11,1.42,2.13,0.33,-0.34,2 -0.52,1.22,1.39,2.19,2.25,4.66,3.00,3.73,2.08,3.75,4.23,0.45,0.35,0.94,1.62,1.04,1.16,0.40,-0.99,0.75,-0.53,0 --0.56,0.92,-0.21,1.28,1.89,-0.13,1.87,0.81,2.36,-0.79,3.05,2.48,3.87,2.56,6.39,3.45,4.34,2.94,1.57,-0.17,-0.68,0 --0.23,0.43,-0.15,0.20,-0.09,0.54,-0.36,0.14,1.90,1.77,2.41,3.69,5.02,4.10,3.89,5.00,2.96,1.79,2.07,0.40,-1.55,2 -1.77,-0.72,0.09,1.06,-1.37,1.42,5.34,1.87,4.86,4.39,5.91,5.67,4.52,0.51,2.37,0.43,0.14,0.58,1.89,0.76,0.94,1 -0.30,0.21,0.30,-1.26,-2.44,0.98,0.78,1.48,3.57,3.39,3.80,3.81,4.66,0.59,4.26,0.97,1.81,2.37,-0.08,0.69,0.02,2 --0.83,2.20,-0.72,1.27,0.77,0.01,2.41,1.17,1.68,5.59,4.18,2.93,3.70,4.43,3.93,2.33,2.94,0.08,2.22,1.20,-0.42,2 -0.96,0.31,1.18,-0.09,-0.90,0.96,-0.10,0.63,0.75,4.40,2.35,2.17,4.77,3.77,3.65,2.83,2.20,0.85,1.10,0.14,0.10,2 --0.71,1.20,1.10,2.66,3.67,2.89,5.26,5.64,2.54,1.19,1.83,2.51,-0.10,1.30,1.55,-0.40,0.02,0.41,-0.49,0.23,0.92,0 -0.61,-0.51,-0.84,-0.53,0.94,-0.12,0.08,2.13,1.54,2.03,3.02,4.15,3.97,2.95,5.42,3.29,3.90,0.81,0.58,0.23,-0.07,2 -0.57,0.76,2.20,1.91,1.80,3.31,3.87,2.96,3.90,4.56,1.43,1.08,2.62,2.88,0.97,1.18,-0.13,1.28,-0.05,0.96,0.31,1 --1.12,-0.01,-1.16,-0.82,-0.15,-0.37,1.28,2.67,1.14,2.15,4.29,2.91,2.26,3.31,5.11,5.17,2.49,3.38,2.15,0.27,0.27,2 --1.09,-0.10,-0.94,-1.19,-0.13,1.20,3.55,2.91,4.15,4.67,5.52,5.60,4.28,3.66,1.14,1.58,-0.14,0.99,-0.81,-0.80,0.83,2 --1.90,0.81,1.17,1.35,-0.71,1.76,2.16,1.81,3.32,2.95,4.69,5.07,4.21,4.36,-0.26,1.82,0.99,1.72,1.83,1.23,-1.40,2 --0.31,1.25,1.16,2.48,2.57,2.27,2.94,2.17,3.55,4.84,4.02,3.20,3.19,1.08,1.70,0.68,-1.97,0.61,-1.28,-0.61,2.14,1 --0.75,-1.60,1.01,1.40,-0.55,1.71,-0.02,2.28,3.30,5.79,7.27,4.55,5.20,3.63,2.80,-0.83,-0.07,0.14,0.91,2.19,1.97,2 -0.00,-0.99,-0.24,-0.10,-0.92,0.04,-1.98,0.05,0.87,2.03,3.79,4.56,3.58,4.35,3.76,2.70,1.08,0.49,1.40,-0.13,-0.78,2 --1.53,0.41,-0.54,-0.86,0.19,1.41,2.49,3.15,3.51,4.68,6.44,3.75,5.90,4.84,0.63,2.01,-1.17,1.17,1.20,-0.20,1.23,2 -0.34,0.61,1.90,2.57,2.40,5.04,6.49,4.30,3.01,2.20,1.21,1.18,-1.03,-0.97,3.24,1.02,1.66,1.54,-0.51,-0.29,0.38,0 -0.33,0.94,0.56,3.99,4.49,5.41,5.25,3.81,1.96,2.91,2.99,1.18,-0.00,0.73,0.99,-1.11,-0.81,-0.54,1.81,0.77,-0.52,0 --1.52,-0.34,-0.19,3.86,2.89,3.80,5.96,4.01,3.64,4.31,0.17,2.49,-0.40,-0.31,1.04,0.70,-0.21,0.73,-0.21,-0.84,-0.60,0 -0.38,1.25,2.50,2.01,3.99,2.41,4.76,6.41,5.41,3.10,1.88,2.13,2.46,0.53,-0.67,-0.33,-0.47,-0.43,0.61,0.17,0.06,1 -0.49,0.90,0.72,2.13,1.13,4.30,4.06,4.15,2.93,3.93,4.30,2.36,2.07,2.10,1.80,0.43,-0.36,-0.66,-0.87,-0.42,-0.83,1 -0.65,0.27,-0.44,2.24,2.28,2.92,4.00,2.76,2.14,2.31,1.78,0.96,0.86,2.76,2.20,1.73,1.33,0.98,-1.00,-2.46,-0.52,0 -0.35,2.37,1.87,1.40,4.43,4.26,3.16,4.23,3.87,3.92,3.92,0.09,1.04,-0.03,2.14,1.56,-2.02,-1.17,0.26,1.36,1.29,1 -1.11,-1.33,0.93,0.87,0.93,-0.31,1.27,1.49,2.39,3.97,1.41,3.72,3.13,4.62,6.50,4.83,3.23,2.98,1.96,0.81,-0.06,2 -0.70,1.96,1.35,1.31,3.55,4.62,4.43,2.11,2.80,2.81,3.25,0.74,2.71,2.56,1.80,0.04,1.14,-0.99,-0.19,-0.26,0.54,1 --0.38,1.29,0.66,-0.81,0.57,0.17,-0.03,1.65,1.71,3.32,3.81,3.83,3.55,1.35,5.55,2.08,0.28,2.24,1.74,-0.05,1.14,2 --1.29,-0.34,-0.39,0.64,0.14,0.84,1.00,2.70,3.50,4.39,4.33,3.89,2.49,4.11,4.72,3.94,1.74,1.50,-0.61,0.78,-1.80,2 -1.90,0.32,0.02,-0.44,-0.43,1.14,4.05,3.83,4.29,5.70,5.88,5.23,4.83,2.68,3.06,1.22,1.26,1.81,1.73,-0.88,-0.26,2 -1.22,1.68,2.00,-0.19,1.03,-0.75,1.49,2.35,4.83,5.21,6.65,5.09,4.22,4.08,2.31,-0.33,-0.01,-0.45,-2.55,0.46,0.23,2 -0.20,0.49,0.92,1.09,1.04,2.63,2.11,4.30,2.87,4.11,4.32,3.58,3.22,2.85,-0.63,0.28,0.62,-0.96,-0.67,0.72,-1.44,1 --1.24,1.50,0.03,1.22,-0.07,1.59,1.80,1.02,0.62,3.35,3.55,2.13,4.57,4.61,2.20,2.81,1.09,2.51,2.48,-0.85,0.28,2 --0.63,-0.04,-0.74,-0.59,1.42,2.23,3.03,2.67,3.59,4.05,4.72,4.52,3.06,3.82,2.54,-0.49,0.41,0.72,0.07,-0.19,-0.09,2 --1.25,-0.01,-1.32,-0.24,1.17,2.11,0.70,0.81,1.80,5.45,5.25,6.51,3.16,2.60,1.15,-1.61,2.12,0.56,0.53,-0.79,0.32,2 --0.85,0.98,3.43,2.68,3.99,4.72,4.88,3.46,3.08,2.43,1.24,2.95,1.42,0.82,1.72,0.88,-0.07,0.39,-1.67,0.07,-0.62,0 --1.37,1.29,2.97,3.20,3.69,4.52,4.17,4.18,4.81,2.98,2.71,3.14,1.96,0.51,1.14,2.45,-0.63,0.94,1.03,-1.15,-0.73,1 -0.11,2.41,0.24,-1.02,-0.08,0.56,0.35,0.32,1.30,2.46,1.01,3.10,4.37,4.41,4.42,4.37,3.76,1.58,1.69,1.90,1.26,2 --1.71,1.93,2.64,1.79,4.09,4.71,6.25,5.71,4.75,3.75,4.82,1.45,0.50,-0.09,1.09,1.14,-0.97,0.55,0.89,-0.44,0.14,1 -0.35,-0.24,1.27,-1.16,0.84,1.42,1.91,3.99,1.32,5.21,6.82,4.45,3.57,2.69,1.74,0.36,-0.42,0.07,-0.80,-0.48,-0.50,2 --0.40,0.54,1.44,-0.17,0.58,2.00,1.51,3.17,4.72,5.57,6.05,5.93,3.05,2.81,3.60,0.79,-0.41,1.17,-1.17,0.66,-1.83,1 --0.72,1.76,0.74,2.04,1.43,4.64,5.53,3.53,3.74,2.83,4.33,2.02,0.19,1.36,-0.08,0.73,-1.37,0.12,-0.81,0.40,-0.65,1 -1.07,1.01,1.23,0.17,0.05,1.76,0.47,-0.90,4.18,5.84,4.58,5.56,4.53,3.66,2.52,3.98,2.01,1.33,-0.51,-1.31,0.68,2 --0.02,-2.28,-0.33,2.92,1.79,3.17,3.99,3.85,5.27,3.66,4.77,2.47,3.34,0.37,-0.45,2.42,-0.41,-1.42,0.33,-0.78,-1.31,1 -1.40,0.26,0.02,-0.06,-0.27,-0.43,3.89,1.47,4.46,4.98,3.82,5.72,3.35,4.69,3.39,2.79,2.00,0.59,-0.36,-0.27,0.36,2 -0.76,0.56,-0.21,1.84,4.26,2.17,3.24,4.37,5.71,3.14,3.90,0.50,0.66,0.99,-0.36,-1.31,-0.09,-0.40,0.22,0.57,0.27,1 -0.15,0.44,-4.20,0.83,1.09,-0.16,2.40,2.98,3.28,3.65,5.42,5.45,5.56,2.93,1.47,-0.08,-1.20,0.76,1.73,0.38,0.06,2 -1.55,0.77,1.21,0.78,0.18,2.07,0.63,-0.22,3.32,1.72,2.97,3.56,4.56,4.51,5.12,4.76,3.52,1.85,0.56,1.02,-0.42,2 -2.87,-0.03,1.65,2.15,0.04,1.78,0.53,-0.27,1.34,2.53,0.77,2.69,4.71,1.31,4.48,2.76,1.29,0.60,1.58,0.18,0.68,0 --0.34,0.02,-0.42,0.30,1.13,1.29,1.74,2.31,2.97,3.12,3.09,5.70,3.92,3.48,2.99,0.32,0.41,0.99,-0.69,0.62,-1.29,2 -0.15,-0.98,0.09,0.57,-0.59,1.69,3.30,3.45,2.20,5.38,4.23,5.69,0.85,2.77,0.70,0.20,-0.12,-0.01,-0.93,-1.12,-0.47,1 -0.99,-0.13,-1.86,-0.77,0.13,-1.82,1.91,1.29,2.82,3.29,3.26,3.41,6.29,4.54,7.48,4.98,2.12,1.99,1.77,2.74,1.29,2 --0.06,-0.19,1.30,-0.00,0.37,-0.66,-0.47,1.01,0.57,2.79,4.50,2.43,4.01,4.79,5.16,4.46,4.22,1.93,-0.08,0.04,-0.57,2 -0.41,-0.28,2.12,1.93,-0.21,-0.13,0.35,0.26,1.08,2.75,1.51,2.55,2.48,5.01,5.11,4.95,3.18,0.98,1.16,1.89,-1.09,0 -0.22,-1.72,-0.77,-0.74,-1.23,1.01,0.80,1.72,1.16,3.13,3.81,4.17,2.52,1.90,4.48,4.08,-0.19,0.71,1.74,0.54,0.11,2 -1.40,0.19,-0.37,0.11,0.38,0.50,-0.32,2.18,1.87,4.08,6.33,4.48,3.64,2.12,2.31,1.74,0.63,1.78,1.81,0.74,0.08,2 -0.15,0.44,0.69,0.96,1.19,3.15,4.26,3.12,3.87,3.57,4.27,4.14,1.99,1.15,-0.10,-0.28,-1.37,1.35,0.07,0.88,0.11,1 --0.00,-0.90,0.39,-1.75,1.74,1.34,1.77,4.49,4.00,4.69,5.92,4.10,4.23,2.45,1.49,0.32,1.70,-0.89,2.32,-0.57,0.42,1 -0.59,0.54,0.98,1.77,3.97,5.13,5.54,3.80,6.08,3.30,3.02,2.16,-0.29,-0.66,-0.55,-0.01,-0.84,0.80,0.35,1.13,-0.72,1 -1.05,1.28,1.35,3.65,4.06,5.04,5.72,4.01,3.19,3.47,2.81,-0.77,-1.02,-0.79,-0.36,-0.39,0.98,1.53,0.09,-0.50,-0.40,0 -1.41,2.11,-0.12,1.33,-0.56,2.10,2.06,2.97,2.62,5.24,6.93,5.56,3.55,2.14,3.08,2.54,1.20,0.55,1.61,-0.42,-0.18,1 --0.48,0.73,2.52,1.46,3.52,3.59,4.93,4.73,6.07,2.31,3.75,1.66,1.89,-0.35,0.08,0.76,-1.54,1.39,2.76,-0.96,0.39,1 -0.82,0.21,-1.08,-0.92,1.65,0.50,1.33,0.46,1.11,2.35,3.91,3.48,2.94,3.98,2.76,2.82,2.88,1.44,0.34,-0.35,-0.68,2 -0.23,-1.21,1.10,1.02,-0.44,0.42,2.02,2.45,4.75,5.20,5.19,5.17,4.17,3.56,2.09,-0.03,0.06,-0.80,-0.44,-0.18,1.34,1 --0.38,0.64,1.25,2.27,4.01,5.17,5.77,4.93,2.65,2.19,2.11,1.25,0.57,-0.27,1.36,0.12,-1.04,2.23,0.03,-2.17,-1.50,1 --0.76,-1.52,0.23,-0.61,1.11,1.95,0.25,1.04,0.87,1.74,2.99,3.83,4.00,3.31,5.82,3.27,3.26,2.92,2.90,1.03,-0.02,2 -0.76,0.78,0.68,1.14,1.06,0.03,2.23,3.35,2.46,4.21,7.01,6.58,1.83,2.79,2.53,1.66,0.95,-1.17,-0.72,-0.11,-0.69,1 -0.76,1.28,0.86,0.46,2.74,3.17,6.28,3.57,4.22,3.22,1.31,0.62,0.83,0.94,0.74,-0.22,0.11,-0.05,-0.16,-0.46,-0.68,1 --0.26,-1.05,0.75,1.56,3.44,4.01,4.57,4.11,4.20,2.71,3.37,1.05,1.41,0.60,0.62,1.79,0.57,0.68,-0.22,-0.36,1.60,1 --0.08,0.91,0.48,1.63,-0.16,0.13,1.38,3.88,3.27,5.64,7.24,4.93,4.80,4.01,1.62,2.04,0.82,-0.94,-0.42,-0.08,-0.74,1 -0.05,0.83,1.60,2.95,2.70,5.11,7.45,3.56,3.54,3.10,1.96,1.34,1.55,0.63,0.65,1.75,-1.33,1.44,-0.64,-0.92,-0.92,0 -0.25,0.92,-1.09,2.74,1.10,1.63,2.67,0.27,1.12,1.50,2.94,1.76,1.52,2.56,4.73,4.10,1.56,2.94,0.45,-0.29,0.33,0 -1.36,0.41,0.40,-0.67,-0.65,1.77,2.96,2.50,2.39,5.40,4.27,4.90,3.55,4.24,3.29,0.66,-0.81,-0.93,2.15,-0.51,1.35,2 --0.57,1.08,-1.20,-0.44,-1.48,1.37,0.45,2.27,1.22,2.30,2.36,3.41,4.66,4.73,3.59,2.97,2.48,3.39,1.04,-0.09,-0.41,2 --0.22,0.67,0.37,2.75,2.86,4.04,4.91,5.52,4.69,3.77,1.69,3.07,2.02,0.25,0.96,0.25,-0.25,-0.08,1.05,-1.85,-0.14,1 -1.53,0.60,-0.05,1.21,2.32,5.01,5.26,5.88,4.75,3.65,3.18,-0.18,0.78,1.60,2.50,0.57,1.02,0.88,0.24,-0.01,-0.02,1 --1.45,1.45,1.17,1.40,2.64,3.22,3.98,2.79,1.38,2.84,1.66,0.70,-0.55,1.50,0.84,-0.65,2.95,0.32,0.50,0.39,-1.44,0 -0.71,1.10,0.73,-0.96,1.55,0.18,0.78,2.09,1.89,2.78,3.26,4.85,3.13,3.14,2.32,4.52,1.40,1.91,1.64,1.24,-1.07,2 --0.51,-1.33,0.44,1.29,0.90,3.28,4.44,2.28,4.09,3.37,4.82,2.03,0.51,1.39,2.33,2.06,0.40,-2.40,1.47,0.54,0.05,1 --1.19,2.52,1.03,2.86,4.09,3.12,5.43,4.26,3.36,1.44,1.44,2.63,0.02,1.61,0.75,1.73,-0.18,-0.91,-0.68,0.89,-0.46,0 -0.59,0.89,2.19,2.91,3.55,1.99,4.39,2.40,3.04,2.21,1.67,4.91,1.12,1.50,3.47,1.45,1.52,1.03,0.63,-0.07,-1.63,0 -0.96,-0.53,-1.00,-0.79,-0.05,2.83,0.60,2.45,4.34,4.43,6.27,3.55,3.98,3.00,2.65,-0.97,-1.77,-2.39,0.99,1.16,-0.38,2 --0.49,1.48,0.33,0.90,5.13,4.58,6.93,3.87,2.86,3.28,1.55,1.19,0.11,-0.48,-0.62,1.00,1.31,1.85,-0.13,1.15,-0.88,0 --1.14,0.35,0.52,-0.68,0.72,2.40,1.84,3.10,3.29,2.56,3.60,5.89,3.79,3.90,3.38,1.05,-1.52,1.16,-0.66,0.47,0.99,2 -0.23,2.04,1.06,0.20,3.55,5.37,3.69,3.80,4.87,4.15,4.19,1.66,1.54,1.69,1.38,0.02,-0.74,1.22,-1.76,1.20,0.08,1 -1.64,0.52,0.09,0.27,0.91,2.17,2.45,2.26,3.17,3.33,8.53,3.94,4.29,2.85,1.88,1.04,-1.72,0.25,-0.31,-0.65,2.29,1 -0.83,2.20,2.68,1.90,3.35,5.42,5.09,4.04,5.14,3.71,4.31,3.10,-0.13,-0.30,-1.11,0.08,-0.18,-0.22,0.27,1.42,-0.91,0 -0.43,1.15,0.92,0.04,-1.82,1.09,3.88,5.13,2.73,3.59,7.91,3.72,3.14,2.72,2.15,2.01,0.40,-0.30,0.64,0.48,-0.40,1 --0.41,-0.20,0.80,0.73,0.04,-0.14,0.46,0.42,4.73,3.96,5.58,4.74,3.57,3.00,4.49,1.65,2.07,-0.31,1.07,1.70,0.34,2 -0.16,-0.83,-0.11,2.51,3.70,6.17,5.12,3.70,2.56,1.91,1.92,2.71,-0.27,2.52,3.08,1.33,2.20,1.08,0.51,0.32,-1.08,0 --0.80,0.14,0.76,-1.02,-1.29,1.11,-0.08,2.52,1.69,2.90,5.24,4.30,3.13,3.92,4.41,4.90,2.25,0.98,1.86,-0.07,-0.35,2 -0.91,-0.83,-0.89,0.04,1.21,0.10,0.53,2.23,1.59,4.12,2.99,4.88,5.05,2.25,4.58,2.18,1.66,1.29,0.84,0.35,0.19,2 -1.11,-1.39,1.99,0.18,-0.79,1.61,1.38,1.47,3.55,3.33,2.42,5.06,3.53,3.66,4.55,1.37,1.70,1.12,0.58,-0.48,-2.55,2 -2.09,0.06,1.22,1.46,0.62,0.75,2.74,2.78,4.91,4.54,4.52,3.69,4.00,2.14,0.76,0.80,0.28,1.25,-0.31,-0.57,0.54,1 --2.21,0.01,0.46,-0.41,-0.52,1.39,2.62,2.74,4.98,3.20,4.13,4.16,2.18,4.23,1.95,1.92,0.19,-1.04,0.81,-0.00,-0.65,1 -0.71,1.07,0.32,-1.66,1.35,2.84,4.16,3.94,3.02,5.17,4.77,5.24,3.91,2.77,3.04,0.82,-0.34,1.15,-0.38,0.92,1.13,1 -1.24,-0.71,0.63,1.96,5.15,4.72,6.15,2.02,3.35,2.59,2.24,1.29,1.64,-0.70,-1.61,0.73,-0.40,-1.65,-0.19,0.23,-0.96,0 -0.60,-1.25,1.51,0.32,2.13,1.22,1.45,2.54,1.57,2.83,1.04,1.65,2.86,3.40,3.70,4.15,2.61,3.69,1.14,0.43,0.66,0 --0.28,-0.09,1.48,0.05,-0.81,1.54,1.99,1.62,0.98,4.07,2.68,3.41,4.20,3.28,2.32,2.52,0.47,0.96,2.48,0.93,-1.62,2 --0.60,0.94,1.61,3.71,4.99,4.31,5.16,6.82,3.64,1.95,2.02,1.63,-0.15,2.30,-0.14,1.76,1.23,1.33,-0.41,-0.67,-1.51,0 --0.62,0.48,0.57,-0.53,2.20,3.52,2.13,1.20,2.91,1.59,-0.17,1.43,2.07,2.82,3.61,2.20,3.15,2.16,1.55,-0.33,-1.80,0 -1.61,-0.07,-1.05,-2.00,1.80,-2.16,2.19,0.07,-1.18,1.34,1.14,3.86,3.94,4.01,5.74,3.34,4.00,3.43,1.66,-0.47,-0.11,2 --2.36,0.61,0.65,0.73,1.65,1.99,1.53,2.00,2.94,5.31,5.47,5.56,2.31,3.29,4.72,1.75,-0.30,0.54,-0.24,0.83,1.18,2 --0.07,1.33,1.14,0.30,1.12,2.85,0.89,2.29,3.50,5.69,5.57,5.87,3.12,0.92,1.26,2.27,1.16,-0.90,1.06,-0.28,1.15,1 -1.64,-0.21,0.49,0.91,0.18,0.96,1.98,2.11,3.56,6.17,6.32,4.48,3.84,2.56,0.14,0.51,0.24,-0.85,-0.71,0.51,-1.29,1 --2.09,-0.89,-0.36,3.38,1.71,2.40,4.24,4.02,3.80,3.20,2.37,2.19,0.87,1.36,1.88,-0.84,-0.40,0.17,0.11,-0.45,-0.11,1 --0.00,1.71,1.14,0.98,-0.46,-0.66,-0.15,-0.46,2.39,0.78,4.77,4.25,4.19,5.88,4.71,2.41,2.46,2.18,0.89,0.07,0.11,2 -0.07,1.57,1.25,0.19,0.94,0.08,2.75,3.86,4.41,4.12,6.17,3.63,4.45,2.51,4.03,1.73,2.13,0.17,-0.33,-0.49,-0.94,2 --0.90,0.28,0.22,2.72,4.61,3.49,5.25,6.15,2.07,2.83,3.28,0.69,0.20,0.93,2.12,1.38,-1.29,0.43,-0.02,-0.92,-0.66,0 -1.27,1.37,1.04,3.01,3.20,4.15,6.80,5.18,3.83,2.58,2.60,0.79,-1.62,0.67,-0.78,-1.95,-1.20,0.29,0.06,0.59,-0.29,0 -1.26,1.10,0.95,2.84,2.68,3.31,5.25,5.57,4.05,1.87,3.32,0.17,-1.06,0.38,1.22,0.18,0.88,1.15,-1.11,-1.20,-0.20,1 -0.92,-0.70,1.26,1.21,4.14,4.12,4.69,3.36,0.91,0.32,3.78,2.30,1.77,2.22,3.60,3.04,3.13,2.55,0.55,0.20,2.28,0 -0.73,-1.64,-0.20,-0.57,0.40,-0.36,-0.22,2.18,1.39,0.85,4.41,4.50,4.36,3.92,4.16,3.74,0.48,1.14,0.56,-1.32,0.57,2 --0.41,1.64,1.11,3.79,4.43,5.54,5.99,4.99,3.73,3.56,0.82,0.53,-0.59,-1.23,-0.47,0.82,-1.65,0.51,-1.39,-1.10,-0.01,1 -0.75,2.11,-1.04,1.30,1.25,0.96,-1.26,-0.27,0.80,2.60,2.58,3.84,4.13,3.80,7.07,2.70,2.47,1.62,0.48,0.63,0.68,2 --0.70,-1.33,-0.27,-0.28,1.53,0.88,1.31,2.03,3.52,3.64,3.96,5.81,3.35,4.13,3.39,1.99,1.15,-0.96,2.21,-0.22,0.12,2 -1.70,0.49,1.27,0.55,0.68,-0.56,2.18,2.50,2.45,6.06,4.76,6.41,3.86,4.10,3.72,3.65,0.69,-0.51,0.07,1.62,-2.56,2 -0.14,0.95,-0.01,-1.69,0.15,2.65,2.07,2.63,4.30,5.16,6.15,3.40,4.47,2.48,1.41,0.59,2.35,1.72,1.60,-0.79,-0.64,2 --0.68,0.92,3.05,3.37,3.12,3.17,3.72,3.81,3.50,5.23,3.05,0.75,0.15,2.02,3.06,0.17,0.08,1.65,-1.36,1.48,-1.39,1 --1.29,0.88,1.10,2.01,1.19,4.59,4.75,2.94,1.21,5.32,4.21,2.17,0.58,1.55,-0.12,1.16,-0.98,2.39,0.11,-0.38,-0.73,1 -1.33,2.34,1.52,2.40,0.87,2.99,3.54,4.14,0.90,2.07,0.94,0.50,1.56,0.67,3.01,2.88,1.94,1.77,1.20,1.36,-0.06,0 --0.17,-1.21,-0.73,0.19,-1.44,1.39,3.45,2.30,1.93,4.80,5.41,6.52,5.09,2.61,3.83,2.79,2.73,1.46,0.44,1.32,0.31,2 -0.33,-0.66,0.14,0.11,1.47,0.09,2.85,4.41,5.79,5.04,5.90,5.65,2.18,2.38,2.02,1.68,0.02,-0.31,0.86,1.09,2.09,1 --0.19,0.47,2.08,1.75,1.74,4.38,6.76,4.45,3.59,3.26,3.72,2.89,1.17,3.96,0.17,0.92,-0.03,-0.52,-0.08,0.04,0.82,1 --0.90,-0.03,-0.09,2.93,3.03,4.39,4.91,2.33,3.98,2.69,1.27,1.83,1.82,1.97,1.30,0.92,-0.04,3.37,1.47,-0.31,-0.40,0 -1.14,0.21,2.35,1.65,1.61,3.44,3.74,4.22,3.55,5.44,5.91,3.02,2.66,1.54,0.70,-0.86,-0.30,0.90,-0.03,-0.39,2.39,1 -1.17,0.21,2.88,3.78,3.87,1.55,5.10,1.34,2.61,1.81,2.65,-0.16,2.05,2.45,2.37,2.70,3.40,2.53,1.36,1.01,1.13,0 --2.29,2.03,0.95,1.22,2.23,2.95,4.82,3.91,4.14,3.40,3.01,3.69,2.77,1.04,1.31,-0.75,0.27,-0.44,-0.35,0.13,0.32,1 --0.71,-1.62,-0.05,1.28,1.45,-0.54,-0.17,1.60,-0.11,1.16,0.96,5.03,3.74,4.41,4.55,5.12,4.66,1.30,-0.52,2.07,0.51,0 --0.29,0.09,1.43,4.00,3.23,2.43,5.23,5.68,2.09,3.38,3.20,-0.50,0.91,0.75,1.22,-0.26,-1.41,-0.69,-0.48,1.24,0.13,1 -0.34,-0.11,2.56,1.88,3.70,2.74,4.89,4.50,3.38,1.69,2.01,3.14,0.79,1.74,1.48,2.79,0.04,0.83,1.97,-0.73,-1.38,0 --1.58,0.27,1.80,1.14,0.57,-1.02,0.77,0.48,2.93,1.23,4.56,3.17,3.03,3.67,5.27,3.26,2.28,2.29,2.16,2.25,0.03,2 --0.24,3.21,0.53,-0.16,0.23,2.44,3.46,4.04,5.11,5.82,5.53,5.61,5.14,3.57,1.99,0.93,0.24,-1.60,0.15,-0.05,-0.22,1 --0.02,-0.87,0.25,0.32,0.76,0.99,2.82,3.01,3.34,3.49,6.67,6.46,4.63,3.21,2.97,2.30,1.66,-1.47,1.51,1.09,-3.22,2 -2.39,0.84,-0.53,-0.34,0.01,2.47,2.98,2.38,0.92,2.37,2.59,0.13,1.74,2.09,2.65,2.13,1.34,2.28,-0.01,0.74,1.51,0 -0.63,0.64,0.41,1.42,2.88,3.17,4.23,2.97,3.03,4.82,4.71,2.69,1.25,1.97,0.88,-1.72,1.20,0.43,2.09,-0.11,0.37,1 --0.51,0.24,-0.12,1.31,-0.47,1.74,1.06,1.35,4.56,4.19,6.15,4.84,3.86,4.20,1.60,0.81,2.48,0.67,-0.76,0.15,0.20,2 --1.70,-0.05,1.49,1.13,-0.59,0.32,2.01,1.72,1.13,2.42,2.52,3.30,3.61,3.60,4.16,3.34,4.08,3.15,1.90,-0.99,-0.54,0 -0.90,-0.07,0.56,-0.93,-0.76,0.41,-0.31,0.65,2.94,3.92,5.41,4.98,4.07,3.79,3.06,2.44,1.34,2.23,0.83,0.91,2.25,2 -0.15,-0.45,1.42,3.37,2.94,4.41,4.75,4.12,3.27,3.75,3.09,1.36,-0.17,0.24,1.34,0.88,0.64,0.98,2.94,-1.24,-0.74,0 --0.96,1.63,1.63,1.58,-0.73,0.94,1.00,0.63,1.95,2.37,1.46,3.20,3.32,2.94,3.78,4.62,1.67,2.05,2.26,1.49,-0.94,0 --1.45,1.46,-1.16,1.56,-1.06,-0.92,0.76,1.16,1.27,0.85,2.40,4.38,3.47,3.62,4.83,6.44,3.77,1.83,1.88,0.88,-0.01,2 -0.54,0.61,2.37,3.76,1.74,3.78,4.32,3.92,3.13,1.88,0.68,0.46,-0.17,2.01,1.28,1.93,2.08,-1.35,0.68,0.30,-0.62,0 -0.99,-1.25,0.75,0.27,-1.23,-0.11,-1.14,-0.66,0.56,-0.42,2.40,4.48,4.53,5.49,3.75,3.45,1.72,2.36,-0.04,1.14,0.29,2 --1.50,0.96,-0.35,1.64,2.74,1.76,5.07,3.58,4.61,7.08,4.28,3.06,4.54,0.60,-0.12,-1.04,0.50,1.31,1.34,1.62,0.50,1 --0.71,0.60,-0.83,-1.12,1.55,2.05,2.81,1.97,0.57,0.01,3.36,3.86,4.58,3.25,5.63,4.93,3.25,2.00,0.97,0.42,-0.38,0 --0.19,0.02,0.50,0.43,0.52,2.60,0.73,0.97,0.35,2.85,2.91,1.16,1.18,1.81,1.30,1.90,2.10,2.15,1.15,0.61,0.25,0 --1.06,1.33,1.34,2.94,2.80,4.06,5.58,5.05,5.41,3.90,1.65,1.23,1.59,-1.11,1.04,0.96,0.01,0.62,-0.92,-1.95,-0.93,1 --0.13,-0.72,-0.21,0.71,0.77,2.29,1.38,-1.16,0.66,3.50,2.51,5.15,5.78,3.90,7.16,4.84,3.93,2.29,-0.99,0.51,0.10,2 --0.06,1.40,0.64,1.50,1.73,2.73,2.34,1.99,2.47,0.50,1.61,2.08,3.22,2.79,4.66,3.29,2.69,1.77,1.04,0.19,0.28,0 -1.84,1.13,0.72,2.06,1.25,1.18,2.66,3.62,2.74,3.50,5.72,4.73,2.79,2.82,0.78,3.16,-1.99,1.80,1.76,-1.25,0.89,1 --1.58,0.67,-0.40,-2.10,-0.92,0.34,-1.36,0.39,-0.70,1.08,0.37,2.48,4.33,4.93,5.60,5.98,4.57,1.01,3.05,0.37,1.31,0 --1.83,-0.54,-0.71,-2.41,0.14,-1.15,1.56,2.63,2.98,1.34,5.08,3.10,4.69,5.24,5.54,3.53,1.64,0.93,0.25,1.29,0.64,2 -1.61,0.80,-0.05,0.10,-0.32,1.24,0.49,0.68,0.35,1.87,3.25,4.39,3.39,5.07,4.17,3.83,2.27,1.35,0.81,1.33,0.83,2 -2.18,1.13,2.90,0.87,-2.38,1.00,1.77,1.30,4.90,2.97,6.11,6.25,2.66,3.64,1.78,1.51,-1.04,0.15,1.38,-0.41,-1.47,2 --1.52,-0.72,0.60,1.52,0.92,2.16,0.32,1.77,4.56,3.74,2.20,6.13,3.80,4.48,3.00,2.66,1.16,1.43,1.00,2.07,1.70,2 --0.08,0.32,0.70,1.23,0.31,1.81,1.94,0.85,1.33,2.51,1.48,3.88,3.50,2.11,5.52,3.44,3.73,1.93,0.47,1.19,1.12,0 -1.07,0.71,-0.18,-0.80,0.27,0.11,0.57,1.76,0.25,-0.23,2.81,3.06,3.34,3.52,5.09,5.10,3.30,2.15,1.83,1.06,-0.25,0 -0.89,0.07,-1.14,-0.27,1.33,2.41,1.76,0.98,0.86,1.91,1.27,4.27,2.72,4.12,3.98,4.40,2.37,2.25,2.60,2.77,1.44,0 -2.09,1.51,0.96,-0.66,-0.70,0.06,1.60,-1.20,1.65,1.64,2.65,4.34,4.30,4.42,5.65,4.97,3.32,1.59,3.08,0.45,-1.57,2 -0.67,-0.27,0.88,1.34,0.57,1.04,1.55,0.91,-0.78,1.53,1.66,2.39,4.01,4.87,4.29,1.98,2.10,2.35,1.28,1.65,0.70,2 --0.55,0.05,-0.53,2.04,1.13,1.85,2.50,0.69,-0.53,3.19,2.16,3.51,3.76,3.64,5.05,3.44,1.70,1.54,3.44,1.71,-0.80,0 -0.76,-0.12,-1.39,2.35,1.03,2.17,3.39,3.30,0.33,1.22,1.60,3.10,3.91,3.38,4.44,0.13,3.31,0.93,1.55,0.73,-0.07,0 -0.51,-0.79,-2.07,-0.30,-0.86,0.42,0.54,0.60,1.18,2.03,3.29,3.76,3.92,2.99,4.51,3.50,1.79,3.68,1.14,2.31,-1.28,2 -1.14,0.54,-0.33,1.11,0.66,-0.19,1.80,0.99,1.19,1.36,1.84,3.38,6.57,5.50,4.82,4.06,4.64,1.66,1.60,0.74,0.98,0 -0.24,0.51,1.90,-0.93,-0.18,1.92,2.08,0.32,1.86,0.03,3.11,3.08,3.67,4.37,3.32,4.46,5.46,4.76,2.65,-0.98,0.67,0 --1.80,-0.26,0.28,0.98,-0.95,0.24,-0.74,1.69,0.71,1.20,1.19,3.96,2.83,4.21,5.08,1.68,3.49,2.08,3.08,0.21,-0.84,2 -0.23,1.20,2.24,2.01,2.97,4.46,3.86,3.32,2.11,3.12,1.33,0.06,1.48,2.67,2.79,-0.19,0.71,1.65,1.57,2.06,0.70,0 -0.44,1.93,0.16,1.05,0.46,4.28,3.59,3.67,3.85,4.23,4.91,2.93,0.68,3.18,0.52,2.64,1.92,-2.42,-0.55,0.36,0.48,1 --0.15,1.76,1.31,2.83,2.58,3.42,5.21,4.16,4.90,3.14,4.38,2.19,1.44,0.20,2.50,-1.00,-0.63,1.91,0.78,-0.64,0.06,1 -0.44,1.93,1.51,1.63,2.20,2.13,3.47,2.63,1.81,2.16,0.77,1.93,1.16,1.12,3.60,0.97,-1.08,0.62,2.17,1.15,0.86,0 -0.07,1.05,1.54,2.53,2.94,3.34,4.29,4.38,5.70,0.29,1.10,1.63,0.93,1.99,1.15,1.31,1.65,1.24,-0.15,-0.66,-0.05,0 --0.52,2.73,0.79,2.65,1.31,5.21,4.52,5.03,3.56,2.57,1.46,1.37,1.80,0.29,2.87,0.65,0.92,0.80,0.30,-0.58,0.46,0 --1.08,-0.16,-0.91,-0.53,0.06,0.60,-0.14,-0.20,0.45,0.52,2.89,2.59,4.87,5.43,5.81,4.78,5.95,3.08,1.98,1.11,-1.22,2 --0.83,1.44,1.65,1.35,3.37,5.15,5.99,5.08,3.75,2.39,2.62,1.25,-0.29,1.88,-0.15,1.73,1.91,-0.57,1.40,-0.12,0.52,1 -0.43,-0.49,0.57,1.12,2.49,2.72,1.42,2.84,1.23,1.74,0.72,1.94,1.85,1.13,3.35,1.08,-0.40,1.64,-0.17,1.71,0.51,0 --0.25,1.02,0.20,1.02,2.26,1.25,3.63,3.14,1.94,1.47,2.25,1.47,0.80,1.12,1.05,-0.59,1.98,0.25,0.64,-0.51,-0.61,0 --0.39,2.18,1.67,1.14,-0.44,3.75,2.61,3.94,3.16,4.14,6.01,2.23,2.54,0.69,0.05,1.45,1.62,0.38,1.13,-0.74,0.52,1 --0.41,-0.86,3.42,3.08,1.83,4.69,3.18,4.82,2.62,2.61,1.57,1.53,0.85,1.46,-0.40,1.78,0.07,0.03,-0.27,1.09,-0.25,0 --1.96,-0.96,1.25,0.72,1.05,-0.17,-0.16,3.13,4.21,5.80,5.94,4.36,2.69,0.92,2.94,1.55,0.50,-0.30,-0.84,0.24,0.23,1 --0.52,0.23,-0.27,0.89,-0.08,-0.41,2.25,2.18,4.95,3.86,5.79,5.34,2.85,2.57,0.78,3.66,0.56,-0.30,-0.53,-0.22,0.89,1 -0.49,-0.45,2.89,-1.74,1.29,3.30,3.36,4.07,2.67,1.44,2.58,2.62,3.23,2.09,2.81,3.82,2.17,1.45,0.41,1.37,-0.98,0 --1.50,0.02,-0.21,1.07,2.71,3.41,1.80,1.29,0.87,0.76,1.87,1.97,1.95,3.80,1.14,2.93,1.81,1.61,1.36,1.89,0.10,0 --1.31,-0.15,0.28,0.20,0.31,2.59,3.24,4.04,4.96,5.71,6.31,3.21,2.27,2.33,3.72,0.70,1.53,-1.04,0.53,-1.34,-0.57,1 --0.43,0.23,0.30,-0.74,-1.80,2.30,0.32,1.85,1.52,4.33,3.64,3.46,3.12,3.70,5.29,2.76,2.30,1.14,2.58,1.06,-0.21,2 --0.20,0.49,-0.12,-0.75,-0.03,1.88,2.83,3.46,5.21,4.12,3.78,4.30,3.67,3.52,0.06,2.25,0.03,-1.00,0.88,0.05,-0.50,1 -1.14,1.16,0.93,2.17,2.86,0.23,5.23,3.02,5.00,4.24,4.75,3.63,2.19,1.07,2.55,-0.21,-1.22,1.07,0.48,1.08,0.55,1 --0.38,2.03,-0.68,1.89,0.70,1.97,2.10,4.35,3.70,5.45,6.40,3.20,3.11,1.71,-1.87,1.55,-0.81,-1.26,0.49,0.65,0.63,1 -0.41,0.45,1.27,1.67,2.70,5.54,5.21,4.25,2.80,3.01,-0.28,2.60,1.10,0.86,1.39,3.67,1.53,0.87,2.65,1.54,0.99,0 -0.75,0.41,-0.42,1.23,1.13,0.85,3.70,3.70,3.76,3.62,4.13,3.69,3.24,3.52,1.34,-0.43,-0.67,-0.53,-0.97,-0.29,-0.50,1 --0.44,3.23,0.19,0.47,0.34,3.02,3.48,4.97,4.28,5.31,4.31,2.89,2.56,2.06,2.97,1.70,0.54,0.77,1.66,-0.43,1.05,1 --1.84,0.53,-0.62,-2.62,0.45,0.67,1.24,5.26,5.53,4.09,6.11,4.48,4.83,3.20,4.30,2.64,-0.09,-1.31,1.47,1.32,-0.59,2 -0.32,-0.61,-0.96,0.60,2.51,1.87,1.40,1.50,0.96,3.04,1.78,2.02,1.34,1.70,2.95,2.80,2.95,2.86,2.47,1.33,0.94,0 -2.49,0.33,-1.34,0.34,2.18,1.68,0.85,1.24,2.64,4.58,4.04,4.20,2.57,3.63,2.44,2.40,1.83,1.10,-1.13,1.35,2.54,2 -0.51,1.19,-0.74,1.51,1.12,1.52,1.10,2.09,-0.44,0.97,-0.86,4.08,4.92,4.27,6.54,4.62,3.48,3.79,2.53,3.07,-0.14,0 -2.04,-0.05,0.91,-0.54,0.46,1.27,0.48,2.91,1.48,2.65,6.13,4.22,2.47,3.01,3.98,2.78,4.05,1.79,0.32,-0.22,-1.61,2 --1.49,0.20,1.85,-1.33,2.16,2.41,3.30,3.88,4.46,4.37,3.29,1.71,1.40,2.02,1.06,0.55,-1.04,-0.51,-0.57,-0.52,1.30,1 -0.56,-0.92,1.66,-0.66,0.18,0.95,2.07,4.06,4.76,4.57,4.07,2.64,3.14,2.59,2.88,0.33,-1.10,0.36,-0.10,-0.13,-1.53,1 -0.87,0.32,0.27,0.68,1.29,1.17,3.07,2.10,4.41,5.42,6.07,4.39,3.34,2.93,1.35,1.47,0.86,0.34,-0.61,-1.12,-1.11,1 -1.59,0.48,-0.28,-0.05,0.27,-0.22,2.31,2.11,3.73,4.17,6.32,4.05,2.65,1.72,3.50,1.89,1.81,-0.18,-1.03,0.41,-0.67,2 -0.20,-1.85,0.40,-0.04,-0.18,0.97,-1.06,0.39,-1.48,0.51,0.73,3.11,4.67,5.12,5.57,5.54,4.12,1.88,1.12,-0.14,-1.37,2 -0.67,0.43,-0.69,0.14,2.20,1.78,4.04,2.89,3.86,3.56,3.49,4.12,3.42,0.82,0.11,-0.38,-0.13,0.11,-0.50,0.63,0.79,1 -1.65,1.58,1.83,1.80,3.59,2.79,3.52,4.77,5.15,5.14,3.19,2.15,0.29,2.28,2.14,-0.24,-0.72,0.13,-0.39,-0.06,-1.18,1 --1.01,1.57,3.81,-1.49,-0.82,2.12,-0.53,1.18,-0.32,0.59,2.75,3.26,2.41,2.58,7.25,4.64,2.25,1.40,1.55,0.48,-0.12,2 --0.89,-0.91,1.12,-0.89,1.54,0.43,1.37,0.32,1.98,2.11,4.11,3.05,4.21,3.73,3.40,4.75,2.18,2.24,-0.22,0.48,-0.12,2 -1.42,0.10,0.50,1.07,0.71,1.78,3.52,4.02,4.75,5.34,5.39,4.58,4.97,2.86,2.46,1.60,1.06,1.17,-0.15,-0.02,-0.45,1 -1.67,1.09,0.78,0.08,2.26,1.35,2.08,1.30,1.27,0.61,1.31,3.51,0.91,2.51,2.80,2.47,3.17,2.68,2.90,0.74,1.59,0 -0.06,1.44,4.65,1.69,3.87,2.10,5.52,4.08,4.80,2.94,1.96,0.75,2.05,0.46,2.16,1.99,-1.72,0.54,1.26,-0.08,1.62,0 --0.27,0.95,-0.69,1.23,2.35,0.45,-0.51,1.82,1.15,0.12,1.60,4.29,3.51,6.40,6.99,4.12,4.64,2.82,0.66,1.63,-1.33,0 -1.75,1.03,0.95,1.73,2.91,4.40,4.94,2.76,3.94,5.44,2.67,1.11,1.00,2.48,-0.04,1.91,0.05,0.10,0.56,-0.31,-0.56,1 --0.87,1.83,0.09,0.48,3.37,2.43,3.83,4.31,4.31,3.24,4.53,4.84,3.96,3.01,0.36,1.29,0.26,1.35,-0.96,1.23,1.51,1 --0.57,-1.84,-1.41,0.49,-1.43,1.52,1.59,3.13,5.01,5.87,5.29,5.96,6.00,1.53,2.37,0.89,0.50,-0.33,-0.50,-0.40,-0.30,2 --1.36,-0.84,-0.79,0.24,3.67,1.19,0.55,0.57,1.82,3.05,4.39,4.91,1.88,4.03,4.37,3.46,2.43,1.45,0.89,0.66,-0.40,2 --1.14,1.64,1.68,2.31,2.78,2.87,3.93,4.10,4.21,4.39,3.44,3.31,0.52,1.72,1.58,1.15,0.23,0.95,0.18,-1.93,0.02,1 -0.71,-0.13,-0.02,-0.96,0.68,-1.06,0.40,0.71,1.27,1.59,1.15,3.34,4.09,3.53,4.98,4.85,4.38,2.69,0.53,1.49,-2.34,0 --0.03,2.20,1.23,1.65,3.98,3.81,5.32,3.50,3.81,2.53,1.91,3.71,0.45,1.43,0.84,1.05,2.04,0.26,0.46,0.30,0.04,0 --0.63,2.96,1.38,3.31,4.93,5.22,4.39,4.28,4.39,2.03,0.58,0.48,-0.40,-0.88,0.08,-0.02,0.70,-1.07,-1.43,-0.08,1.07,0 -0.34,-0.17,0.96,1.67,0.97,1.66,3.06,1.49,3.36,5.45,5.41,4.50,4.41,1.07,0.78,0.30,0.70,0.10,-2.56,-0.29,0.77,1 --0.04,1.24,0.11,-0.51,0.80,0.58,-0.49,-1.13,-0.46,1.42,0.80,2.54,3.90,3.68,5.06,3.95,4.75,2.42,0.54,-0.28,-1.49,2 --1.15,-1.33,0.00,0.07,1.69,1.30,1.70,0.86,2.27,2.10,3.37,4.48,3.70,3.06,4.67,3.32,2.84,1.78,1.62,0.60,0.06,0 --1.71,0.76,0.37,-1.41,-0.27,0.45,1.16,2.55,0.71,2.49,3.07,4.08,2.80,2.51,4.02,3.73,1.39,2.58,1.60,0.75,-0.36,2 --0.17,0.11,1.68,0.54,0.62,1.80,3.26,3.66,5.39,2.94,4.94,3.47,2.26,2.80,2.20,0.52,-1.39,0.64,-1.03,0.69,0.10,1 --1.80,0.11,-1.22,1.24,1.00,-0.34,1.22,-0.72,-1.42,1.70,2.28,3.33,4.75,6.46,7.96,6.15,5.31,1.50,2.20,2.02,0.48,0 --0.69,0.27,2.46,0.17,-0.11,2.64,4.93,2.66,2.87,3.47,5.43,3.89,1.58,2.06,2.10,0.95,1.37,-0.38,0.90,-1.04,0.28,1 -1.35,-0.47,-1.42,-0.81,-0.23,-0.02,0.01,0.79,3.27,4.10,2.58,4.52,4.81,2.08,1.56,2.46,1.46,1.18,2.08,-0.89,0.53,2 -0.04,1.09,-0.31,-0.38,-0.57,-1.55,2.66,2.19,4.00,3.63,4.06,3.42,4.57,3.21,1.34,2.48,-0.23,0.63,0.26,0.28,-1.10,2 -1.05,0.56,0.69,1.52,2.91,1.82,1.62,3.53,0.69,1.94,1.34,3.67,1.56,4.12,4.49,2.85,2.17,2.88,1.54,-0.29,-0.46,0 -1.46,0.17,1.03,0.19,0.93,0.55,2.53,2.21,2.09,3.21,1.85,0.57,2.32,3.01,5.13,1.52,0.84,1.08,1.30,0.31,-0.47,0 -0.62,-0.62,0.18,1.09,-0.38,1.16,4.72,3.87,3.78,3.74,6.71,4.43,2.92,5.29,1.56,0.43,2.04,0.45,0.45,0.62,-1.58,1 --0.63,0.38,-2.03,-1.67,2.30,0.99,3.95,2.01,3.60,5.61,4.96,5.81,4.20,2.73,1.50,1.54,-0.44,0.06,0.58,-1.01,0.73,1 --1.55,0.98,0.36,0.59,0.72,0.93,0.78,2.64,3.18,4.80,5.26,5.21,4.25,3.94,2.84,2.69,0.17,0.99,1.71,0.57,0.80,2 --0.16,-0.79,0.07,0.01,0.26,1.01,1.24,0.98,-0.52,3.06,0.30,2.83,4.47,4.64,5.95,4.55,2.38,1.86,3.43,-0.41,-0.31,0 --0.20,0.30,-0.59,0.68,0.77,0.76,1.54,0.45,2.63,0.93,0.16,2.21,1.65,3.93,5.39,3.02,2.48,4.06,2.19,0.68,0.85,0 -2.27,0.61,-1.05,-2.19,1.67,1.45,2.08,2.35,2.76,5.77,6.63,5.65,4.44,3.35,2.97,1.37,1.15,-1.04,1.05,-1.41,0.46,2 --1.04,1.19,2.74,1.86,3.04,3.67,6.43,5.41,5.14,2.98,2.05,1.35,0.19,1.81,0.49,-0.78,0.72,0.73,1.20,-1.10,-1.03,0 --0.27,0.34,1.67,0.08,2.15,2.96,4.08,4.08,3.13,1.48,2.15,3.11,3.85,2.30,2.65,3.03,1.10,1.42,2.17,-2.30,-0.27,0 -0.79,1.17,0.28,0.76,1.93,4.30,3.48,3.30,4.14,2.54,3.96,3.21,0.73,1.89,0.09,0.89,-1.11,0.15,1.39,0.77,-1.99,1 --0.80,-1.38,0.21,-1.87,-0.02,1.38,2.41,2.10,0.36,2.76,1.08,1.59,3.25,3.18,5.73,3.78,2.60,2.22,1.43,0.65,0.56,0 -0.27,-0.57,-0.40,-1.04,0.06,3.32,3.01,3.53,3.10,4.66,3.71,4.26,4.37,3.24,1.82,2.92,1.01,1.38,-0.86,-0.34,0.94,2 --0.38,1.57,0.60,2.33,2.46,0.57,2.86,3.87,1.90,0.52,1.92,1.02,1.91,2.95,4.98,2.89,2.10,2.26,1.27,0.54,-0.51,0 -0.02,-0.59,0.75,-0.03,0.98,-0.86,2.25,1.80,0.32,1.49,2.98,2.74,2.48,4.16,5.18,4.20,1.49,3.40,0.51,0.08,-1.14,0 -0.94,1.62,-0.02,4.60,3.68,3.48,5.28,4.03,4.11,3.68,1.68,2.41,0.41,-0.58,0.70,0.59,0.70,1.56,0.73,-0.79,1.01,1 --0.72,1.37,1.30,3.60,3.63,3.40,6.88,4.99,2.71,2.75,3.79,0.52,0.65,1.18,0.83,1.61,-1.63,-0.49,1.20,0.12,-1.49,1 -0.10,0.64,-0.95,-0.18,0.11,1.49,3.18,2.86,2.03,4.61,4.32,4.04,4.80,5.00,4.29,2.99,2.35,1.05,0.74,-1.13,1.04,2 -0.58,-1.83,-0.10,-0.97,0.28,0.03,-0.23,2.06,3.57,2.22,3.63,3.31,3.89,2.15,5.10,1.71,0.98,1.93,3.67,0.69,0.01,2 -0.54,0.68,-0.82,0.93,-0.23,0.32,-0.61,0.15,-0.26,1.87,5.51,3.69,4.40,4.70,3.95,4.11,3.39,2.12,2.46,1.18,0.54,2 --0.39,-0.03,1.69,1.24,3.80,4.65,5.60,4.26,4.02,2.95,3.44,2.53,1.43,0.27,0.75,-0.24,0.20,2.00,0.81,-1.51,0.18,0 --0.75,-0.34,-0.22,1.82,0.41,-1.70,-0.22,-0.40,1.20,4.26,2.55,3.59,3.98,4.49,5.95,3.35,2.94,3.84,0.65,0.55,1.80,2 --1.11,0.15,-0.20,-0.44,0.72,-1.15,1.12,-1.09,2.70,1.62,0.66,2.19,5.16,5.11,4.46,3.93,4.25,3.59,1.31,0.47,0.68,0 -0.96,0.29,-0.19,1.14,-0.09,1.36,3.08,1.50,5.23,5.45,4.98,4.77,3.99,1.22,2.31,0.65,0.10,-0.17,-2.68,-0.42,0.83,1 -0.26,1.32,0.84,0.25,-1.11,-1.00,2.24,3.13,3.19,5.33,6.20,6.18,4.24,3.23,3.33,-0.18,-1.75,-0.20,-0.38,-0.95,-0.22,1 --0.18,0.84,0.33,0.84,1.21,1.21,-0.01,1.25,1.50,1.13,2.08,3.74,3.11,4.17,5.08,4.86,2.39,-0.95,0.89,0.42,-0.18,0 --0.70,-0.90,0.06,1.03,0.37,-1.22,0.51,0.84,0.08,2.62,0.82,3.27,6.04,4.10,4.34,0.89,3.69,3.11,2.32,0.86,-0.29,2 -0.26,0.30,1.22,-1.20,-0.05,-0.96,-0.53,1.38,2.66,-0.01,2.67,4.37,3.17,4.69,4.85,3.69,3.89,3.93,2.37,1.98,-0.25,2 -0.35,1.53,1.51,1.66,3.10,5.82,3.53,4.95,2.98,4.07,3.26,1.30,2.36,-0.35,-1.43,1.60,-0.27,0.65,-0.98,0.10,-1.78,1 --0.22,0.78,0.06,-0.25,0.75,-0.49,2.01,1.02,3.18,3.75,5.75,6.34,4.88,2.77,2.85,0.59,0.95,0.85,0.70,-1.10,0.24,2 --0.01,0.99,0.22,0.65,-1.23,1.99,3.46,3.89,3.61,6.77,7.05,4.48,1.86,3.40,3.06,0.02,-0.62,0.13,-0.97,0.83,0.10,1 --0.40,-0.48,0.13,-0.54,-0.52,2.33,3.23,3.57,5.61,4.55,5.19,4.39,4.07,3.78,2.53,-0.05,-0.31,0.86,-0.58,-0.92,1.01,1 --0.50,2.12,-0.01,-1.16,1.67,1.19,1.90,-0.49,0.39,2.51,2.17,4.77,3.91,4.43,5.77,2.77,1.08,3.66,1.65,-0.10,0.04,2 -0.73,1.08,0.33,2.66,1.31,3.17,2.52,2.40,2.08,2.46,1.26,1.51,2.02,5.02,3.44,2.89,3.82,2.29,1.66,1.15,0.15,0 -1.72,1.70,-3.56,-0.63,0.83,0.78,-0.05,1.31,1.88,3.64,3.55,3.31,3.08,4.86,2.80,2.25,3.13,2.11,2.86,0.51,0.21,2 -0.38,0.29,0.03,-1.46,1.45,1.62,2.00,2.99,5.36,5.19,6.35,3.31,1.50,4.11,-0.47,0.55,-0.02,0.60,-0.92,0.20,-1.01,1 -0.38,-0.58,2.16,2.04,3.16,3.61,3.42,3.43,2.38,2.43,1.79,0.26,0.73,1.58,0.64,2.19,3.59,0.58,0.07,-0.74,0.87,0 --0.22,-0.59,1.11,3.47,1.52,0.02,3.35,0.98,2.90,1.81,2.40,2.27,1.84,1.51,4.04,2.56,2.86,1.82,0.27,0.46,0.28,0 --0.22,3.34,1.31,0.85,2.02,2.93,3.23,2.83,0.62,0.29,1.94,0.91,0.40,2.02,2.57,2.68,2.15,1.75,0.93,2.02,-0.87,0 -0.36,0.63,-0.27,1.50,0.36,1.65,2.39,3.23,4.03,3.24,3.66,2.10,2.12,2.53,0.98,0.12,0.94,-0.86,1.80,0.43,0.75,1 --0.40,-0.65,0.79,-0.06,1.50,0.22,0.19,2.54,1.46,3.62,1.95,4.09,3.93,3.50,4.45,2.21,1.24,1.59,1.84,0.53,-0.79,2 --0.26,0.07,1.61,4.14,4.63,4.46,5.51,4.63,2.60,2.38,4.04,0.11,-0.49,-0.42,0.69,-0.55,1.43,-0.42,1.45,-1.32,-0.58,0 --0.27,-0.20,-1.41,-1.06,-0.66,2.28,2.42,2.40,2.32,0.96,3.08,1.29,0.21,2.36,4.13,4.47,4.09,0.92,3.35,1.08,0.72,0 -0.73,0.35,0.01,0.97,0.81,2.90,1.39,1.05,-0.09,1.14,0.93,3.61,3.93,5.46,5.99,6.44,3.76,2.38,2.84,1.21,-0.50,2 -1.39,-1.29,-3.42,-2.15,-0.27,2.39,1.03,3.55,2.76,4.77,6.67,5.27,4.74,2.04,2.04,2.12,-0.40,1.41,0.89,-0.60,0.73,2 -0.85,0.48,-0.77,2.02,-0.81,1.73,1.83,-0.01,0.74,3.59,3.97,4.63,4.04,2.49,4.80,4.20,2.72,3.31,2.02,1.63,1.43,2 --1.58,1.53,0.97,-0.29,3.08,3.03,4.92,7.67,5.16,1.85,4.70,4.13,2.39,2.16,0.56,0.71,-0.54,1.48,0.16,1.30,0.52,1 --0.94,0.19,-0.10,-0.44,-0.60,-0.04,0.90,0.16,-0.12,2.71,1.85,4.89,4.58,6.57,5.41,4.96,3.60,3.64,0.85,-1.41,-1.57,2 --0.44,0.24,-1.44,-1.32,-1.20,0.97,2.05,-0.77,1.71,0.85,1.70,3.26,4.90,5.35,5.45,5.30,2.52,2.26,2.08,-0.17,0.71,2 -0.36,0.62,0.58,1.30,1.80,1.52,3.75,4.70,3.06,3.49,3.25,4.47,2.39,1.93,0.85,0.04,0.29,-1.17,-0.76,-0.27,-1.99,1 --0.11,0.60,1.86,2.44,1.70,2.37,4.62,3.89,3.41,3.14,3.82,1.60,0.65,4.20,3.36,2.94,1.51,1.46,0.18,-0.62,-0.01,0 --0.54,-1.48,-0.08,-0.57,-0.52,1.61,1.50,0.93,0.83,1.19,3.38,1.19,3.62,2.50,4.85,5.60,2.69,2.03,1.74,1.89,-0.55,0 --0.72,-0.64,0.29,0.71,1.22,-0.41,2.11,2.84,1.51,2.64,3.86,5.18,2.48,2.84,3.22,3.37,2.53,0.46,0.35,-0.48,-0.95,2 --1.95,1.77,0.11,1.98,3.17,3.08,4.77,3.14,4.09,3.53,3.48,4.72,1.58,2.05,3.18,1.85,-0.17,0.38,-0.85,0.51,-0.79,1 --1.40,0.03,1.17,2.17,1.97,2.43,3.41,3.81,1.38,2.77,1.72,2.55,1.53,1.63,4.13,1.98,4.45,-0.16,2.54,0.53,-1.12,0 -0.63,-0.48,0.96,0.12,0.86,1.06,-0.68,0.53,1.47,1.47,2.19,2.34,3.77,4.12,5.99,2.70,4.35,0.69,0.76,0.07,1.41,0 -0.27,-0.68,0.03,0.11,0.28,1.78,2.57,1.98,2.77,4.82,4.71,4.79,3.53,2.29,2.20,1.41,-0.36,0.15,-1.10,0.39,-1.25,1 -0.09,-0.65,-0.41,0.69,4.11,1.77,2.25,2.75,2.99,4.66,4.92,4.02,2.83,2.49,1.31,1.01,1.06,-0.85,-0.73,-1.46,-0.58,1 --0.74,0.82,1.18,2.44,2.27,4.01,4.25,5.65,2.88,4.85,2.29,-0.11,1.27,0.65,-0.01,-0.58,-0.59,0.53,1.36,1.04,0.56,1 --1.77,1.37,-0.51,1.31,1.86,0.56,4.39,2.41,4.02,4.25,4.98,2.30,5.87,1.61,0.58,2.82,0.42,0.48,1.14,-0.66,0.43,1 -1.48,0.67,0.57,-0.99,-0.71,1.32,0.37,0.84,1.32,5.45,3.46,4.34,4.47,5.24,2.61,2.73,2.72,1.20,2.46,0.19,-1.14,2 --1.58,0.16,-1.53,-0.33,-0.25,2.85,0.09,2.30,2.24,1.06,3.64,4.70,2.07,3.10,5.74,3.26,2.02,2.92,2.09,1.64,-3.26,2 --1.22,1.15,2.39,2.66,4.52,3.80,3.33,4.26,5.01,4.45,2.58,5.64,1.37,0.96,-0.66,-0.61,-0.45,0.80,2.88,0.05,0.95,1 --0.14,-0.47,3.56,1.16,2.61,3.47,5.85,4.75,4.41,4.24,0.15,1.53,-0.67,0.40,-0.75,1.98,-0.17,0.65,1.26,2.22,-0.56,0 -0.57,-0.51,-2.06,0.36,2.29,3.24,0.61,0.63,1.85,0.74,1.63,2.52,4.34,4.01,5.08,4.48,4.34,3.35,1.65,1.19,0.09,0 -1.66,-0.59,-0.39,-0.08,1.68,0.14,0.65,1.54,1.75,3.41,4.27,5.57,3.49,6.44,3.85,0.48,-0.97,-0.46,1.24,1.72,-0.98,2 --0.95,0.50,-1.87,0.94,-0.78,0.99,-0.49,-0.80,1.34,2.13,0.69,2.82,3.04,4.24,5.44,4.27,3.84,2.08,2.26,1.06,0.29,2 --0.76,2.80,2.45,3.81,2.15,1.91,3.37,3.15,3.55,1.80,1.38,1.36,0.00,0.77,1.72,1.82,1.21,2.52,-0.46,0.26,2.86,0 -0.05,0.17,0.40,-0.27,0.84,1.66,2.96,2.67,3.62,4.39,6.37,5.83,4.43,3.44,0.03,1.24,-0.16,-0.99,0.79,-1.84,-0.18,1 -1.66,-0.35,2.11,3.19,3.55,4.65,6.48,4.66,3.39,1.35,0.50,1.46,0.27,-0.86,-1.10,0.30,1.97,0.19,0.76,-0.01,0.36,0 -0.32,2.31,0.45,-0.16,-0.09,0.29,-0.35,0.31,-0.21,3.44,3.20,3.51,1.80,5.76,6.75,3.74,4.27,1.76,1.89,0.98,1.82,0 -0.40,0.87,-1.42,2.73,4.50,3.48,3.73,5.08,5.48,3.88,5.12,3.28,0.78,0.93,1.24,0.31,-1.68,0.43,1.13,0.97,0.30,1 --0.79,0.98,3.30,3.82,3.31,4.34,6.70,5.22,4.96,3.56,2.38,1.28,-0.05,0.42,-2.48,0.82,-0.35,-0.57,-0.79,-1.02,0.56,1 -0.11,-0.51,1.14,0.35,0.14,0.31,1.07,1.29,2.90,2.61,4.66,3.18,3.27,3.04,2.42,-0.22,-0.73,0.86,1.18,-0.72,0.84,2 -0.39,2.65,-0.39,0.22,0.98,2.60,4.09,2.92,3.08,4.72,5.15,3.51,2.99,2.37,1.64,1.19,-0.23,1.26,-0.15,0.89,1.26,1 --0.47,-0.34,-1.17,0.31,1.03,0.66,3.85,3.86,3.48,4.71,5.51,4.58,5.32,1.79,-0.56,2.55,-0.70,0.23,-0.23,2.05,0.30,1 -0.61,-0.26,0.47,1.43,2.18,1.07,1.64,2.95,4.62,2.64,4.50,4.44,3.41,2.13,2.04,-1.02,-1.00,0.43,2.29,0.85,0.75,1 --0.65,0.85,1.23,-1.90,-0.02,-0.35,2.60,3.22,3.26,5.32,4.96,5.58,4.11,4.25,2.80,2.27,-1.34,0.25,1.89,2.60,-0.94,2 --0.86,0.31,-0.39,-0.72,-1.25,1.08,0.13,0.26,-2.37,0.00,1.32,0.24,3.16,4.43,7.07,2.39,3.93,3.96,0.64,1.99,-0.06,2 -0.52,-0.01,0.55,0.90,2.42,2.25,5.36,4.71,4.10,4.69,5.40,2.00,1.48,0.61,-0.36,0.44,0.77,0.16,0.13,1.22,0.22,1 -1.41,1.06,-0.23,1.70,1.65,2.02,1.69,1.94,2.85,2.85,3.91,0.87,2.42,3.41,4.04,2.96,4.01,1.82,2.29,0.63,-1.47,0 -0.35,-0.11,0.02,-0.36,-1.02,0.97,1.41,1.52,2.90,2.73,3.31,3.95,4.89,1.92,3.24,2.01,-0.53,1.97,0.42,-0.12,0.37,2 -1.29,0.73,2.36,3.04,3.72,4.83,5.51,4.52,3.77,2.74,3.32,1.85,1.45,0.99,-0.53,0.97,-2.18,-0.26,1.31,0.15,-0.33,1 -0.67,1.25,2.24,0.91,3.56,5.28,6.83,6.39,4.02,3.39,2.18,1.90,1.89,0.76,-0.38,-0.40,-0.21,-0.25,-1.06,-1.28,-0.65,0 -1.34,0.08,1.99,0.94,3.03,2.36,2.62,2.86,4.63,3.29,5.82,3.57,2.56,4.47,0.00,0.81,0.72,-0.57,0.28,-0.06,-0.42,1 --0.49,1.71,0.27,1.71,2.17,1.92,-0.74,-1.20,0.99,0.75,3.27,3.02,4.50,3.60,4.30,3.22,1.74,2.56,1.39,0.52,-1.51,0 --1.29,0.25,0.47,1.78,0.20,1.41,2.94,0.75,0.82,-0.46,2.63,2.91,2.88,2.36,1.90,3.90,3.97,1.96,2.65,1.39,-0.33,0 -0.08,-0.67,-1.15,-0.64,-0.11,-0.02,1.36,3.55,2.84,2.33,6.48,5.57,3.69,2.06,1.65,2.60,-0.02,0.94,-0.53,0.91,0.46,2 --0.07,1.23,0.84,1.31,-1.88,2.58,0.59,0.05,-0.98,-0.34,1.73,2.98,5.55,4.40,3.74,5.02,4.90,3.67,1.69,1.24,0.25,2 -1.55,-0.73,-0.26,-0.53,-0.09,1.18,1.14,2.42,3.22,2.73,4.31,3.56,2.78,3.44,3.63,2.55,2.64,0.02,0.68,-0.99,0.33,2 --0.47,-1.51,-0.43,-2.11,0.69,3.03,2.24,2.65,4.39,4.56,5.47,4.03,4.92,2.21,3.74,1.13,-0.32,-0.23,1.19,1.12,1.95,2 --0.13,0.63,1.31,-1.00,-0.78,1.98,0.66,1.34,1.65,1.92,4.31,6.49,4.09,4.50,4.74,1.80,3.72,1.79,0.56,1.50,0.19,2 -0.86,0.90,1.37,2.87,3.91,4.22,5.11,6.64,4.46,3.11,4.92,2.69,2.08,-1.56,0.79,0.42,1.25,1.69,-2.53,-0.35,0.72,1 --0.23,-1.30,-0.64,2.03,1.68,0.76,1.03,3.55,2.28,5.95,3.20,2.81,2.60,1.67,2.02,-0.45,-0.91,0.72,0.89,-0.28,0.86,1 --0.43,0.58,0.60,0.30,0.01,1.85,4.14,1.55,4.81,4.26,5.46,4.74,1.26,0.82,1.31,1.65,-1.91,-0.77,-0.33,0.52,-0.23,1 --0.69,0.90,1.77,2.61,0.71,4.15,2.77,3.49,3.52,2.55,1.78,2.12,3.08,3.83,2.22,1.70,3.21,-1.30,1.36,2.57,0.30,0 --0.48,-0.06,0.04,1.13,0.68,2.02,2.46,0.40,0.91,2.01,1.94,2.22,1.80,3.89,2.41,2.94,2.60,2.55,1.30,0.66,2.10,0 --1.05,-0.15,0.35,1.89,1.09,1.28,1.46,3.30,3.43,3.22,6.48,5.22,3.64,4.40,2.80,3.50,-0.02,0.97,0.39,-0.15,-0.74,2 --1.04,-1.26,0.26,-1.77,0.53,2.95,2.76,4.86,3.83,4.79,3.52,4.10,1.85,2.53,-0.81,2.57,0.20,1.09,-0.10,-0.86,-1.16,1 --0.47,0.87,-0.32,3.15,1.71,4.57,1.85,4.82,2.56,6.64,3.59,2.50,0.95,2.71,1.67,1.09,-0.41,-0.00,0.46,2.89,0.06,1 -0.54,0.13,0.38,0.33,0.91,1.22,2.44,3.17,2.26,2.61,1.20,2.76,1.51,1.74,3.81,1.94,4.39,2.25,1.58,0.98,-0.04,0 -0.99,0.34,1.69,0.02,-1.39,0.35,-0.46,1.15,-0.05,1.63,1.28,4.16,3.97,5.80,7.20,4.26,2.11,3.11,1.32,0.41,-0.31,2 -1.90,-1.86,-0.18,2.78,2.77,2.99,3.42,3.61,2.61,4.28,3.84,4.69,2.89,2.17,0.93,1.42,-1.79,0.75,0.51,-2.36,-0.96,1 --0.11,-0.66,1.06,1.67,2.38,1.90,1.39,-0.61,1.60,2.80,1.90,2.04,0.66,5.29,5.00,5.49,1.59,1.73,2.02,1.22,0.58,0 --1.88,2.38,3.27,2.43,3.23,4.21,5.85,5.37,5.60,2.65,3.27,1.42,-0.82,0.85,1.51,1.05,1.41,1.31,-2.10,0.50,-1.06,0 --0.16,0.16,0.63,0.63,0.16,-0.74,1.02,1.24,2.06,2.19,4.24,3.62,3.98,3.91,3.03,3.36,0.31,1.15,1.28,0.22,-0.37,2 -0.12,0.32,0.86,1.35,2.40,1.84,2.48,0.53,2.57,2.58,1.32,1.89,1.73,3.55,4.61,3.97,2.32,2.09,1.32,-0.78,-0.07,0 -0.17,1.19,0.14,0.81,0.30,1.08,1.99,1.33,-0.37,2.74,2.64,3.45,1.23,5.30,4.71,5.54,3.38,2.36,-1.45,0.70,0.30,0 -1.96,-0.32,1.55,0.83,4.22,3.44,4.54,4.54,4.65,1.67,0.96,0.76,0.62,1.31,-0.55,1.09,0.23,-0.30,1.64,0.05,-0.12,0 -0.87,-0.18,0.85,2.22,5.83,5.72,4.36,5.15,4.88,3.96,2.99,1.94,-0.67,-0.11,-0.91,-1.96,-0.21,-0.38,-0.76,0.45,0.37,1 -1.39,0.56,1.02,2.98,3.94,3.38,4.51,4.74,2.43,2.33,0.74,4.14,2.48,1.67,1.04,1.28,0.80,0.73,-2.04,1.21,-0.08,0 -0.15,0.64,2.40,3.23,5.77,4.04,5.98,4.95,3.57,4.22,1.65,2.24,-1.58,-1.25,0.86,-0.82,-2.03,-0.91,-0.31,0.86,-1.58,0 --1.61,2.52,1.48,2.99,3.77,4.46,4.42,5.86,4.34,3.96,1.48,2.13,0.96,1.11,-0.15,2.31,-1.68,1.11,-0.21,1.11,-1.08,1 -0.90,-0.01,1.48,-1.20,0.40,1.35,3.00,0.01,2.75,1.62,1.94,3.58,4.15,5.04,6.01,5.21,3.67,2.46,1.46,1.27,-0.95,2 --2.57,0.41,1.50,3.74,4.05,3.04,5.14,5.55,3.63,2.86,2.18,0.42,0.48,-0.46,0.70,-0.18,-0.76,-1.22,0.36,-1.27,-1.88,0 -1.17,-2.92,1.26,0.01,0.78,0.09,0.93,1.29,0.75,2.74,3.32,3.85,2.28,4.28,4.16,2.87,2.28,0.25,0.10,-0.94,-1.42,2 -1.71,1.06,1.01,2.66,4.50,5.44,4.56,3.75,4.28,4.75,-0.59,1.81,1.06,-0.49,0.55,-0.14,-0.60,-0.53,-0.73,-0.71,-0.84,1 --0.71,0.58,0.26,1.84,3.47,3.10,3.13,2.07,3.09,1.64,1.46,2.24,1.50,3.27,3.05,0.44,1.40,2.02,-1.73,0.47,0.10,0 --2.01,1.52,1.16,0.69,2.76,2.87,3.42,2.97,4.22,4.33,3.94,3.11,0.52,0.11,0.00,1.02,0.08,0.64,0.90,0.88,-0.86,1 -1.13,1.06,0.89,2.23,3.31,5.86,5.56,6.00,3.26,0.51,2.08,0.27,1.45,2.28,1.21,0.34,1.00,0.99,1.25,0.19,0.14,0 -0.72,1.79,2.94,0.51,4.86,4.35,6.92,4.50,2.72,3.63,2.95,1.67,0.41,-0.60,-1.06,-1.45,-1.22,0.72,-0.23,0.07,-0.17,1 --0.41,0.91,0.55,1.32,-0.86,2.17,3.43,2.88,4.47,3.58,5.08,3.91,0.43,2.03,0.63,-1.37,0.40,1.28,0.64,-0.39,0.64,1 --0.96,1.19,-0.38,2.61,1.32,2.74,1.82,1.83,2.13,2.54,2.45,0.67,1.91,2.06,2.57,-0.45,0.75,1.78,0.55,3.00,0.40,0 -0.03,-0.95,0.12,1.65,0.62,0.87,0.81,2.83,1.20,3.40,-0.41,2.10,1.88,2.88,1.73,4.14,1.66,2.77,1.35,1.70,0.99,0 --0.69,1.01,1.27,1.93,1.78,4.69,4.49,4.24,1.62,2.77,2.33,1.40,1.53,2.18,1.16,2.17,1.13,0.61,0.07,-0.04,-0.40,0 --0.19,1.22,0.86,1.45,1.43,0.18,1.89,1.81,2.58,4.78,5.91,4.00,3.64,1.45,0.70,-0.65,-0.83,0.03,-0.25,-0.99,-0.82,1 -0.20,0.56,-0.33,-0.75,0.52,0.32,-0.01,0.90,2.72,3.57,3.34,3.45,4.23,4.03,2.76,2.12,1.61,1.88,1.73,0.28,-0.09,2 -0.36,-0.31,2.06,-0.93,-0.42,-0.38,2.20,1.80,0.95,3.69,2.58,3.31,5.74,3.19,3.41,3.75,0.57,1.15,0.84,-1.08,1.58,2 -1.66,0.98,0.49,-0.31,2.48,-0.62,3.09,2.62,0.63,2.95,4.32,4.16,5.44,2.87,5.03,3.00,2.82,3.13,0.46,0.28,0.12,2 --0.70,0.98,0.75,1.63,1.35,3.37,2.49,3.39,1.73,2.29,1.00,1.78,2.88,0.11,2.06,1.10,1.81,1.55,0.84,-0.70,0.19,0 --2.22,-0.52,1.94,1.98,1.97,2.10,5.87,4.54,5.03,4.25,2.27,2.65,0.58,0.34,2.01,0.89,-0.40,-0.45,-2.13,0.90,1.47,1 --0.70,0.88,-0.15,-0.01,0.35,2.19,0.83,2.30,2.33,3.54,6.27,6.15,4.67,2.86,3.22,1.66,1.00,-0.43,0.16,0.22,-0.17,2 --0.40,0.43,1.57,2.73,1.69,3.45,5.39,5.40,2.03,2.96,3.33,2.26,1.75,1.54,2.23,4.34,-0.55,0.64,1.24,-0.53,-0.25,0 -0.21,1.93,-0.40,3.80,6.11,5.62,4.48,3.85,3.26,2.81,0.65,2.42,-1.05,-1.54,0.14,0.30,-0.26,0.22,-1.69,-1.03,1.73,1 --0.82,1.04,0.30,1.81,3.98,2.79,5.74,5.72,2.85,2.02,2.23,2.72,-0.91,0.19,1.04,2.22,-0.48,-0.33,-0.80,0.72,-0.87,1 -1.48,1.56,0.52,2.00,0.55,2.20,0.29,3.47,4.02,3.10,4.23,5.90,2.43,1.65,1.15,-0.23,-1.08,-1.42,1.39,-0.88,0.15,1 -0.39,0.33,0.69,-0.03,0.02,0.71,-1.69,2.38,2.80,4.34,6.46,4.72,3.11,2.57,3.94,1.71,0.92,-0.04,0.64,-0.45,-1.24,1 -1.24,1.38,2.39,2.49,3.96,3.53,6.01,5.02,4.27,4.18,2.80,2.04,2.45,1.12,0.44,1.02,-0.02,-2.37,1.54,0.31,-1.43,1 --0.23,0.73,-1.23,1.27,-0.34,0.36,1.20,-0.95,-0.79,1.08,3.50,2.40,3.05,4.41,6.59,6.33,3.83,3.56,2.46,1.26,-0.25,2 --0.93,-0.03,-0.33,-1.40,-0.67,-0.32,0.60,2.48,-0.09,3.20,4.82,4.68,3.56,4.35,3.52,3.18,1.54,1.57,0.96,0.48,0.68,2 -0.50,-0.85,1.01,2.74,2.59,2.58,2.49,4.79,4.86,4.09,4.57,2.30,2.87,1.75,0.43,1.38,0.47,0.57,-0.35,0.29,4.01,1 --0.62,2.49,0.76,1.30,1.97,2.96,4.80,4.49,3.30,3.30,2.44,2.12,0.51,1.37,2.50,-0.56,1.44,0.75,-1.08,0.48,-1.06,1 --1.49,-1.95,-3.37,1.77,0.35,0.31,1.72,-0.92,1.79,1.53,4.25,3.50,2.82,7.38,4.40,3.99,4.01,4.67,0.31,0.46,-1.91,2 --0.28,-0.84,0.32,1.02,-1.19,-0.71,0.36,0.84,0.97,1.97,2.62,3.03,1.94,5.45,4.49,5.59,4.80,0.92,1.99,1.08,-1.50,2 --0.35,1.18,0.25,2.13,2.47,2.74,5.18,3.04,2.65,2.41,4.56,1.87,0.89,1.26,1.08,0.86,0.74,0.04,0.11,-1.95,-0.79,1 -0.43,0.25,1.16,2.13,0.28,2.97,4.71,3.85,0.30,2.25,1.93,2.61,1.76,3.38,1.46,3.73,0.99,1.68,0.19,0.87,0.80,0 --1.59,1.86,1.72,4.22,4.04,4.68,5.89,5.36,3.36,4.77,2.41,0.97,1.32,0.77,-0.11,-0.21,0.25,-0.73,-1.87,-0.58,-0.80,1 --0.08,-0.16,0.15,2.02,2.77,3.25,2.31,3.27,0.05,4.48,0.10,1.66,1.78,2.52,4.69,2.36,2.10,1.31,0.71,2.23,0.48,0 --1.59,2.05,0.81,3.72,4.76,5.38,4.59,5.44,3.11,2.88,3.15,1.22,0.07,-1.46,-0.25,0.74,0.08,0.60,0.55,0.77,-0.04,0 -0.44,0.72,-1.15,0.58,-2.66,1.24,2.18,1.83,1.67,3.40,3.85,4.28,5.33,2.11,4.99,2.80,0.99,0.65,2.52,0.12,1.14,2 -0.07,-0.02,0.35,-1.62,0.67,1.16,-0.69,1.53,0.92,0.84,3.61,4.49,4.67,3.89,3.31,4.86,3.12,1.21,1.87,1.81,0.43,2 -1.18,0.02,2.03,0.58,0.07,2.15,2.12,0.45,1.42,1.16,0.63,2.48,4.22,4.56,5.26,4.02,2.83,2.49,0.23,1.64,-1.91,0 -0.36,0.19,1.01,1.14,0.96,-0.32,0.02,0.06,-0.50,0.49,3.70,2.81,4.72,4.16,4.11,5.88,3.89,1.39,3.03,0.82,-0.66,2 -0.44,-0.22,1.07,1.05,2.30,3.23,3.72,5.46,3.06,3.29,1.44,1.20,1.06,0.68,0.61,0.83,1.35,-0.04,0.77,-0.05,0.24,0 -0.76,1.31,-0.93,0.62,-0.11,2.70,4.17,3.02,1.82,2.90,4.74,5.49,3.93,2.07,2.53,1.21,1.85,-0.54,-0.50,-1.59,-1.39,1 -1.21,1.12,2.02,2.87,2.79,3.49,3.39,5.34,3.30,2.95,1.38,0.90,-0.53,0.64,0.69,-0.47,-0.76,-1.78,0.61,1.37,0.35,1 --0.44,1.07,1.29,3.10,4.19,6.26,5.40,5.34,2.70,4.11,-0.60,0.67,1.19,-0.37,-0.64,-1.55,0.30,-1.36,0.43,-0.44,1.14,0 -0.75,2.08,1.02,1.28,4.32,3.09,2.34,3.13,0.78,2.14,1.44,0.68,1.47,2.19,2.22,2.27,1.01,2.15,0.05,0.29,0.32,0 --1.19,0.47,-0.82,-1.44,-0.26,0.71,0.78,1.87,2.81,3.40,3.89,2.88,3.45,3.25,2.89,2.00,2.21,0.46,0.71,0.72,0.03,2 -2.61,0.77,1.08,-0.02,-0.08,0.64,-1.42,0.86,0.79,3.48,2.65,2.65,3.59,5.16,5.07,5.58,1.97,1.90,1.43,2.61,-0.40,2 --1.59,-0.46,0.55,2.76,3.18,4.17,3.46,6.56,5.27,6.10,3.90,3.28,-0.03,2.86,0.65,-2.21,-0.58,-1.78,-0.06,-0.82,-1.91,1 --0.41,2.67,-0.62,-1.86,-0.75,1.70,0.36,3.58,4.31,6.23,6.44,4.02,3.38,2.93,2.60,0.18,0.38,-1.42,0.95,0.86,0.67,1 --0.76,0.62,0.82,2.10,0.85,4.21,4.72,2.04,5.29,3.13,3.03,1.75,1.62,2.01,1.29,2.89,1.06,-2.00,-1.00,-1.34,0.51,1 --0.67,-0.30,1.64,0.04,1.34,1.25,-0.19,0.03,2.24,1.13,3.02,3.25,2.31,4.31,3.73,3.88,3.77,3.15,0.39,2.66,1.28,0 -0.41,0.13,1.03,-0.26,5.80,3.81,3.89,3.37,2.20,1.16,0.14,1.36,0.98,2.08,1.06,2.45,0.30,0.53,-1.42,-2.12,-0.86,0 --0.22,-1.15,0.16,-1.85,1.24,0.36,-0.08,-0.08,0.40,0.85,2.52,3.67,3.67,4.08,3.76,3.50,1.75,1.04,1.55,0.06,0.60,0 -1.44,-1.31,0.34,0.94,-0.09,0.58,3.17,1.99,1.14,-0.23,2.33,4.11,4.06,4.85,4.52,5.39,3.29,5.56,-0.15,2.75,0.74,2 --0.16,0.58,3.08,1.12,3.40,3.88,6.69,3.11,3.90,1.92,4.22,2.91,1.26,1.97,-0.50,1.05,1.05,1.90,-1.06,-1.02,0.21,1 -0.09,0.12,0.68,-1.46,0.46,0.69,-1.07,-1.11,-0.28,-0.50,2.06,3.85,5.46,4.90,4.15,4.84,5.13,1.31,1.21,2.28,-0.57,0 -1.59,-0.92,-0.22,-0.46,-1.50,-0.41,0.61,3.20,2.46,4.66,5.95,4.02,3.92,3.16,3.44,2.23,2.16,1.76,0.81,-1.04,0.86,2 -1.38,0.37,-0.76,1.37,0.99,3.99,4.39,2.84,6.12,6.07,2.27,2.68,1.57,0.29,0.67,-0.27,-1.07,-1.13,-0.34,0.71,-0.18,1 -0.78,-0.71,0.75,0.05,1.43,1.95,3.42,3.68,3.28,3.07,4.49,2.22,0.88,1.37,0.37,0.18,-0.78,0.63,-0.39,1.00,1.49,1 -2.75,2.88,0.66,0.37,0.86,2.02,3.19,3.62,4.41,4.39,4.94,4.74,1.28,0.25,0.84,-0.61,-1.38,0.01,-1.64,0.35,-0.79,1 --0.95,1.27,-1.27,0.06,-0.28,-0.03,-0.52,1.45,-1.40,0.29,4.64,3.28,4.29,4.66,3.82,4.77,3.42,2.10,2.30,2.26,0.54,2 --0.44,-0.29,1.50,-0.01,-1.33,-1.11,2.05,-0.06,1.65,0.79,2.02,3.67,2.82,3.72,5.40,5.27,4.93,4.33,3.05,1.41,1.04,0 --0.55,-0.31,0.32,-0.26,-0.97,2.74,2.81,0.58,2.48,2.13,3.94,3.04,2.71,3.82,2.45,2.19,0.06,1.24,-0.47,1.11,-0.91,2 --1.40,-0.02,2.55,0.37,3.95,5.54,5.87,3.66,5.58,1.97,0.78,-0.84,-0.80,-0.87,0.46,0.59,1.54,-1.71,0.70,-0.88,0.33,0 -1.33,1.20,0.45,-0.66,0.52,1.48,4.02,3.09,2.72,5.49,5.21,3.00,2.39,3.28,2.64,0.09,-0.64,-0.69,0.71,-1.34,-0.27,1 -0.49,0.11,3.33,0.44,3.99,2.18,2.98,3.06,1.63,1.89,2.52,0.09,2.20,1.56,2.79,4.05,1.65,3.12,-0.28,1.78,-0.00,0 --0.60,2.56,-0.34,1.31,-0.50,-1.02,-1.11,0.20,0.08,1.19,2.40,2.40,3.21,4.79,7.68,4.74,4.49,3.68,1.10,0.23,-0.04,2 -2.07,1.11,0.23,2.54,1.09,0.95,1.74,4.42,0.73,-0.94,2.14,2.82,1.13,1.34,3.32,4.55,2.23,3.19,0.35,0.09,0.01,0 --0.86,-0.10,1.71,2.37,0.51,3.10,4.83,3.84,3.38,3.93,5.91,4.04,0.67,2.39,-0.11,-0.85,-1.00,-1.77,-0.06,-0.69,0.07,1 --1.10,-0.44,0.60,1.19,-0.15,0.44,-2.10,0.34,-1.06,1.54,2.15,4.12,3.13,3.62,4.35,4.84,3.23,2.93,1.61,-1.64,-0.88,2 --1.02,2.39,0.79,-0.09,5.24,3.78,6.41,2.31,5.35,3.25,3.24,3.19,2.03,1.68,2.28,1.19,-0.44,0.73,-0.58,1.25,0.05,1 -1.07,-0.00,-0.60,-0.41,1.27,3.98,3.27,2.87,4.31,6.21,5.90,3.81,1.11,4.10,2.52,0.33,0.94,1.01,0.60,0.79,0.83,1 --1.48,-0.51,0.93,2.42,2.54,4.82,3.61,3.13,3.40,2.00,1.78,0.84,2.42,0.07,2.17,0.85,2.04,2.20,1.70,-0.03,1.27,0 --0.01,-0.32,-0.49,3.10,1.06,2.00,2.14,4.09,0.61,2.11,2.33,4.94,1.93,2.15,1.82,2.17,0.97,1.40,1.89,2.43,-0.19,0 --0.88,0.52,2.49,1.44,1.89,3.44,5.08,3.71,4.72,0.88,2.82,0.04,0.92,1.17,3.08,-0.01,0.57,0.34,0.73,1.50,0.28,0 --0.75,-0.33,0.75,1.95,1.79,4.07,3.26,4.24,3.86,3.47,4.11,1.71,2.67,0.84,1.48,1.26,-1.06,-0.11,0.35,-1.50,1.50,1 -1.05,0.26,-0.63,-0.01,0.87,2.66,1.73,3.46,4.58,5.75,4.91,4.59,2.82,2.37,2.81,1.89,-1.08,1.57,0.06,0.52,0.52,1 --1.63,-0.37,0.55,0.20,0.51,2.37,0.59,2.64,3.48,4.85,5.30,4.48,3.69,4.61,3.22,2.80,1.70,1.29,-0.34,1.34,-0.17,2 --1.05,-0.10,1.58,-1.02,2.58,-0.85,2.20,3.18,4.13,5.01,5.15,4.73,5.28,4.07,2.00,1.09,0.05,0.94,-0.22,-0.67,1.12,2 -0.40,-0.43,-0.94,-2.08,-1.24,0.97,1.29,1.49,2.85,3.01,6.46,3.90,5.71,2.75,4.38,3.44,2.64,1.14,0.38,0.11,-0.53,2 -0.74,0.92,1.50,0.59,2.66,3.86,3.82,3.39,2.22,2.00,2.14,2.55,1.01,1.43,3.30,3.22,1.85,1.30,0.32,0.42,-2.72,0 -0.22,-1.28,1.48,-2.03,0.17,-0.32,2.50,2.32,4.28,4.96,6.19,5.43,3.28,4.07,3.69,-0.05,0.18,1.05,1.05,1.37,1.42,2 -0.23,0.55,-0.49,0.87,-0.52,0.41,-1.31,-1.43,2.40,2.19,4.23,3.42,4.89,5.11,2.32,3.32,2.81,3.02,1.59,0.28,0.16,2 -1.94,3.17,0.03,-1.15,-0.48,-0.12,3.16,2.07,2.26,2.66,5.14,3.63,3.69,4.38,4.13,2.50,0.47,3.50,-0.13,-0.26,-0.04,2 --0.61,-0.84,0.43,0.15,0.06,1.92,1.22,1.00,0.25,2.23,2.14,3.52,5.59,6.92,6.00,4.75,4.18,1.81,1.18,1.60,-0.68,2 -0.19,-1.28,1.76,1.02,1.75,0.82,1.31,2.13,4.70,2.46,0.74,1.62,2.44,3.28,3.58,2.50,0.73,1.64,1.31,0.45,2.33,0 -0.86,0.73,1.53,1.63,1.89,2.52,1.35,0.04,1.06,3.14,1.43,2.15,1.31,3.53,2.62,3.54,1.58,0.26,0.36,-0.23,-0.81,0 -0.62,0.33,1.84,2.53,3.98,2.75,4.48,4.51,4.00,3.62,2.71,1.07,1.65,-0.80,0.10,-0.60,-0.97,-1.34,0.30,0.17,-0.10,1 -1.03,-0.12,-0.04,1.26,-1.16,-1.41,0.59,0.34,-0.59,0.83,3.34,4.52,3.81,3.76,7.05,4.08,3.59,3.75,0.94,2.06,-1.26,2 --1.41,0.15,0.08,0.51,-1.36,0.64,-0.22,0.05,-0.04,0.08,0.96,2.39,3.90,5.68,4.55,5.28,3.52,1.13,0.41,-0.57,-1.04,0 -2.30,0.09,0.51,1.74,3.75,3.09,4.87,4.89,2.20,4.12,4.91,3.36,2.53,1.74,1.54,0.51,1.50,0.62,1.12,0.31,0.11,1 --1.20,0.51,-0.41,0.66,0.92,-0.24,1.92,-0.31,0.76,0.88,2.49,2.60,4.54,5.68,4.27,5.84,4.24,2.09,1.99,2.11,-0.06,2 -0.72,1.67,1.45,1.71,1.18,4.06,2.84,1.20,1.20,1.08,1.35,0.90,3.13,3.95,2.70,2.57,3.32,3.99,1.04,0.22,0.18,0 --0.72,-0.81,1.76,2.09,1.19,1.73,0.99,1.04,1.46,3.11,2.27,1.20,2.12,3.08,4.36,4.75,4.74,1.58,1.05,1.20,2.03,0 -0.97,0.25,-0.32,0.41,-0.80,1.88,0.30,2.91,3.87,4.57,5.98,5.16,2.58,3.42,2.85,1.22,-0.92,-0.49,-0.12,1.98,1.52,1 --1.88,-0.04,-0.20,1.48,0.90,1.73,3.71,5.13,3.95,4.50,4.87,4.08,1.99,1.03,2.12,2.41,1.63,0.80,1.24,-2.02,0.90,1 --0.06,-0.78,0.31,-0.17,-0.86,-1.05,0.57,1.08,1.18,4.48,1.10,4.67,2.22,5.46,4.84,5.42,2.64,3.76,0.88,0.93,0.26,2 -1.19,0.97,0.48,3.11,4.54,4.34,4.24,4.78,3.07,1.56,1.27,1.29,-0.73,-0.75,2.04,0.27,-0.23,1.04,1.11,2.11,-0.47,1 --2.21,1.04,0.73,1.75,2.80,4.08,6.74,5.25,4.22,3.57,2.08,2.64,0.31,1.42,-0.85,0.84,-0.89,1.03,0.13,0.50,-0.39,1 -0.25,2.44,0.83,3.47,2.84,4.60,4.75,4.03,2.86,2.85,3.56,2.89,0.77,2.24,1.23,0.52,3.43,1.53,1.60,2.04,-0.95,0 --1.18,-1.21,0.53,2.25,2.18,3.58,5.34,2.84,3.57,3.18,2.44,2.92,1.92,2.39,1.64,1.60,0.59,0.66,0.01,0.26,-0.93,0 --0.79,-0.59,0.09,-2.15,0.31,1.07,-1.25,-1.37,1.18,2.07,2.43,4.73,3.42,5.63,4.68,5.54,4.16,0.91,0.32,2.16,0.05,2 -0.68,0.36,1.42,0.64,0.13,1.98,1.61,1.74,1.07,2.32,1.60,3.11,1.71,4.24,3.86,1.04,0.04,0.65,2.44,1.78,-0.16,0 -0.71,-0.61,0.26,1.11,-1.16,-1.00,0.88,1.65,3.54,3.42,7.41,4.04,3.21,1.87,2.50,0.06,1.06,-1.24,0.05,0.22,1.21,2 -1.32,1.23,0.33,-0.98,0.74,2.45,1.49,1.42,-0.56,1.45,2.38,3.39,3.94,4.18,4.38,3.71,1.92,2.02,0.29,-0.68,-1.44,0 --2.46,3.36,2.33,4.26,3.14,4.58,5.75,5.04,2.45,3.64,1.80,0.52,0.49,0.80,0.78,-1.62,-0.23,0.52,1.58,1.44,0.50,0 --2.49,-0.38,0.82,0.36,0.27,2.79,3.41,3.58,5.75,4.77,7.04,3.20,2.75,0.15,0.42,0.91,1.13,-1.06,-1.46,-1.04,1.18,1 --0.82,0.12,0.89,0.12,0.13,1.48,0.34,-0.15,1.79,1.99,1.99,3.86,4.62,4.93,6.16,7.10,3.07,2.03,2.47,0.73,0.55,2 -0.73,-0.48,-0.24,2.10,-0.21,0.05,1.40,1.60,3.99,5.87,5.69,5.29,3.87,2.97,4.04,1.45,-0.25,0.01,-1.54,-0.12,-0.57,1 --0.43,0.04,-1.26,-1.21,-0.44,0.05,2.16,3.95,5.67,5.26,6.30,4.61,3.88,2.29,3.41,1.56,-1.50,1.11,-0.70,-0.23,-0.18,2 --0.25,-0.64,2.82,0.99,1.60,1.68,2.62,6.42,3.86,3.20,3.60,1.99,2.14,1.02,1.86,-0.26,2.09,0.24,1.30,-0.68,0.10,1 --0.33,-0.56,2.71,0.95,1.27,3.84,4.54,3.85,3.95,4.05,6.34,2.98,1.43,3.86,2.28,1.11,1.26,1.12,0.38,2.20,-0.41,1 --1.44,-0.23,-0.45,-0.59,-0.37,0.55,1.76,3.09,3.39,6.76,6.94,3.89,4.08,4.80,4.10,1.81,-0.47,0.76,-2.11,-2.25,-0.48,2 --0.67,0.02,1.03,0.12,-1.47,-1.16,-0.50,0.94,2.00,0.48,2.90,3.60,3.29,3.33,4.79,5.53,3.93,3.74,3.29,0.48,1.80,2 --0.09,2.57,0.20,1.56,4.24,3.23,5.41,4.51,4.84,4.91,2.63,0.90,2.91,0.32,0.41,0.49,0.20,-0.06,-1.97,-0.73,0.07,1 -0.52,1.79,-0.55,1.77,2.36,3.73,5.38,3.42,2.58,2.59,2.37,1.21,1.03,1.41,0.74,1.06,1.60,-0.06,1.99,-0.59,-0.08,1 -0.94,-0.87,-1.01,-1.88,-1.00,-0.12,1.34,4.44,2.54,4.85,5.26,4.23,2.74,3.28,0.64,2.04,0.37,1.58,0.05,-0.16,-0.50,2 --0.14,1.18,2.10,1.76,2.23,1.04,1.64,2.30,-0.05,1.08,4.02,1.33,3.14,3.01,5.36,3.49,3.52,0.79,0.33,2.27,-0.61,0 --0.45,-1.05,0.39,0.71,0.74,1.83,1.18,1.92,2.14,3.17,4.14,2.99,2.17,1.63,3.08,4.38,1.64,2.35,0.85,2.05,0.92,2 -1.22,0.42,1.41,3.67,4.84,3.78,5.12,4.24,4.64,2.26,3.28,1.28,-0.10,0.07,-0.37,0.24,0.07,1.36,-0.03,2.45,0.02,0 --1.43,0.60,-0.01,-1.82,0.32,0.19,0.81,0.04,1.03,1.95,4.48,4.38,2.28,4.99,3.73,4.76,4.19,0.68,0.98,0.33,-0.65,2 --0.64,0.43,1.59,-0.39,2.15,2.21,3.17,1.19,3.97,1.12,3.00,3.62,2.47,1.69,2.86,5.74,2.53,1.25,1.13,0.10,2.68,0 --0.33,-0.80,1.26,0.47,1.50,5.11,2.59,2.49,2.17,2.62,1.51,3.40,2.15,3.48,4.82,2.35,0.70,2.16,3.74,-0.05,-0.17,0 --0.37,0.07,0.32,0.19,2.30,0.95,0.97,2.72,1.13,0.57,1.78,1.08,3.22,3.19,3.41,3.50,2.71,2.38,0.38,1.01,0.75,0 --2.08,-0.65,0.94,-0.21,-0.56,0.80,-0.01,1.77,1.02,-0.83,1.76,2.18,3.11,4.18,5.62,3.68,3.25,0.45,1.52,-0.17,-0.82,0 --1.01,-0.17,1.52,1.79,4.45,3.91,5.63,4.35,4.68,3.41,2.42,0.82,0.56,0.70,1.38,0.06,-1.09,1.10,-1.03,-1.95,0.83,1 --1.63,0.33,0.68,0.68,2.67,0.48,0.87,3.02,0.98,2.09,2.55,1.44,1.14,2.04,4.47,2.67,4.06,3.00,-0.40,0.60,0.95,0 -0.33,1.29,1.00,-0.10,1.71,2.09,2.71,3.30,4.05,6.80,2.72,2.89,2.36,0.34,2.47,0.98,1.11,1.02,-0.78,0.53,-0.55,1 -0.05,1.87,2.79,2.78,1.02,5.18,4.55,3.30,3.74,3.79,2.29,2.07,0.48,2.27,2.41,1.54,0.70,0.89,0.61,-1.97,0.69,0 -1.72,0.46,1.56,-1.22,-0.69,-0.58,0.41,1.54,1.59,3.64,2.93,3.25,5.08,3.18,3.95,2.89,-0.06,2.73,0.33,1.00,1.58,2 --0.31,0.62,0.81,0.09,-0.37,0.82,3.68,1.69,2.01,3.77,4.62,4.57,3.28,4.97,3.79,0.96,1.09,0.36,0.23,0.49,0.31,2 -1.13,-0.61,-0.39,2.20,0.99,1.40,1.94,2.46,1.63,0.78,2.73,1.04,1.69,2.70,4.32,2.75,0.77,1.32,1.89,-1.00,2.26,0 --0.09,-0.58,0.85,0.20,1.11,0.02,-1.43,0.77,0.32,1.97,1.78,2.92,2.66,2.46,4.31,4.59,3.53,1.63,1.90,1.07,0.57,0 -1.85,0.07,1.39,2.60,3.30,4.44,4.56,4.18,3.42,2.47,0.08,2.30,-0.21,0.78,-0.92,0.76,1.04,-0.41,0.87,-1.52,0.68,0 --0.84,-0.31,0.28,-0.17,0.83,-0.59,0.52,0.16,2.69,4.23,3.77,4.01,4.34,4.94,4.06,2.07,0.78,0.95,1.20,0.90,-1.05,2 --0.55,1.48,-0.07,0.66,0.14,0.52,1.01,-0.89,2.34,3.07,4.19,2.42,3.79,3.44,2.75,2.23,2.48,0.59,0.62,2.45,-0.14,2 -0.71,0.01,0.82,-0.37,-2.15,0.72,1.69,2.02,4.61,5.06,5.56,4.12,5.44,2.38,2.65,1.70,1.31,-0.78,1.87,0.84,-0.62,1 --0.39,2.27,2.10,2.60,3.05,4.26,3.34,1.04,3.08,2.87,1.32,1.92,1.83,1.60,1.71,0.98,1.37,1.94,1.76,-0.26,0.67,0 -1.27,0.77,0.73,0.54,1.38,1.76,1.87,1.74,0.94,2.88,2.78,3.09,3.56,1.68,4.13,3.52,2.99,1.52,0.20,-0.18,-1.85,0 -0.32,1.78,1.42,1.73,1.24,3.21,2.90,3.92,3.79,4.73,3.81,4.51,0.76,0.99,0.91,2.77,-0.41,-0.09,-0.44,-0.70,2.03,1 --0.39,-0.80,1.48,0.77,-0.94,0.59,1.90,1.76,0.73,-0.53,3.63,2.83,4.41,4.20,3.51,4.27,2.84,2.46,-0.22,0.45,-0.11,0 -0.70,1.89,0.34,2.42,1.95,2.61,4.60,4.06,3.28,2.71,4.12,2.87,1.57,2.06,-0.58,1.88,-1.08,-0.45,-0.29,-0.92,-1.56,1 -0.06,0.98,2.77,0.79,1.74,3.89,4.26,3.69,3.19,3.07,2.90,1.37,3.77,0.11,1.94,1.30,1.48,0.81,1.13,-0.19,-0.42,0 --0.21,-0.65,0.26,0.03,1.09,0.20,0.96,2.69,3.86,1.76,1.90,4.37,5.36,4.35,5.06,4.47,4.91,2.68,-0.56,0.03,-0.77,2 --2.15,-1.55,-0.59,0.65,-0.94,-0.14,1.16,-1.55,0.74,1.09,3.71,4.54,3.93,4.43,6.69,6.14,3.08,5.21,3.16,1.33,-0.29,2 -0.57,0.40,-0.60,0.62,-0.02,0.13,3.38,3.97,2.54,5.40,3.91,3.68,5.14,3.99,1.84,2.99,0.92,-1.49,0.88,0.83,-2.22,2 --1.67,1.58,1.63,2.63,4.47,6.46,5.07,5.28,5.52,3.57,1.48,1.39,-0.53,-1.62,0.07,-0.42,-0.71,0.75,1.38,-0.21,-0.32,1 --0.40,-0.67,0.02,0.31,-0.16,0.61,0.49,2.90,2.94,2.25,6.20,5.52,5.23,4.20,2.92,0.88,-0.35,0.85,0.78,-1.03,1.66,2 --0.10,0.04,-1.15,-1.29,-1.44,-0.82,2.84,3.61,4.42,3.98,5.64,4.42,4.64,4.51,3.91,2.73,-1.28,0.77,0.13,0.04,1.38,2 -0.41,1.09,0.34,3.55,2.15,3.42,6.59,4.92,4.51,1.44,1.46,2.33,0.28,1.05,-0.98,2.15,-1.37,0.26,-0.29,0.37,-0.31,1 -0.73,-1.43,1.97,-0.14,-1.68,-1.87,3.20,2.04,3.89,5.53,5.41,4.17,3.40,3.39,0.55,1.25,0.46,-1.13,0.89,0.27,0.75,2 --0.71,0.14,-0.58,-1.09,2.77,-1.53,-0.93,0.77,-0.39,0.76,2.61,2.29,3.54,6.85,6.10,5.03,1.96,2.48,1.92,0.37,-0.27,2 --0.46,-1.55,2.46,-0.63,-1.04,1.48,0.06,0.85,3.83,0.91,5.10,2.46,3.30,4.94,5.29,3.76,0.26,0.86,1.27,1.60,-0.63,2 --0.96,-0.46,-0.57,-0.00,0.58,-0.09,2.22,2.23,3.62,7.01,6.52,4.16,4.82,3.39,2.00,1.64,-0.18,-1.21,-0.41,0.02,-0.68,2 --0.08,-1.06,-0.44,-0.45,-0.27,-0.15,-0.35,0.78,-0.23,-0.09,2.89,3.13,5.10,5.65,7.78,5.45,2.73,2.43,1.54,1.10,1.41,2 --1.14,0.14,0.61,0.43,0.41,-0.11,1.88,2.25,-0.32,0.13,2.58,3.65,1.56,4.39,4.02,3.66,1.35,3.78,0.78,-0.03,0.45,0 -0.31,1.00,1.58,2.21,3.85,4.89,3.73,3.00,4.74,2.35,1.58,-0.06,1.61,0.81,1.87,-0.44,-0.31,-1.43,1.62,-0.12,-0.53,0 --0.50,-1.02,0.67,1.48,-0.07,-1.25,-0.62,1.45,-1.16,1.22,2.59,3.28,3.70,5.13,6.90,4.22,3.32,2.50,1.78,-0.62,-1.87,2 --0.12,-2.14,0.26,2.12,1.68,2.70,1.60,1.50,0.50,2.27,1.80,1.28,2.59,4.24,2.01,3.10,2.57,3.08,1.44,0.49,-0.42,0 -1.22,-0.79,2.23,4.28,1.67,4.22,3.65,3.41,3.03,2.44,2.79,1.38,1.68,-1.11,0.47,1.66,0.47,-1.60,-0.09,1.26,0.46,0 --0.22,2.03,-0.48,0.35,-2.13,-0.96,3.20,3.77,3.33,3.68,5.99,4.98,6.98,2.91,1.10,0.69,-1.07,1.94,0.58,-0.67,1.32,2 -0.20,0.90,2.85,2.27,2.79,5.15,6.35,4.31,3.26,3.40,0.33,2.98,0.17,0.14,1.60,0.30,0.22,0.29,-0.13,-0.08,-0.03,0 --1.95,-1.89,0.33,1.00,0.69,3.46,2.96,3.78,3.09,4.85,4.52,3.24,3.35,1.73,2.83,0.84,2.41,0.59,0.62,-0.98,-1.19,1 -1.04,0.02,2.24,1.51,1.25,1.13,1.94,0.31,1.56,2.17,4.24,1.43,3.66,4.30,5.04,2.67,2.78,2.11,1.34,0.98,-1.63,2 -1.96,0.65,0.19,3.74,3.28,3.94,5.57,2.83,2.13,3.00,2.20,2.16,-0.29,-0.90,-0.90,1.93,2.65,0.76,-0.42,-0.63,-0.65,0 --0.12,1.87,-1.44,-1.75,-0.66,0.43,1.57,1.06,2.82,1.98,4.71,3.41,4.41,4.69,4.83,2.38,1.27,1.16,1.82,0.71,-0.45,2 -0.01,-1.00,0.73,0.15,-0.01,-1.21,0.80,-0.72,-0.14,-0.67,2.74,1.81,4.45,5.21,5.68,5.93,2.51,2.28,1.61,-0.79,2.30,2 -2.15,1.59,0.92,3.15,1.02,3.83,6.36,2.39,5.29,3.46,3.36,1.39,2.02,2.07,1.38,0.44,-1.31,1.04,1.49,-1.37,-0.03,1 --0.15,-1.56,0.06,0.93,1.67,1.27,1.81,1.85,2.64,3.29,1.39,2.22,3.03,3.77,3.56,5.04,3.08,2.13,3.82,0.72,-0.43,0 -1.26,-0.38,0.09,1.89,0.76,3.96,2.59,2.73,5.41,5.56,6.02,2.41,1.64,2.68,1.90,-0.34,1.72,-0.08,1.07,0.34,-0.56,1 --0.28,0.33,0.63,0.81,2.49,2.75,2.03,3.51,3.37,4.90,5.47,2.38,3.08,2.28,1.57,0.05,1.07,-0.04,-1.50,-1.16,-1.19,1 -1.51,1.93,1.43,3.37,3.54,5.71,5.50,5.24,5.45,3.48,0.89,0.67,1.87,1.80,1.35,1.05,0.65,-0.37,0.35,-0.54,-1.21,0 --1.08,0.01,-0.96,0.39,-2.02,1.66,2.87,1.86,4.35,4.14,5.00,3.99,5.26,3.22,2.18,0.70,1.13,-0.94,-1.10,-1.22,0.02,2 -1.79,-0.71,-0.17,-0.47,-0.77,0.12,-1.00,1.24,-1.26,2.01,3.43,2.55,4.39,5.28,5.51,4.46,3.73,1.54,1.49,-1.05,-0.75,2 -0.71,0.63,1.39,-0.66,0.26,0.37,-0.00,0.09,0.01,1.75,2.24,3.14,2.92,6.35,5.93,5.04,3.66,2.14,2.27,1.09,-0.76,0 -0.26,0.66,-0.57,-0.06,0.89,1.99,1.24,1.22,3.86,4.37,4.48,5.71,2.63,3.08,3.58,2.72,1.24,1.91,1.32,-1.02,-1.26,2 -0.19,-0.98,-0.27,-0.34,0.19,0.11,0.85,2.03,4.82,5.66,5.36,5.95,2.96,4.47,3.33,0.93,0.18,1.12,-1.75,0.12,0.32,2 -0.89,2.45,1.30,1.67,2.78,2.60,4.61,4.18,2.68,3.22,4.89,3.03,0.65,1.56,1.44,0.36,-0.54,-0.00,-1.08,0.23,-1.25,1 --0.05,0.44,1.28,3.56,4.90,2.83,5.71,4.50,3.42,3.71,2.32,-0.14,0.24,1.69,-1.29,0.84,-0.63,0.29,0.36,-1.42,-1.04,1 -0.02,1.55,0.62,0.17,0.52,2.84,5.09,2.93,4.21,4.53,6.17,3.20,3.78,1.89,0.94,2.02,0.25,1.01,-0.57,1.19,-0.44,1 --0.59,1.65,-0.88,0.09,0.94,0.21,3.22,0.83,1.05,3.44,5.64,5.36,5.11,2.98,4.00,-0.06,2.23,-0.07,-0.60,1.05,-0.55,2 --0.85,-1.34,-0.19,1.23,0.60,2.19,0.44,-0.71,1.42,0.88,3.11,1.46,2.92,4.73,4.65,2.61,4.39,2.96,1.45,1.01,-0.19,0 --0.36,-0.01,-1.76,-1.19,0.87,0.82,1.76,1.41,1.76,1.40,3.76,1.59,3.00,4.10,5.23,5.03,4.26,2.72,3.76,0.46,-0.27,0 -0.31,1.66,0.13,1.12,1.69,4.62,3.73,3.98,3.20,3.83,4.19,4.24,1.81,1.46,1.53,-0.45,1.60,-0.19,-1.05,-1.27,-0.90,1 --0.01,-0.12,0.40,1.16,3.27,0.86,2.82,0.61,-0.13,1.01,2.28,0.97,3.60,4.88,3.24,3.82,2.17,1.32,1.98,2.47,1.02,0 -1.03,0.24,0.98,-0.54,1.96,3.88,1.97,3.21,2.33,4.03,4.65,2.92,2.61,3.02,3.33,0.99,0.74,-0.95,-0.28,0.87,-1.91,1 -0.81,0.58,1.02,0.38,2.20,-0.35,-0.77,0.48,-3.38,0.91,2.02,2.69,5.17,6.42,5.17,5.64,5.23,2.22,1.95,1.48,0.82,2 -1.46,-0.13,0.42,1.03,0.29,1.65,-0.71,0.14,-0.22,1.98,1.09,2.44,3.41,3.21,7.62,4.19,3.94,2.35,3.00,2.18,-0.40,2 -2.17,1.60,0.64,2.17,1.94,3.16,3.66,2.28,0.83,1.41,1.83,2.66,1.41,2.70,3.53,3.83,0.64,-0.54,2.23,0.27,0.67,0 -0.67,0.88,-0.09,-1.46,1.01,2.43,-0.97,1.79,1.38,2.41,5.15,4.25,2.43,4.23,2.92,2.54,1.17,1.39,-0.34,1.56,0.69,2 --2.19,-0.92,2.61,2.27,3.05,3.30,5.42,3.81,3.41,3.42,1.67,1.78,1.89,-0.14,2.43,-0.43,-1.16,-0.52,-0.89,2.06,1.26,1 --0.22,-1.10,0.21,1.71,1.68,0.44,1.02,1.43,0.59,-1.03,-0.02,1.21,2.51,4.92,6.61,2.75,3.28,3.37,3.76,0.95,0.48,0 -0.67,0.45,1.35,0.43,3.56,3.85,4.44,4.08,6.46,4.07,6.70,3.52,1.81,1.50,1.84,2.41,-0.70,1.77,-0.09,-0.38,0.95,1 -0.71,-0.89,-0.25,0.07,1.14,4.52,4.85,3.08,5.01,4.19,3.51,3.53,2.21,3.16,1.56,0.69,-0.26,1.00,0.29,1.44,1.34,1 -0.22,0.42,2.00,0.76,1.38,5.02,3.95,6.32,4.63,4.74,5.13,2.69,1.75,0.99,2.02,0.48,0.62,-0.69,-0.65,0.05,-1.22,1 -0.49,-0.72,0.73,-1.08,0.60,0.23,0.24,0.78,2.30,3.48,5.17,3.40,3.04,3.85,4.89,4.73,2.83,1.89,0.42,2.43,-1.61,2 --1.21,1.36,2.90,1.90,4.56,3.55,5.24,4.81,3.86,3.05,0.60,0.20,0.93,-1.43,-0.05,0.13,-0.02,0.89,-1.18,1.36,-1.08,1 -0.15,0.53,0.74,1.50,5.09,5.21,5.71,4.52,4.40,1.46,2.16,1.37,0.46,0.25,-0.56,-0.70,0.46,-1.97,-0.18,-0.11,-2.01,1 --1.14,-0.23,-1.04,0.03,-0.21,0.58,2.75,1.41,2.04,4.68,4.43,3.52,3.49,4.65,2.59,2.13,0.91,1.62,-0.12,0.38,-0.61,2 -1.87,-1.80,1.77,1.01,1.74,1.21,2.30,4.13,2.85,3.71,4.55,2.57,3.94,0.83,1.82,-0.19,0.69,1.36,-0.57,-1.01,-1.14,1 -1.71,0.34,0.57,3.48,3.63,3.30,5.87,1.37,2.07,2.83,1.98,1.42,0.94,3.30,2.37,2.44,1.57,-0.11,1.19,0.68,1.04,0 --0.33,0.97,1.03,3.58,2.07,2.88,2.81,2.70,1.24,0.99,0.08,0.19,0.42,1.59,2.63,2.55,1.20,1.09,0.18,1.29,1.09,0 -2.01,-0.50,-0.44,-0.21,-0.83,2.31,-0.19,0.42,2.65,1.99,4.39,1.68,3.68,4.15,5.02,3.10,2.59,3.20,1.06,-0.56,0.40,2 -0.48,3.03,-0.02,1.19,1.52,2.82,2.40,1.41,2.32,2.42,2.15,2.04,1.28,2.99,4.27,1.87,1.43,2.69,0.61,-0.38,-1.43,0 --0.22,2.52,0.17,2.81,3.79,5.78,6.75,3.06,4.62,1.27,2.42,-1.19,1.09,1.55,-0.25,0.14,0.21,-1.29,-0.17,0.11,1.67,0 --0.17,-0.83,0.80,-0.41,0.48,1.82,-0.39,0.92,1.77,1.17,2.32,3.50,4.41,4.12,7.80,5.11,3.29,3.89,1.00,0.59,-0.94,0 -0.91,0.03,-0.30,-0.07,-1.57,2.41,2.24,2.98,4.56,5.82,5.86,4.93,4.98,4.67,3.25,0.26,0.76,0.24,0.55,1.12,-1.16,2 --0.44,1.02,1.77,2.12,2.44,3.14,5.61,5.70,1.98,2.68,2.57,2.47,0.52,0.70,1.08,0.32,2.00,1.29,0.69,1.33,-0.68,0 -1.64,-0.47,1.36,2.12,3.27,3.31,4.29,4.19,4.08,1.02,2.06,2.45,1.13,3.67,1.86,1.67,1.82,0.52,-0.09,-1.64,-0.96,0 -0.61,0.02,-0.91,1.88,0.57,1.98,1.87,2.21,2.52,1.08,4.74,2.54,0.75,4.41,4.09,3.80,3.01,4.55,1.66,1.10,-1.17,0 -1.17,0.18,-0.23,0.79,-0.27,1.28,0.07,0.52,2.40,3.12,5.25,2.47,1.81,2.65,5.50,2.25,2.17,1.84,0.68,1.30,-0.35,2 -1.22,0.37,-0.46,-1.23,-0.12,2.08,0.61,1.28,-0.24,2.71,3.25,4.13,4.04,4.39,7.37,2.70,3.51,2.74,0.83,1.49,0.23,2 --1.32,0.49,0.25,-0.25,-0.09,1.22,1.36,1.47,-0.47,1.94,2.66,2.14,3.75,3.56,5.10,5.89,3.06,2.95,-0.09,2.16,1.17,0 -1.16,-0.29,0.70,0.67,1.22,3.65,3.73,4.88,4.22,3.33,4.84,4.36,3.20,0.82,2.85,0.09,-0.21,-0.11,-0.41,0.16,1.10,1 -0.87,-0.50,-0.39,1.01,0.03,1.16,2.42,3.31,5.45,4.22,4.96,4.07,4.91,2.49,0.75,0.80,-1.13,0.92,0.79,-0.43,1.84,2 --0.12,1.25,-0.12,2.22,1.62,1.94,3.38,3.10,3.39,1.59,1.30,3.84,1.95,3.37,4.73,2.05,2.50,1.11,1.76,0.43,-1.84,0 -0.61,0.63,1.68,1.16,2.44,4.47,4.51,3.87,5.16,3.19,1.39,0.72,0.98,1.98,1.71,-0.08,-0.37,2.28,0.96,-1.63,-0.16,0 -0.51,1.02,2.79,3.62,1.63,5.37,5.71,3.79,3.23,3.60,3.28,1.09,1.23,1.15,2.22,-1.19,-0.62,0.65,0.52,0.59,-0.52,1 -0.92,1.06,0.79,0.56,2.46,3.39,3.77,5.93,2.25,3.45,5.36,4.28,-0.50,1.19,0.51,2.18,0.58,-0.83,-0.19,-1.38,-0.49,1 --0.38,0.16,1.76,2.43,2.39,4.45,5.13,5.07,4.53,1.09,0.74,2.08,0.17,-0.01,2.13,1.44,0.45,-0.32,1.52,1.13,0.13,0 --0.74,0.38,1.02,1.16,1.78,3.50,4.40,5.34,3.44,3.40,4.39,3.52,3.26,2.33,-0.53,2.33,0.33,-0.55,0.64,0.14,0.47,1 --0.29,1.32,2.27,1.61,3.41,2.70,2.02,3.30,1.21,2.69,2.24,3.35,2.76,2.65,4.53,2.64,5.03,1.13,1.30,0.04,-0.29,0 --0.92,0.44,1.44,-0.03,-0.28,1.09,0.40,0.63,2.09,0.00,1.46,4.35,5.89,3.66,2.96,5.26,3.10,3.33,2.58,1.77,1.39,2 --0.24,0.76,2.17,-1.02,-0.24,-0.45,1.14,1.58,1.38,3.05,3.59,3.09,3.82,2.48,2.78,3.12,0.23,0.78,0.82,-0.07,-1.19,2 --0.44,-0.43,1.36,-0.72,0.28,0.00,2.52,-0.69,1.45,2.68,3.12,0.98,4.73,3.84,5.84,2.85,4.72,1.72,3.89,0.41,-2.11,0 -1.05,-1.09,-0.55,0.73,-1.30,-1.17,0.47,-0.55,-0.52,1.08,1.65,2.83,3.29,5.09,6.47,6.36,3.83,1.87,0.95,2.89,-2.22,2 -0.39,0.31,-0.20,-0.10,-0.73,1.14,3.72,3.36,2.42,4.11,6.49,5.77,2.73,2.65,3.70,-0.64,0.62,2.04,0.84,0.83,-0.37,2 -0.31,1.80,0.86,2.34,1.25,4.33,4.76,3.46,3.88,1.28,3.94,2.28,0.81,2.64,1.30,-0.49,0.80,0.59,-1.25,-2.38,-0.59,0 --1.57,-0.43,1.66,-0.67,1.26,3.22,5.24,5.04,5.70,3.62,3.15,3.68,0.18,1.37,1.94,-0.13,-0.33,0.63,2.16,0.01,1.35,1 --1.78,-0.40,1.38,-1.20,2.00,1.12,2.13,3.19,0.71,1.33,1.70,1.76,3.36,4.15,4.16,2.71,3.44,1.45,0.54,-0.18,1.88,0 --2.52,1.07,2.01,-1.53,1.66,1.43,1.39,1.53,-0.36,0.64,2.53,3.32,2.92,6.21,5.06,4.50,4.00,1.16,2.29,1.42,-0.63,0 -1.85,-0.08,0.17,-1.09,-1.01,-0.11,1.36,0.40,-1.11,-0.66,2.39,4.84,4.62,4.55,6.56,4.58,4.00,2.07,0.98,3.59,0.15,2 -0.13,-0.63,0.84,2.81,4.10,4.95,6.36,4.92,3.03,3.66,3.03,1.92,1.12,-1.06,-0.18,0.96,-0.41,-0.37,0.64,-0.14,-1.18,1 -0.97,-1.48,1.36,0.77,0.72,-0.48,1.84,2.71,4.26,5.26,6.06,4.03,3.28,2.33,2.67,0.30,-0.29,0.65,1.08,1.69,1.05,2 --1.16,-0.01,1.58,1.76,2.60,2.07,3.14,1.05,1.47,1.75,1.84,1.76,1.99,2.59,3.19,2.53,2.74,0.36,2.49,1.94,0.37,0 -0.04,-0.60,0.91,2.04,-1.01,1.97,2.42,3.43,4.18,4.75,4.56,5.38,3.28,3.83,3.83,1.66,2.69,-1.64,0.48,0.81,-0.19,2 --1.03,0.51,1.98,2.12,0.51,2.49,4.00,5.07,5.22,4.68,4.18,2.26,2.89,2.13,-1.93,0.08,1.57,-0.34,0.11,0.12,0.05,1 --0.03,0.82,2.99,0.69,4.70,6.35,5.61,4.21,3.20,2.31,2.45,1.43,0.10,-0.27,-1.36,-0.11,0.11,-0.81,0.14,-0.47,-0.03,1 -1.17,-1.51,2.05,0.43,-1.00,0.11,2.45,3.92,4.65,4.78,5.32,6.01,3.63,4.01,1.88,0.40,0.16,-0.16,-0.99,-1.80,1.44,1 -0.24,0.80,1.55,4.49,2.48,5.04,4.71,2.96,1.49,1.67,3.82,1.26,0.71,0.52,1.25,0.95,0.26,0.12,-0.20,-0.23,-2.66,0 -0.15,-0.30,0.95,1.09,2.16,1.98,4.51,2.15,1.23,1.41,1.47,2.98,2.70,2.98,3.65,4.20,2.52,1.47,0.79,0.23,1.11,0 -2.15,-0.26,1.07,3.86,3.06,4.28,6.27,3.19,3.60,2.23,2.85,2.99,0.18,0.59,-0.02,0.47,1.07,0.44,0.44,-2.08,0.79,1 --0.47,1.04,2.02,-0.97,1.15,0.95,-0.17,2.27,2.34,2.75,4.58,3.03,3.10,4.73,3.51,2.33,0.02,0.98,1.13,-0.15,-2.82,2 --0.61,1.22,1.01,2.33,3.92,5.72,3.35,3.21,3.24,1.66,1.60,0.97,0.40,1.47,-0.44,1.45,-0.23,-0.88,-0.31,0.87,-0.49,0 --0.11,2.16,0.50,-0.80,0.30,1.14,1.63,2.37,1.43,-0.45,2.84,1.71,3.20,4.11,4.18,3.28,2.24,1.55,1.75,1.28,-0.42,0 --0.36,-0.05,0.22,0.54,1.75,0.11,2.84,3.39,4.18,6.14,4.98,1.99,4.51,4.03,0.88,2.92,0.63,0.59,0.28,-2.00,-0.00,2 --0.58,2.40,1.84,4.39,1.22,2.66,2.75,2.67,4.94,4.08,2.15,2.80,2.97,3.40,0.26,1.60,0.86,-0.76,-1.37,-0.46,0.70,1 -0.70,0.28,0.61,-0.24,0.84,2.79,1.49,1.22,-0.20,1.38,1.87,1.55,2.49,1.68,2.71,2.95,2.20,1.35,0.77,2.04,-0.88,0 --0.34,1.04,0.33,1.22,0.76,-0.34,0.91,1.68,1.32,1.25,1.35,4.99,2.40,3.51,4.16,2.39,1.54,2.29,2.49,-1.36,-0.84,0 --0.15,0.37,1.08,2.99,4.31,5.86,7.40,4.39,5.03,2.48,2.27,0.05,0.46,0.12,1.08,-0.34,0.07,-0.13,-0.74,1.16,1.19,1 --2.76,0.07,1.12,-1.01,-0.78,1.83,-0.91,2.29,0.63,3.50,1.67,4.64,3.18,5.06,3.84,5.38,2.04,3.36,3.56,0.98,-0.86,2 --1.39,1.54,1.27,2.17,2.14,2.60,2.71,5.19,3.70,5.14,5.33,0.56,3.79,0.36,1.10,0.71,-0.54,-0.22,-1.16,-0.63,0.37,1 --0.84,-1.23,0.56,0.58,-1.20,2.82,3.26,3.30,2.82,2.88,7.62,7.23,4.56,4.07,1.86,0.14,-1.47,0.00,-0.58,-0.57,-0.17,1 -1.86,1.39,3.16,-0.64,0.18,2.87,2.74,3.27,4.57,4.16,4.42,2.27,-0.03,0.01,0.48,0.70,0.10,-1.05,0.94,1.09,0.47,1 -1.08,2.00,-1.35,1.63,0.54,-0.35,0.18,-0.01,-0.16,1.74,0.85,4.40,2.51,3.76,5.79,6.03,3.93,2.88,0.27,1.70,0.77,0 -0.40,0.62,2.37,1.01,0.78,2.60,2.75,2.70,1.41,1.77,2.88,0.64,2.11,2.43,3.27,4.14,3.45,3.23,1.76,0.17,1.14,0 --0.87,-1.60,0.61,1.17,0.82,0.80,2.29,0.80,3.06,3.90,5.09,5.45,6.11,3.64,2.46,3.32,0.67,2.96,-1.05,0.53,0.47,2 -0.13,0.60,1.27,0.52,-1.20,-0.53,1.81,1.01,0.55,1.83,5.06,4.39,4.89,3.31,4.14,3.65,-0.78,1.12,0.91,0.91,-0.14,2 -0.82,0.88,0.04,-1.79,-0.05,0.97,1.24,0.86,-0.43,2.04,0.60,4.21,2.31,4.30,6.50,6.23,4.26,3.50,2.80,0.81,-1.52,2 -2.26,-0.73,0.05,0.95,2.82,3.88,2.80,5.40,4.67,4.02,4.55,4.64,1.59,0.51,0.54,-0.42,0.28,-0.78,-0.22,1.02,0.27,1 -0.56,0.69,-0.44,0.88,-0.22,2.06,4.22,3.32,2.95,4.82,5.20,3.64,0.59,1.07,0.65,-1.70,-0.18,-0.07,1.27,1.02,-0.41,1 --0.09,-0.44,0.32,0.93,2.21,2.84,2.93,4.67,3.04,3.30,7.23,4.60,2.69,0.46,0.24,0.28,0.31,0.62,0.16,-0.77,0.36,1 -0.12,-0.93,0.63,1.05,1.90,-0.64,1.38,2.37,-0.65,0.88,1.52,0.94,3.93,4.52,5.22,3.77,3.04,1.39,1.00,1.66,-0.77,0 --0.53,1.49,2.83,3.82,3.80,5.58,4.48,6.60,3.45,2.03,3.39,2.92,-1.02,0.43,-0.22,0.43,-1.92,-0.56,0.47,1.15,-1.35,1 -0.49,0.74,0.01,-0.98,0.52,0.28,2.52,1.91,3.01,3.14,4.55,5.45,3.10,3.01,4.07,3.36,2.01,1.90,0.80,0.58,-1.01,2 -0.51,-0.49,-0.39,0.45,0.64,2.78,2.32,3.64,3.04,5.92,7.33,4.08,2.04,2.67,0.71,0.30,-0.32,-0.39,0.69,-0.90,-0.01,1 --0.64,0.09,-0.96,2.28,1.97,5.19,3.30,3.10,3.04,2.21,3.19,1.87,3.07,1.02,3.29,3.42,1.16,1.90,0.86,0.27,0.09,0 --1.01,1.69,2.14,2.16,2.49,3.83,3.13,2.36,2.73,1.49,2.65,1.91,-0.40,1.06,1.42,2.75,0.99,1.00,3.11,0.65,-0.48,0 --1.56,0.39,0.25,2.64,1.69,2.00,1.66,2.69,0.63,1.90,1.48,2.12,2.26,1.11,3.93,3.21,1.31,1.12,1.39,-0.38,-1.00,0 --0.51,0.17,0.92,-0.39,-2.05,-0.38,0.82,0.25,-2.06,2.29,2.64,3.95,3.94,4.54,3.64,2.71,2.24,3.60,2.39,1.64,-1.27,2 -0.22,-0.05,-0.18,-0.25,0.70,1.62,0.91,0.54,0.34,3.63,2.98,4.34,4.00,3.74,4.53,3.10,1.73,2.83,1.21,1.08,-0.02,2 -2.26,1.82,0.71,-0.79,0.18,2.46,2.84,4.84,2.36,3.28,5.29,3.62,0.52,0.82,1.36,0.92,1.35,-0.44,-1.73,0.56,0.91,1 --1.68,0.79,0.48,1.92,-0.17,2.49,1.73,1.35,3.86,2.53,2.37,2.51,0.79,2.87,4.18,2.25,-0.09,3.03,0.35,-0.22,-0.55,0 --0.13,-0.09,3.40,2.16,0.97,2.20,5.70,5.04,5.69,4.53,3.34,1.80,0.74,-0.12,0.31,-0.14,1.72,-1.04,0.12,0.65,0.43,1 -1.07,-0.77,-1.06,-0.75,0.12,-0.17,1.57,1.85,3.97,4.70,7.97,2.88,3.34,2.75,2.06,-0.30,2.24,1.11,-1.78,1.05,0.04,2 -0.11,-1.03,-0.86,1.38,0.73,1.44,1.63,2.05,2.45,1.81,6.93,4.14,2.69,3.98,1.65,4.26,2.05,1.80,0.18,-2.18,0.45,2 -0.29,0.89,-1.02,-1.33,1.19,0.58,1.84,-0.46,1.25,1.95,0.80,2.99,4.23,3.67,6.07,5.55,3.74,1.90,2.43,-0.30,0.12,2 --1.05,-1.12,0.98,3.67,3.86,4.66,5.10,5.54,4.02,3.43,0.98,1.53,1.10,-0.85,0.17,-0.09,1.58,0.98,2.93,-1.05,-0.08,0 --0.20,1.17,0.62,1.70,2.80,2.10,5.77,3.35,5.37,2.48,4.49,1.04,3.03,0.67,1.59,0.32,1.17,0.18,-1.17,-1.41,2.59,1 --1.03,1.73,-1.95,0.67,1.29,0.80,1.13,-0.09,2.07,1.51,1.37,3.64,2.87,4.56,5.16,4.31,3.58,0.98,3.06,0.75,2.99,0 -2.05,1.55,0.74,-0.13,-0.80,2.49,1.92,3.37,4.40,5.18,6.91,3.02,3.47,5.77,2.37,0.74,-0.94,0.04,1.39,-0.16,-2.48,2 --0.96,-0.49,-0.80,0.73,-0.56,-0.77,1.56,0.35,0.26,1.41,2.81,1.47,3.72,4.91,5.15,4.40,2.88,1.71,0.05,-0.42,-0.20,2 -0.69,-0.34,1.96,0.45,0.17,0.96,-0.19,2.05,0.61,-0.07,2.78,1.99,4.16,2.53,4.39,4.98,3.05,1.55,2.05,0.24,0.37,0 -1.32,0.09,-0.44,-0.23,-0.71,0.12,-1.23,0.65,1.38,1.67,3.18,3.26,3.78,3.73,5.20,4.72,3.85,3.23,0.67,0.36,0.20,2 --0.10,0.53,0.20,-0.30,-0.26,2.46,0.88,1.89,5.02,4.13,4.40,4.10,5.36,1.99,4.93,2.10,1.45,1.66,1.82,-0.61,0.17,2 --1.37,-0.61,-1.19,0.57,0.48,-0.59,1.64,1.19,1.50,1.46,3.95,4.50,2.94,3.99,5.97,4.44,2.51,2.71,1.20,1.46,0.65,2 --0.16,0.05,1.22,1.75,4.61,4.05,8.42,5.42,3.55,3.33,1.02,1.96,-1.69,-1.15,-0.52,1.86,0.53,0.37,-0.19,-0.29,0.94,0 -0.12,1.68,0.80,0.68,1.26,3.52,4.23,2.78,4.26,5.76,2.47,3.68,2.16,0.42,0.77,1.97,-0.33,0.97,-0.86,1.40,1.57,1 -0.20,0.38,-0.14,2.15,5.59,4.05,4.94,5.05,4.81,1.43,1.62,2.29,1.08,1.08,1.35,-0.60,0.05,0.40,-0.02,-2.21,0.69,0 -1.29,0.33,1.30,1.63,2.25,0.72,2.91,3.33,1.17,2.05,1.94,3.13,1.18,3.93,2.84,5.63,1.73,3.09,-0.19,0.05,0.50,0 -0.11,1.91,-0.20,3.68,3.32,5.46,6.92,6.00,3.37,3.39,2.05,1.56,0.22,0.52,-0.55,1.20,1.52,1.24,0.84,-0.30,1.45,1 --0.78,1.09,0.75,2.67,0.94,1.30,-1.68,1.29,1.76,3.47,3.17,3.77,4.24,3.73,5.25,3.73,1.61,0.45,1.58,0.77,0.02,2 -0.49,2.21,0.70,0.34,0.34,1.40,1.19,3.41,3.24,4.63,3.70,5.17,1.59,2.24,2.84,0.56,-0.80,-0.04,-0.22,1.22,-0.21,1 --0.63,-1.03,-0.15,-0.52,-0.39,-1.37,0.11,2.69,1.79,3.65,5.40,3.47,3.31,3.23,2.86,3.15,1.98,0.95,0.08,0.43,1.01,2 -0.31,-0.10,1.58,2.65,3.08,3.28,7.58,3.32,2.53,3.66,3.04,3.61,1.01,1.63,0.16,1.23,1.07,-0.50,0.65,1.70,-0.38,1 -1.11,-1.14,0.67,1.06,0.80,1.37,1.27,2.48,4.91,4.44,6.73,4.46,3.38,2.77,0.61,-0.93,-1.36,-0.42,-0.91,0.09,-1.28,1 --1.79,0.73,0.92,1.36,0.11,1.51,2.04,2.82,2.09,5.67,4.08,6.22,4.14,3.06,2.86,0.21,1.89,1.88,0.20,-0.29,0.51,2 -0.54,-0.50,0.77,0.36,2.09,-0.39,4.22,3.45,4.12,5.15,6.49,4.16,3.68,2.86,1.85,1.02,0.80,-0.77,1.33,-1.58,1.12,1 -0.80,0.88,-0.24,1.41,3.90,3.54,4.99,3.39,2.35,3.39,2.36,1.03,1.62,3.95,2.37,-0.62,0.05,0.59,-0.13,-1.10,-0.63,0 --0.15,-0.90,0.83,1.02,1.74,2.02,3.84,3.20,3.28,2.97,4.27,2.76,0.70,0.46,2.26,2.25,-1.08,-0.26,-1.22,-0.07,-0.02,1 -0.15,1.10,1.98,3.65,3.87,4.54,5.47,3.83,3.28,3.33,1.61,0.89,0.73,0.48,0.88,1.03,-1.29,0.16,-0.98,0.02,-1.72,1 -1.23,-0.90,-0.01,-2.33,-0.89,-0.35,0.26,0.25,0.22,1.37,3.08,1.31,3.18,4.63,5.24,5.54,1.92,2.70,2.68,0.69,-0.55,2 --1.56,-0.42,3.03,3.30,3.75,2.27,6.28,5.11,4.71,1.86,2.72,-1.15,1.63,-0.36,0.50,0.17,-1.45,-1.24,0.49,-0.27,0.41,0 -0.50,0.93,0.44,1.73,0.00,2.40,1.53,1.97,2.68,3.49,6.58,5.43,4.14,5.09,0.82,1.70,1.20,0.33,0.57,1.01,-0.75,2 --0.64,-1.15,-0.26,-0.90,-1.60,1.76,0.81,0.94,2.97,4.84,4.15,2.42,5.95,3.58,4.13,2.32,0.52,1.92,2.28,-1.10,0.63,2 --0.42,1.97,2.31,2.22,5.26,4.06,4.24,5.93,2.66,3.06,1.55,0.25,0.82,1.59,0.30,-0.16,1.23,0.50,1.49,-0.44,-0.93,0 -0.01,0.31,2.21,2.58,1.51,5.07,4.65,4.40,3.42,2.58,3.38,2.44,-0.49,0.25,0.53,-0.08,1.35,-0.10,1.64,-1.55,0.95,0 -0.46,1.26,0.04,2.31,2.21,3.06,5.04,2.85,2.01,1.41,1.92,2.96,0.71,2.38,2.16,3.00,2.05,1.27,2.34,0.33,-0.14,0 -0.14,0.19,0.28,2.09,3.82,4.58,2.72,3.81,3.87,3.93,4.57,0.94,0.35,2.07,0.36,-0.91,0.15,-0.28,0.76,-1.06,0.27,1 -0.24,-1.53,-0.70,1.55,-0.29,-0.02,2.33,3.55,5.34,4.79,4.80,5.49,3.61,2.91,1.44,1.48,-0.60,-1.95,0.05,1.05,-0.64,1 --0.44,1.97,-1.08,-1.20,-0.83,-0.36,3.71,2.95,2.02,4.47,6.54,5.14,3.25,3.23,4.36,1.85,1.19,0.71,-0.31,-0.87,1.16,2 -0.97,0.88,0.74,0.94,-1.02,-0.39,0.14,-0.95,0.55,2.19,1.86,3.57,3.55,3.52,5.50,3.40,4.22,2.02,0.93,1.01,1.26,2 --0.38,-0.45,2.27,2.75,2.87,3.40,5.37,4.86,0.85,2.37,1.92,2.76,1.04,2.89,2.72,0.73,2.24,0.54,1.88,-0.11,-0.12,0 --0.52,1.80,0.63,-0.20,0.19,-1.60,2.26,2.08,3.31,3.66,3.97,3.07,4.99,5.14,2.45,1.75,2.46,-0.09,0.56,0.51,-0.21,2 --0.09,0.16,1.30,0.80,-0.31,1.66,3.30,2.02,3.60,5.60,4.64,4.78,5.70,3.14,3.99,1.32,0.74,0.04,1.95,1.16,-0.48,2 -0.51,0.97,1.69,2.52,-0.61,1.87,2.05,2.29,1.83,0.69,1.48,2.65,3.15,4.14,5.49,4.01,3.09,2.34,1.54,-0.23,1.25,0 --0.54,0.45,1.12,-1.44,-0.93,0.86,-0.54,3.95,0.21,0.67,3.93,4.33,5.17,4.73,4.90,2.39,1.60,0.14,0.10,1.38,1.08,2 --0.95,2.40,1.65,3.26,4.99,5.17,4.48,5.56,5.26,3.32,4.74,2.45,-0.54,-1.80,-0.75,0.59,0.49,0.49,0.16,-2.24,-2.05,1 -0.71,0.48,0.71,0.28,2.26,0.60,0.78,-0.36,1.04,0.85,1.46,2.05,2.25,5.51,4.67,4.86,2.24,0.91,2.18,3.26,-0.32,0 --1.52,0.27,0.36,1.46,1.59,1.57,3.35,2.23,2.00,1.36,2.22,0.85,3.59,4.14,4.65,2.04,2.60,2.39,1.17,-0.42,-0.22,0 -1.69,-0.28,0.06,1.11,0.60,-0.58,-0.21,-0.22,-0.91,1.53,2.99,1.66,2.36,5.25,4.68,7.09,3.51,1.80,5.28,0.76,1.18,2 --0.58,-0.14,-0.08,0.07,2.02,3.57,3.65,5.83,5.10,3.37,2.85,0.56,1.67,1.32,-0.36,-0.75,0.43,0.33,0.40,-0.06,-1.35,1 --0.25,-1.21,0.52,2.00,0.73,0.66,2.02,0.78,1.62,1.32,1.93,2.73,2.48,6.86,5.88,4.31,3.62,2.72,2.66,1.90,-1.30,0 -0.98,0.02,1.03,3.07,2.08,2.96,2.38,1.59,0.77,3.23,2.89,1.20,1.44,2.26,2.64,1.68,2.86,0.88,1.10,-1.65,-1.64,0 --0.45,0.15,0.37,-0.26,2.07,-2.41,2.95,1.97,0.39,3.32,4.56,4.09,4.09,4.53,4.74,3.44,4.31,1.97,1.31,1.05,-0.38,2 -0.57,1.30,2.36,3.16,3.08,3.12,4.70,4.50,6.13,4.01,1.66,2.49,0.51,0.16,2.09,-0.12,-0.10,0.30,0.64,1.07,0.64,1 -0.19,-1.45,1.48,0.33,-0.07,-1.24,0.66,1.50,3.46,4.06,4.49,2.20,4.92,5.20,3.21,3.18,1.31,1.83,-0.71,-0.78,0.99,2 --0.92,0.32,-0.55,-0.73,1.35,0.62,1.92,2.13,1.71,2.78,5.13,3.96,3.91,4.11,5.11,4.10,1.61,0.95,0.77,-0.42,-1.40,2 --0.01,-0.57,-1.34,-0.62,-0.14,-1.25,0.02,-1.90,0.70,1.22,1.99,2.63,4.03,5.46,6.64,2.91,3.99,2.23,3.50,1.17,-0.89,2 -1.80,0.20,0.28,-0.91,-1.29,0.85,1.72,-1.21,0.43,2.64,2.22,3.29,3.83,4.68,5.24,5.80,3.97,1.22,-0.57,0.34,1.21,2 --1.41,-2.33,0.59,0.50,1.96,1.76,1.38,1.07,0.82,1.50,-0.45,3.38,4.90,5.37,4.04,3.40,3.37,1.53,2.32,0.81,-0.75,0 --0.55,0.94,2.28,1.28,3.39,5.64,4.66,4.17,3.94,3.81,2.74,-0.28,1.32,-1.63,1.46,2.30,-3.04,1.28,-0.51,1.20,-0.55,1 -0.80,1.34,0.34,-0.14,-1.98,2.48,1.01,3.55,4.53,4.80,5.00,3.37,4.78,3.60,0.47,1.47,-0.70,-0.96,-0.85,0.66,0.14,2 --1.24,1.55,0.37,1.34,1.90,3.63,3.00,1.56,0.43,1.50,1.01,2.46,2.43,2.53,3.48,1.96,2.30,2.26,-0.23,0.53,0.44,0 -1.18,-0.64,0.36,-0.00,0.57,0.71,0.79,-0.45,0.92,1.70,0.61,2.54,3.85,3.21,5.23,3.63,5.80,1.80,1.28,0.41,-0.77,0 --0.05,-0.48,1.18,2.59,1.00,4.81,4.84,3.81,3.02,1.23,2.84,2.24,2.30,2.12,-1.01,0.35,-0.78,-1.67,2.14,0.92,1.10,1 --0.58,0.81,1.52,0.01,3.24,1.80,6.33,1.85,3.01,2.45,4.83,3.74,2.74,0.98,-0.38,-0.43,2.32,-1.00,1.76,0.48,-0.83,1 --0.82,1.58,0.69,1.02,1.59,0.57,3.20,3.37,0.53,1.84,1.52,2.99,1.79,1.89,1.76,1.27,1.22,1.08,0.50,-0.17,0.18,0 --0.66,0.31,0.73,4.76,3.12,3.99,5.54,2.80,3.24,2.95,1.66,0.59,-0.31,-1.89,0.16,-0.65,1.85,0.35,-0.85,0.84,-0.45,0 -0.66,-0.24,1.92,2.47,1.15,2.01,1.66,2.60,0.40,2.86,2.06,2.97,4.17,3.26,3.40,3.35,3.54,2.82,1.17,-1.04,2.23,0 -1.85,1.80,-0.08,0.65,1.29,1.53,0.48,0.37,1.70,0.78,1.88,2.46,3.52,1.72,4.23,4.10,2.90,2.21,1.08,1.75,0.97,0 -1.23,1.29,0.83,1.34,1.82,3.16,1.87,4.24,3.24,1.73,3.37,2.47,2.87,1.87,2.34,2.75,3.49,2.53,0.48,1.20,0.53,0 -0.23,-0.69,0.74,0.20,1.10,-2.65,1.23,0.68,1.90,2.91,4.83,1.27,2.61,4.11,5.68,2.41,1.84,1.11,0.34,2.34,0.17,2 -0.28,0.07,-0.56,-1.53,-0.11,1.63,3.05,4.07,5.16,2.04,6.75,4.54,3.88,2.23,1.81,1.13,-1.78,-0.01,-0.71,-0.69,-0.22,1 --0.03,0.85,0.05,3.74,3.59,1.89,3.37,7.32,4.00,4.90,2.43,1.84,0.92,-0.01,0.18,1.70,0.33,-0.39,0.36,-0.22,1.04,1 -0.27,-2.14,1.41,1.60,0.64,3.45,5.43,5.96,2.92,3.83,4.01,3.77,2.50,2.08,2.87,-2.30,-0.69,1.52,0.94,0.23,-0.80,1 --0.04,0.37,1.18,0.86,-1.07,0.78,3.10,3.09,3.80,4.79,6.81,4.68,4.69,1.88,2.66,0.13,-0.43,-0.60,0.39,1.97,-0.40,2 --0.21,-0.39,0.32,2.97,1.59,2.43,2.99,1.94,1.83,2.66,2.49,3.21,3.69,2.98,4.91,2.40,2.54,4.09,1.11,1.73,0.60,0 -0.53,0.57,-0.10,-1.51,-0.80,0.56,0.72,1.57,1.07,3.46,4.52,3.17,4.73,4.16,5.00,4.05,0.97,1.14,0.94,3.41,-0.51,2 -0.02,-0.56,0.43,0.97,-1.57,-0.32,-0.09,-0.39,-0.54,1.77,3.18,2.79,4.86,5.77,5.80,5.44,3.95,3.33,0.40,0.35,-0.51,0 --1.01,0.35,0.11,0.11,0.62,0.57,1.10,1.02,3.84,2.51,6.49,3.80,3.60,3.82,1.38,2.90,0.22,-0.31,-1.03,1.28,0.54,2 -0.77,-0.97,0.79,-0.41,0.30,-0.57,1.23,0.24,2.28,0.77,3.45,3.20,4.29,4.89,5.33,3.21,3.01,2.57,-0.61,0.66,-0.10,2 --2.61,0.32,2.03,1.21,0.63,2.44,4.07,2.82,2.51,3.98,5.58,3.96,2.96,2.80,2.31,1.32,1.04,0.28,0.05,1.69,-0.17,1 --0.19,0.87,0.01,0.35,2.29,0.68,1.29,4.36,4.58,4.43,5.68,2.27,4.41,2.60,2.24,0.60,1.29,0.66,0.81,0.96,0.90,1 -0.99,0.25,0.21,-1.44,0.09,-0.50,-1.00,-0.57,2.11,3.15,2.23,2.35,2.82,5.56,5.80,3.74,3.59,2.15,2.16,0.60,-0.85,2 --0.11,1.14,0.27,2.00,0.06,0.25,-0.06,0.64,0.56,2.29,2.47,3.02,4.38,5.13,6.05,3.51,3.20,1.81,0.50,0.26,1.25,2 -0.47,-1.33,1.79,1.61,2.17,3.97,3.70,3.80,2.20,1.12,1.49,1.70,0.99,2.57,2.79,1.34,2.15,2.56,1.68,0.04,0.17,0 -1.47,-0.17,0.54,0.83,-0.43,-0.06,-0.25,0.37,0.89,2.07,4.18,3.24,5.06,5.35,5.10,4.58,3.30,2.89,0.62,1.55,0.96,2 --0.79,0.61,0.26,-0.32,-0.40,-0.95,0.37,2.88,3.43,5.25,5.31,2.67,5.56,1.43,0.75,2.59,0.03,-1.56,0.15,-0.92,0.96,1 --0.44,-1.94,-0.51,-1.07,-1.19,0.76,-0.49,3.01,2.32,4.24,4.48,4.31,5.98,1.04,1.82,1.41,-0.46,1.77,0.38,0.20,0.27,2 --0.93,0.52,0.67,1.31,2.29,5.10,6.48,4.75,4.53,2.30,2.18,0.78,1.02,2.04,-0.34,-0.28,1.12,-0.32,0.34,1.52,0.88,0 -1.32,-0.41,0.74,0.73,-0.12,1.83,3.23,2.50,1.48,-1.65,1.80,2.21,1.51,4.12,3.43,3.49,4.79,0.64,2.54,1.19,-0.48,0 --0.08,-0.75,-3.77,1.67,0.19,-0.68,-1.09,0.92,1.77,0.95,-1.03,2.71,2.87,3.99,4.87,4.06,5.51,3.20,1.55,1.57,-0.57,2 -0.57,-1.25,2.14,0.95,2.10,3.03,3.17,2.85,3.26,4.06,1.97,1.75,1.83,3.80,2.82,2.15,2.57,1.15,1.61,0.25,0.38,0 -0.29,0.72,-0.07,0.09,1.01,0.76,1.90,1.63,4.71,4.50,6.96,5.65,3.84,2.12,3.39,1.87,1.09,-0.09,-0.88,-0.99,-0.52,2 -0.40,-1.45,-1.78,0.34,-0.99,-0.71,-0.44,1.13,3.16,5.46,7.31,3.86,3.60,4.11,4.08,2.26,1.68,0.41,1.55,-0.85,-0.83,2 --1.25,0.61,-0.70,2.64,2.89,4.68,4.67,2.62,4.68,2.83,0.82,2.71,-0.99,-0.88,-0.47,-0.69,-1.71,0.03,0.54,0.53,1.64,1 -0.60,0.39,-0.37,2.81,1.33,3.19,5.27,5.00,3.54,4.30,2.27,2.12,-1.05,1.56,-1.60,0.57,-0.97,1.22,-0.37,-0.27,-0.10,1 --0.25,1.01,-2.83,1.14,0.60,2.05,2.22,3.20,4.21,4.80,4.41,3.56,3.78,2.84,0.91,-0.10,-0.93,0.45,-0.83,0.40,-0.19,1 -1.69,0.57,2.20,2.29,4.12,3.67,6.50,6.15,4.59,3.06,4.19,0.21,-0.85,0.78,0.69,1.31,1.45,0.72,0.43,0.11,1.62,1 --1.58,-1.59,1.17,1.55,0.12,1.75,0.31,0.85,-0.09,1.68,3.29,4.45,2.44,3.12,5.20,2.59,4.36,3.10,1.18,-0.05,1.11,0 -1.34,0.86,2.38,0.86,3.46,3.76,4.90,3.75,4.35,5.02,3.77,1.79,1.80,0.43,-0.52,-0.91,-0.19,-0.47,-0.14,0.86,-0.65,1 --0.61,0.16,-1.00,-0.01,-0.52,-0.31,0.21,2.01,1.06,3.18,2.48,3.01,3.07,4.58,4.10,2.40,2.26,2.34,1.37,0.25,0.72,2 --1.45,-0.42,2.30,-1.02,1.26,2.43,0.59,1.04,3.10,4.80,6.02,5.64,5.23,3.07,2.08,0.99,-0.75,-1.69,-0.64,-0.72,1.85,1 --0.69,-0.82,1.68,0.65,1.95,0.04,1.29,1.84,1.35,1.59,2.96,2.55,3.30,3.67,3.42,2.43,3.33,1.59,1.76,1.28,-0.82,0 -1.16,-1.72,-1.31,0.82,0.95,2.12,1.39,2.09,4.08,6.42,6.37,4.74,4.32,2.39,1.00,1.91,0.27,-0.16,-1.34,0.97,-0.93,2 -0.28,-0.96,1.16,0.56,-1.00,0.79,3.63,3.42,3.37,4.38,5.00,3.68,3.56,3.75,3.21,0.07,0.50,1.50,-1.18,-1.92,-0.73,1 --0.86,0.44,-0.74,0.93,0.05,1.09,-0.58,1.77,3.48,1.31,2.50,3.05,5.53,3.29,4.93,5.60,3.21,0.83,1.11,0.99,2.33,2 --1.10,0.09,1.33,0.28,1.32,2.71,2.28,2.79,4.71,3.35,3.48,4.28,0.87,-0.03,1.39,0.14,-0.42,-1.57,-0.05,1.55,-0.44,1 --1.09,1.10,0.57,2.09,1.64,2.28,2.22,3.91,3.72,3.75,5.34,4.82,3.16,1.41,1.05,2.30,0.12,0.60,-1.36,-0.03,0.86,1 --0.25,2.10,2.65,3.80,3.92,5.85,5.91,6.06,4.27,2.68,3.06,1.90,1.19,-1.13,1.37,0.58,-0.04,1.53,0.69,0.19,-1.16,0 --0.79,0.96,-2.62,-0.06,0.55,-1.05,1.16,1.22,2.52,2.67,4.46,3.35,2.92,4.02,4.37,1.02,1.60,-0.25,0.04,1.66,0.61,2 --0.24,1.19,1.13,1.27,2.79,0.96,1.62,4.11,2.17,4.29,4.43,6.14,0.73,3.06,0.86,1.31,0.61,-0.17,0.64,-1.26,-1.43,1 -1.09,-0.42,0.06,0.56,-1.69,1.24,2.06,5.10,5.05,6.11,4.36,5.10,3.59,2.80,2.84,1.54,0.18,-1.52,1.26,0.32,-0.34,1 -0.34,1.13,-2.01,0.47,-0.13,0.50,-0.21,2.17,2.02,3.44,2.99,2.76,5.37,4.07,4.40,3.46,3.00,1.73,1.24,0.17,-0.01,2 --0.25,1.39,-0.32,1.91,1.17,0.31,1.32,-0.41,1.29,1.23,-0.50,1.61,2.54,2.57,4.29,5.33,3.70,0.87,1.14,0.43,1.24,0 --0.52,1.91,-1.18,-1.17,-1.39,0.20,2.35,-0.98,0.59,3.46,4.44,3.79,5.24,5.28,5.25,3.73,5.02,2.24,2.77,2.41,-0.46,2 -0.81,-0.85,2.77,3.44,3.06,5.30,4.10,4.98,5.61,3.72,3.79,2.71,2.02,0.82,0.01,-0.48,0.04,-1.88,-0.79,-0.50,-0.55,1 -0.07,0.63,0.42,4.53,4.19,5.13,6.88,3.41,4.19,3.24,1.54,1.99,-0.64,2.75,1.06,1.25,-1.48,1.80,-1.10,-1.01,0.56,1 -1.10,-1.39,-0.24,-0.37,-0.85,-0.81,0.79,1.58,3.04,3.93,5.08,5.57,3.43,5.06,2.79,1.65,1.46,0.76,-1.20,-0.04,1.81,2 -0.94,0.18,2.41,3.09,2.07,4.62,5.24,1.25,1.37,1.77,3.00,1.22,1.36,1.48,3.51,0.40,1.46,1.38,1.04,1.07,-0.12,0 --2.14,1.49,1.90,3.26,1.50,5.59,4.73,4.49,2.99,4.24,3.88,0.47,1.97,0.80,0.28,0.65,-1.35,-0.16,0.99,0.36,-0.39,1 --0.22,1.53,1.00,1.52,-1.14,1.64,1.33,0.56,4.07,5.38,7.17,5.78,3.31,3.79,1.52,2.35,-1.28,0.92,-0.08,-0.32,-0.12,2 --0.48,1.06,3.08,4.09,3.24,3.48,5.18,5.00,4.12,3.81,4.13,2.70,0.02,1.90,0.81,-0.14,1.84,-0.96,0.08,0.11,0.72,1 --0.62,0.35,1.63,2.72,3.14,2.63,5.48,4.59,1.64,2.92,1.63,1.89,0.39,-0.28,2.97,0.29,1.17,-0.95,-0.54,-0.85,0.77,0 -0.95,0.63,0.84,1.19,2.56,0.73,3.06,4.96,4.95,4.12,4.53,2.95,0.51,0.27,0.44,2.05,0.41,1.23,0.43,0.55,-1.32,1 -0.28,2.01,2.43,1.46,4.11,5.14,6.44,5.30,3.48,3.32,1.36,0.67,1.86,-0.26,0.08,-0.18,2.19,-1.01,-1.30,-1.04,-1.22,1 --1.42,-0.34,-0.14,0.11,-0.61,1.70,-0.02,3.82,2.02,2.57,6.08,4.52,4.79,4.30,4.00,2.76,1.76,0.16,0.30,1.72,-0.84,2 --0.66,-1.73,1.43,0.52,0.55,1.89,-0.07,1.70,0.59,0.89,3.54,3.16,2.28,3.43,6.15,3.92,3.47,2.53,1.05,1.00,0.20,0 --0.26,1.21,-0.90,1.82,3.21,1.23,1.38,-0.00,1.44,-0.30,3.10,0.89,2.52,4.03,3.22,2.68,1.87,2.60,1.08,1.11,0.94,0 --1.13,-1.11,2.10,0.07,0.95,0.10,3.38,4.31,4.73,6.00,4.60,4.20,0.73,0.73,1.13,0.61,-0.41,-0.06,-0.33,-1.40,1.00,1 -0.94,0.02,2.44,1.59,2.21,4.04,4.09,2.99,5.02,3.03,3.80,2.63,0.62,0.23,1.64,0.80,-0.20,-1.00,0.53,-0.91,-0.67,1 -0.99,2.17,1.70,3.04,3.70,5.11,6.64,4.13,3.56,3.68,2.89,0.81,0.75,0.67,0.37,0.45,-0.36,-0.40,1.56,1.86,0.77,0 --0.18,1.35,0.08,-0.43,-0.25,-1.68,0.78,0.01,0.56,2.53,1.95,2.97,6.17,4.22,6.42,5.14,4.55,1.90,3.07,1.25,0.86,2 -0.24,-0.42,0.05,0.82,0.55,1.57,0.19,1.64,1.73,0.82,3.00,2.78,3.89,5.55,7.00,5.74,1.74,1.09,1.58,-0.53,-1.04,2 --1.96,1.08,1.39,1.43,0.44,3.37,3.89,3.89,3.94,5.12,2.52,2.31,3.80,3.27,0.77,1.30,-0.72,-0.78,0.78,-0.48,0.19,1 -0.88,0.49,1.28,4.01,5.21,3.80,5.92,2.90,5.21,4.27,2.53,1.69,-0.22,-1.31,0.55,-0.47,-1.68,-1.92,0.85,0.19,1.24,0 -0.30,-0.44,0.14,-0.80,0.57,-1.20,2.18,4.83,1.28,3.88,6.74,4.15,4.38,2.10,2.18,-0.49,0.94,1.91,0.08,-0.59,1.30,2 --0.98,0.62,-0.46,0.97,1.68,0.86,1.08,0.15,1.43,1.85,1.44,3.74,3.78,2.56,3.54,4.41,1.44,0.82,0.55,-1.04,-0.39,0 -0.05,0.40,-0.34,0.02,1.44,-0.71,0.33,0.28,0.93,1.01,1.87,4.13,3.53,6.08,5.72,4.58,3.76,3.23,2.25,0.69,0.78,2 -0.56,-1.26,0.59,0.92,-1.58,-0.40,3.53,3.03,3.82,4.46,5.10,4.74,3.45,1.41,2.29,1.42,2.39,-0.57,1.59,-0.62,-0.41,1 --2.36,0.98,0.72,0.94,2.09,3.69,4.68,1.45,3.27,3.72,3.15,3.16,3.08,0.53,-0.68,0.85,0.51,0.14,-0.11,-1.42,-0.11,1 -0.95,0.52,1.36,2.77,1.53,0.85,3.22,3.32,2.77,3.56,3.30,3.20,2.48,1.14,0.25,0.01,0.12,0.59,0.90,-0.23,0.66,1 --0.65,-0.99,0.88,3.05,3.78,2.49,4.65,3.35,3.38,3.09,0.81,1.27,1.41,0.41,2.76,1.91,2.18,1.42,-0.22,-1.04,0.75,0 -0.71,0.49,0.90,-0.78,-0.97,0.30,-0.11,0.04,0.82,1.36,3.55,2.64,4.97,4.48,4.13,3.53,2.68,1.21,0.55,1.05,0.54,2 --1.46,-0.54,2.74,3.17,4.16,3.64,3.29,5.56,4.23,2.56,3.43,0.79,0.73,1.17,-0.59,0.93,0.59,-1.75,-0.23,-0.93,-0.03,1 -1.74,-0.78,-0.29,1.35,-0.07,-1.06,0.03,-0.36,0.34,1.28,2.31,2.28,4.59,3.51,4.78,4.15,5.50,2.17,1.41,0.37,1.16,2 -0.32,-0.50,2.53,4.49,2.90,5.51,5.10,2.86,1.66,2.35,1.55,2.46,1.88,1.21,0.15,-0.07,2.14,1.16,-0.89,-0.65,-0.91,0 --0.87,-0.21,-2.65,-0.31,-0.03,0.38,-0.91,-0.31,1.60,0.00,3.69,2.36,4.00,5.19,5.40,6.31,4.22,3.55,2.39,1.59,-1.81,0 -0.37,0.63,-0.31,0.53,1.34,0.94,0.56,2.74,1.82,4.18,5.63,3.77,4.80,5.98,4.65,3.88,3.24,1.33,0.50,2.05,-1.35,2 --0.37,-2.01,-0.37,-0.06,-1.14,-0.45,-0.58,1.66,1.92,1.07,3.92,5.08,3.54,5.11,2.97,3.01,2.36,1.96,2.99,0.35,0.37,2 --0.45,0.15,1.86,4.07,2.75,4.62,7.15,2.76,4.39,1.85,1.04,0.41,-1.07,-0.33,-0.35,-0.15,-0.71,-0.17,0.70,0.45,-0.45,0 --1.02,-0.63,0.47,3.51,2.16,4.57,3.12,5.21,3.52,4.77,3.53,1.84,0.15,1.88,-0.00,0.12,-0.00,-1.67,1.53,-0.28,0.80,1 -0.05,-0.74,2.23,1.82,4.16,5.57,5.49,4.11,4.37,4.39,2.64,2.20,2.07,1.64,1.38,1.56,0.86,-1.27,-0.62,-0.74,-1.45,0 -0.70,0.54,1.42,0.85,0.18,-1.23,0.36,1.28,3.75,3.86,5.01,4.05,3.61,3.85,3.79,3.45,-1.35,2.97,-0.93,0.57,0.59,2 --0.47,0.83,0.38,-0.73,0.56,1.16,-1.09,-0.52,2.44,4.57,3.65,2.89,4.02,3.17,2.71,4.13,1.73,1.11,2.39,-0.77,0.47,2 -0.68,-1.70,2.19,0.57,0.30,0.66,-1.07,1.74,0.16,0.99,2.74,4.98,2.54,2.47,3.67,3.99,4.67,1.71,3.03,0.67,0.02,2 -0.97,-0.12,-0.03,-2.61,-0.23,-0.07,-0.31,0.49,0.21,2.87,3.03,4.61,5.75,2.45,5.86,4.66,3.40,4.70,2.60,-0.02,0.65,2 --1.44,-0.40,0.60,-0.06,0.91,1.46,2.08,2.23,3.51,3.12,3.35,2.81,4.31,5.28,4.07,1.38,1.64,1.04,0.64,-0.38,-1.98,2 -0.71,-0.68,0.73,1.13,2.11,1.16,2.21,3.04,4.43,4.16,4.53,3.71,1.70,3.14,-0.06,1.43,-0.04,-0.18,-0.64,-0.08,-0.50,1 --0.47,1.99,0.46,2.19,3.83,5.42,4.88,5.12,5.54,3.84,0.63,1.44,-0.42,0.74,0.31,0.83,-0.66,0.34,0.13,0.61,0.91,1 --1.68,0.76,1.95,1.99,3.33,5.31,4.17,6.36,3.50,1.79,3.50,1.88,0.14,-1.08,0.75,0.53,0.05,1.87,-1.24,-0.63,1.19,1 --0.84,1.34,3.06,2.69,1.99,3.56,3.83,5.06,4.41,3.87,2.35,2.07,2.01,2.94,2.59,0.44,-0.29,0.32,-0.98,0.44,0.32,1 --0.23,1.13,2.83,2.87,3.32,4.38,3.75,4.37,3.28,2.18,1.01,1.27,1.19,-1.46,0.97,0.94,1.38,0.42,-0.10,0.01,-0.62,0 --0.01,1.54,-1.96,0.56,-1.82,0.85,-0.19,1.17,0.43,0.45,0.77,3.43,4.82,4.44,3.92,5.65,2.48,2.19,3.07,2.63,1.07,0 -0.39,0.67,-0.61,0.06,-0.14,-1.12,1.97,1.93,1.76,1.18,-0.50,1.95,5.43,5.81,3.83,3.60,3.64,4.21,2.53,0.50,0.76,0 -0.82,1.77,2.63,4.52,3.01,4.32,6.15,5.19,4.92,2.41,3.62,-0.45,-0.57,1.78,0.25,0.45,0.58,-0.44,0.79,-0.55,1.84,1 --0.08,0.05,0.64,2.10,2.48,3.40,5.07,4.79,3.20,2.90,3.25,1.28,-0.21,-0.34,0.87,1.67,1.43,-2.19,1.47,0.82,-0.29,1 --0.62,1.14,0.57,1.96,3.17,5.11,4.51,4.62,3.70,1.26,3.03,1.65,-0.58,0.58,-0.27,-0.18,0.36,0.26,1.19,-0.15,0.54,0 --0.22,1.76,-0.46,2.73,3.50,5.04,3.14,4.37,2.54,2.75,1.93,2.49,0.90,1.69,3.32,1.66,2.82,1.12,-0.08,1.25,-0.24,0 -0.86,1.22,0.67,0.13,-0.39,2.56,1.16,1.71,4.26,3.45,6.96,5.37,4.73,1.07,3.09,1.58,2.16,0.25,0.04,1.32,0.44,1 --0.30,-1.11,-0.33,-0.02,0.05,0.24,0.69,2.01,2.48,4.99,3.34,3.86,4.89,2.81,1.19,1.64,1.49,-0.28,-0.14,2.08,-0.11,2 --0.06,2.15,0.96,1.57,2.24,4.82,4.13,2.88,3.74,3.20,4.84,2.95,-0.02,-0.65,1.39,0.82,0.11,-1.68,-0.98,1.02,1.38,1 --0.57,-0.74,-0.00,0.73,-0.37,1.12,-1.45,1.11,1.68,2.94,5.62,3.74,3.14,3.98,4.45,3.45,0.65,1.72,0.83,0.90,0.24,2 --1.05,0.15,0.76,-0.88,0.74,0.54,4.58,4.95,3.65,5.99,5.05,2.61,3.29,1.67,1.34,0.53,-0.56,0.34,0.03,0.21,0.94,1 --0.12,-0.27,-1.19,1.33,1.33,1.35,0.30,1.57,1.82,3.19,2.40,5.30,4.30,2.83,4.48,4.79,2.62,2.53,0.88,0.93,-0.65,2 -1.74,2.36,3.01,2.52,0.25,1.86,2.15,1.94,0.45,0.73,2.85,0.76,1.89,2.39,3.53,4.44,3.18,3.14,-0.15,-0.34,0.78,0 -0.72,0.13,1.50,1.27,1.81,4.08,3.68,3.60,4.38,3.16,1.79,1.65,-0.07,2.07,2.02,3.39,2.05,1.53,-0.05,1.66,-0.54,0 --0.45,0.43,2.11,2.07,2.28,3.23,4.38,5.22,5.14,4.01,1.82,1.23,0.63,0.64,1.38,1.00,-0.27,0.30,-1.72,0.03,-1.30,1 -1.08,-0.13,-0.78,1.13,0.93,3.57,4.28,5.04,3.68,3.82,4.65,4.44,0.77,1.34,-0.23,-0.47,1.63,0.72,-0.64,1.11,-0.26,1 -1.23,0.49,0.72,-0.38,-0.39,-0.80,0.63,2.59,1.37,3.33,4.24,4.91,4.22,3.47,7.16,4.54,2.52,1.92,3.32,0.24,-0.36,2 -1.37,1.41,0.58,-0.96,0.42,3.18,2.61,2.47,4.34,5.08,5.59,4.03,4.92,3.70,2.80,0.52,1.09,0.31,0.83,-1.56,0.61,1 --0.30,0.25,0.33,0.03,2.42,0.76,-0.77,-0.20,0.70,1.84,2.28,3.94,3.10,4.05,4.59,3.30,1.79,3.74,0.55,0.77,-0.11,2 -1.72,0.09,-0.28,1.46,2.14,1.86,1.76,1.39,3.22,1.85,1.58,2.74,-0.25,3.02,3.28,2.83,-0.05,1.78,-0.41,-0.05,-0.12,0 --0.21,-0.06,0.14,-0.43,1.31,1.14,0.98,-0.78,-0.01,0.46,1.57,3.40,3.33,4.61,2.88,4.14,1.72,1.24,1.55,0.73,1.27,0 -0.57,1.09,2.21,1.02,3.44,1.95,3.97,3.47,2.26,4.21,4.45,3.49,2.20,0.98,1.15,-0.49,1.51,0.24,0.68,-0.55,0.36,1 -2.09,0.37,0.94,2.65,3.64,3.81,6.31,5.62,4.91,3.42,2.81,-0.43,0.58,2.73,-0.34,1.22,1.43,0.32,0.50,1.53,1.69,1 --0.28,-0.60,1.28,2.53,3.80,4.52,3.65,3.43,3.21,2.84,1.21,2.34,0.45,3.25,-0.20,0.09,-0.03,1.10,-0.27,-1.95,-0.36,0 --0.98,0.47,2.07,0.69,-0.20,0.48,2.14,1.86,0.72,4.01,5.01,4.46,3.69,3.63,2.74,3.13,0.26,1.28,-0.36,0.80,0.65,2 --1.94,-1.39,-0.47,0.70,-0.43,0.70,2.89,3.62,3.30,3.95,5.94,4.75,5.16,1.99,1.90,1.24,-0.03,1.32,2.40,-0.33,-0.49,1 --1.96,0.11,1.06,0.39,1.52,1.63,1.03,1.26,-1.12,1.95,2.07,3.92,4.08,4.12,5.04,3.65,3.06,2.08,2.68,1.85,-0.51,2 -1.58,1.84,-0.43,-0.37,0.15,2.55,0.44,2.37,0.41,0.96,4.63,3.53,4.19,5.69,4.85,5.42,4.10,1.84,1.03,2.32,0.06,2 -0.70,1.27,2.95,2.44,4.71,5.96,6.54,5.90,4.18,4.00,3.87,-0.85,0.82,-0.13,-0.20,1.07,-0.08,0.05,-0.23,1.28,-0.42,0 -0.96,1.62,0.95,0.91,1.17,0.28,2.11,4.63,4.55,2.33,5.09,4.83,3.74,2.25,1.85,-0.31,1.07,0.65,0.86,-0.67,0.35,1 -0.16,-1.90,1.37,1.18,0.39,-0.18,2.42,0.33,1.47,2.97,3.13,3.18,3.34,3.24,5.27,3.44,2.16,-0.22,0.48,1.18,0.40,2 -0.34,-1.84,0.93,1.33,-0.41,2.27,-0.20,3.50,2.34,1.74,3.13,3.10,3.76,4.63,3.86,3.36,2.16,1.13,1.63,1.77,0.33,2 -1.22,1.26,2.25,2.80,3.18,5.61,4.45,3.75,3.30,1.81,2.04,0.72,0.79,0.84,0.45,1.01,0.22,0.42,-0.54,0.06,-0.33,0 --1.90,0.72,2.69,0.11,-0.05,1.18,2.24,2.47,0.05,1.77,1.90,2.02,2.18,3.03,3.38,2.79,2.50,1.67,4.07,1.70,1.33,0 --0.15,0.89,0.75,0.24,-0.23,0.97,-0.79,-0.08,0.90,1.79,2.24,2.99,3.72,5.72,4.78,4.31,1.85,4.20,1.57,0.82,-0.23,2 -1.92,1.44,0.78,2.08,2.49,3.29,3.48,3.67,4.53,4.78,5.78,2.79,1.67,1.83,2.13,2.03,-1.29,-1.90,-0.41,-0.96,0.27,1 --1.47,1.18,0.68,0.26,-0.96,-2.55,1.25,1.91,2.69,1.78,4.69,3.59,3.22,2.10,4.87,2.36,2.54,2.54,0.50,3.08,0.47,2 --0.14,1.61,-0.29,0.46,-0.39,2.01,0.52,1.10,-0.74,1.99,2.96,4.45,5.92,4.99,2.98,5.34,3.34,1.48,2.01,0.41,0.23,2 --0.21,0.17,1.69,2.03,5.26,4.68,7.28,6.72,4.19,4.13,1.95,1.08,-0.30,0.65,-1.75,-0.08,-1.12,-0.35,-1.77,0.64,-0.29,0 -1.43,1.33,1.47,2.82,2.09,2.43,3.94,2.97,3.50,3.44,0.25,2.28,1.09,1.97,2.83,1.61,1.10,1.11,2.21,0.25,0.64,0 -0.39,-0.22,-0.44,-0.97,1.61,-1.65,1.72,-0.37,2.55,4.22,4.62,3.41,5.14,2.82,3.71,4.23,0.96,-0.36,-1.61,1.67,-1.53,2 --0.52,2.13,0.23,1.86,3.24,4.77,5.92,4.32,4.09,3.73,2.74,1.27,1.59,2.47,0.93,0.73,0.93,0.86,0.08,-1.16,0.63,1 --0.75,1.00,0.44,2.96,0.48,4.17,4.81,4.57,2.97,4.22,4.29,3.74,3.72,-0.10,0.04,-0.50,1.44,0.57,1.49,-0.86,-0.71,1 --0.12,-0.60,-0.25,-0.69,-0.06,0.22,-0.56,1.61,2.05,3.14,4.36,5.11,4.04,1.35,2.94,0.74,0.22,1.67,2.03,-1.28,-0.39,2 --0.89,0.34,0.82,-0.21,1.39,1.96,3.97,3.62,4.83,5.48,5.19,3.76,3.91,1.56,1.54,-0.17,2.71,-0.32,-0.17,-0.25,-0.07,1 -1.22,0.39,1.01,-0.56,0.78,1.79,3.73,2.07,3.68,3.74,4.83,3.54,4.13,2.81,1.16,2.42,-1.70,1.09,-0.57,-1.28,-0.43,1 --0.55,1.09,0.06,-0.02,1.02,-0.67,2.14,0.82,2.26,2.29,3.60,4.16,4.07,5.97,3.97,2.43,4.02,0.27,1.03,1.04,-0.25,2 --0.82,1.79,1.43,4.57,4.36,5.22,4.50,4.25,4.34,3.71,2.32,0.09,1.35,0.91,-0.78,0.35,-0.55,-1.72,0.69,1.10,-1.37,0 -0.66,-0.03,1.96,1.07,0.60,4.39,6.73,4.27,3.44,3.04,1.86,1.39,3.22,1.06,2.41,2.84,0.92,1.65,0.43,0.87,0.85,0 -0.24,1.61,0.62,3.42,2.35,4.76,4.85,4.39,3.33,3.91,2.81,2.67,1.62,-0.28,0.72,0.86,0.95,-1.28,2.22,0.03,-0.68,1 -0.08,-0.97,-0.05,0.63,1.83,-0.11,1.54,0.82,-0.51,0.80,0.16,3.47,3.52,5.09,6.20,5.63,4.79,3.01,1.00,-0.84,-0.15,2 --0.68,-0.71,0.18,1.26,2.63,2.31,2.43,3.09,0.10,2.19,1.63,-0.03,3.95,3.32,1.51,2.65,2.82,2.71,0.86,0.59,-0.79,0 --0.52,1.20,1.18,0.94,2.10,4.04,3.00,2.48,1.70,3.25,1.51,3.08,0.00,2.96,1.20,2.88,-0.03,1.01,-0.55,-1.10,0.86,0 --1.38,0.67,1.19,1.55,4.97,3.36,6.11,4.28,3.15,2.88,0.49,1.58,1.07,2.32,1.57,1.62,0.93,1.10,1.94,0.17,-2.71,0 --1.46,-1.60,-0.65,1.52,-0.87,1.98,1.08,0.99,5.32,4.55,5.11,4.73,4.67,4.90,3.10,2.50,1.00,0.45,0.75,-0.50,-0.87,2 --0.42,-0.06,2.15,0.78,-0.92,1.84,3.73,4.43,5.06,5.35,4.78,3.19,3.34,3.02,2.23,1.05,0.78,-1.43,0.63,-2.03,1.56,1 -0.58,-0.22,2.49,2.86,4.23,5.39,7.03,4.99,4.31,1.65,3.36,1.37,1.32,-1.60,0.33,-0.58,-0.01,-1.07,-1.54,-0.68,-0.74,1 -0.82,-1.20,-0.98,-0.43,1.20,1.22,0.16,-0.75,1.42,2.64,1.99,4.16,2.78,5.55,5.06,3.64,3.71,-0.57,2.05,1.16,-1.21,2 --0.85,-0.68,-0.63,-2.32,0.05,0.04,1.98,-1.46,0.60,-0.36,2.04,1.61,4.18,3.90,7.05,5.60,2.99,4.12,3.23,1.72,-0.17,0 -0.51,-1.24,1.38,0.05,-1.26,-0.71,0.98,0.48,0.06,0.90,2.89,4.10,2.04,5.11,6.34,5.23,3.38,1.95,3.25,0.12,-0.91,2 --0.00,-0.59,1.35,2.86,0.83,2.34,4.61,2.43,2.71,1.12,2.19,2.68,0.85,0.08,1.02,1.18,2.06,1.64,1.49,0.53,0.79,0 --0.02,0.71,0.12,0.59,-1.00,0.57,0.71,0.43,0.03,1.31,1.52,5.13,2.79,2.63,5.11,5.35,3.95,4.07,0.91,0.02,-0.89,2 --0.28,1.51,-0.44,-0.43,-1.06,0.53,2.73,1.74,2.83,1.26,5.76,3.92,4.76,3.48,4.85,4.95,1.95,0.54,-0.16,-0.85,0.09,2 -0.75,1.27,-0.03,2.03,2.76,3.58,2.83,3.27,2.04,3.54,2.03,-0.10,1.22,-0.35,1.13,0.42,0.91,0.94,1.87,-0.54,0.87,0 -1.02,-0.63,0.25,-0.25,-1.66,-0.78,1.54,1.10,0.72,3.58,3.34,2.67,3.79,4.23,4.79,3.28,1.88,1.91,0.94,-0.47,-1.71,2 --1.32,0.19,1.29,0.20,2.26,2.05,2.58,-0.21,2.68,2.80,2.72,1.52,4.24,2.81,4.57,3.62,3.98,3.20,0.70,-1.46,0.09,0 -0.92,0.38,1.13,0.17,2.32,1.38,2.25,4.24,4.02,5.50,4.91,4.59,2.69,4.02,0.41,2.18,-0.46,0.34,0.13,-0.60,1.18,1 -1.63,0.29,1.79,2.79,1.55,4.58,1.65,4.35,0.47,1.68,0.30,1.30,1.20,2.89,3.58,4.12,2.01,2.63,0.44,0.97,0.78,0 --1.09,-0.81,1.34,1.99,0.88,1.99,3.24,3.59,0.92,1.63,1.57,2.98,2.92,3.19,2.29,3.83,3.73,1.75,2.28,-3.05,0.97,0 --0.06,0.03,0.56,-0.71,-0.58,0.30,0.84,3.06,3.73,4.41,4.62,2.78,4.18,5.18,3.29,3.18,1.99,-0.66,0.87,-0.50,-0.11,2 --1.28,-1.50,0.30,-1.58,-0.07,0.81,1.19,-2.26,2.06,0.63,1.15,5.31,5.00,2.83,5.47,4.12,2.35,3.37,1.56,-0.15,-0.26,2 -0.33,0.96,1.01,2.51,1.25,2.43,5.04,3.94,2.12,3.60,1.62,2.89,2.36,-0.04,3.35,1.45,1.58,-1.14,-0.34,-0.54,-0.92,1 --0.14,0.83,0.03,0.50,1.79,0.34,1.59,1.84,3.24,3.28,5.38,6.30,2.86,3.49,3.12,2.74,1.14,1.39,-0.87,-2.45,-0.66,2 -0.01,0.94,1.83,3.38,2.29,3.11,1.39,2.69,3.82,3.22,3.67,2.22,0.77,0.14,0.93,0.43,0.88,2.41,0.53,0.32,2.09,0 -0.43,0.92,-0.55,1.18,1.60,2.11,3.05,3.09,5.31,4.85,4.06,3.57,2.60,1.14,2.08,-0.23,-0.05,-0.32,0.44,-0.12,-1.47,1 -0.68,-1.41,0.95,-0.75,0.27,-0.11,1.18,1.96,-0.36,3.40,2.60,1.44,4.24,5.74,5.75,4.89,2.97,2.61,2.45,1.49,0.14,2 --1.24,2.91,2.28,3.94,3.42,5.03,5.64,4.16,4.08,2.97,1.59,0.24,-0.27,-2.38,3.22,-0.28,0.18,-0.37,-0.27,0.76,1.24,0 -2.26,-1.63,-0.18,0.48,-0.13,0.86,1.38,2.42,4.05,4.46,4.99,3.68,4.04,1.77,3.86,1.71,2.14,0.25,2.94,0.33,-0.65,2 -0.34,-0.74,0.22,0.20,0.72,-1.30,1.10,0.49,0.19,-0.45,1.69,3.57,1.84,4.90,2.97,4.64,3.78,3.71,1.12,-1.18,0.67,0 --1.22,0.41,1.95,-1.43,0.00,2.25,2.58,1.34,3.60,5.00,4.26,4.43,1.51,1.68,2.20,0.28,0.60,-0.58,0.55,-1.86,0.38,1 --1.48,2.38,1.88,3.50,1.60,2.30,3.02,3.37,3.18,2.79,3.86,2.01,0.16,0.60,0.31,1.36,-0.05,-0.62,0.24,-0.88,-0.46,1 -0.73,2.18,1.45,3.35,4.19,5.42,2.61,5.79,3.19,2.36,2.72,0.44,0.62,1.05,-0.56,-0.86,-0.77,-0.07,1.92,-1.26,-0.60,1 --0.11,-1.19,1.64,1.32,1.35,0.22,0.21,-0.56,0.23,0.15,2.46,3.47,3.97,4.54,6.49,5.24,3.01,2.59,2.78,1.09,-1.16,0 -0.09,2.27,0.35,0.49,3.09,3.64,4.43,4.47,4.13,2.97,1.67,2.55,0.75,1.19,1.16,1.00,-1.59,0.12,1.20,0.11,0.99,1 -1.77,-0.06,-0.34,-1.51,1.75,-1.39,-0.27,-0.24,0.64,3.70,2.30,3.71,4.59,4.09,3.68,2.55,1.30,0.86,1.09,0.37,0.02,2 -0.48,0.48,0.38,-0.81,2.40,-0.55,1.39,1.75,1.78,1.12,1.97,2.25,2.22,2.44,4.23,2.53,2.40,1.71,1.59,1.32,-0.82,0 --0.72,-0.20,1.90,0.25,0.54,1.91,2.37,4.78,2.07,3.87,3.33,3.33,3.54,2.66,-0.04,-0.14,0.19,0.64,-2.57,1.46,-0.84,1 --0.46,3.33,1.47,4.02,5.30,2.47,4.81,5.39,3.52,2.11,2.73,2.42,-0.85,0.52,0.09,0.15,-0.03,-0.61,0.60,-0.95,-0.24,0 -0.25,1.76,0.01,0.60,-0.51,0.79,1.62,0.96,1.49,-0.02,3.06,3.55,6.38,3.76,5.97,3.26,1.67,1.79,1.47,1.93,-0.93,2 -0.32,-0.02,-0.14,1.56,0.76,-0.49,0.21,3.16,4.02,2.65,4.35,4.01,3.09,4.84,3.36,2.34,0.03,2.02,1.16,0.69,-1.72,2 --1.72,0.75,1.22,3.65,4.70,3.77,4.93,3.18,3.20,2.56,2.49,1.30,-0.04,0.84,0.60,0.74,1.75,-0.25,0.31,0.96,-1.24,0 -1.54,2.64,0.72,3.08,3.01,2.84,1.18,3.72,2.04,3.49,0.80,1.33,1.54,1.62,2.50,1.79,1.10,2.30,0.11,-1.46,1.79,0 -1.59,-0.75,0.04,0.80,-0.22,-0.43,0.31,0.54,1.51,3.13,4.01,3.14,4.21,5.75,6.10,4.95,3.64,1.96,0.42,0.10,0.74,2 --0.32,-1.87,0.90,0.79,-0.92,0.15,-3.32,0.27,1.10,0.51,2.61,1.88,5.68,3.92,5.81,4.91,3.73,4.66,0.91,-0.74,0.62,2 --1.53,-0.44,0.80,0.02,-1.20,2.81,3.01,3.40,3.41,5.21,5.40,3.40,3.39,4.36,2.45,0.84,-1.12,-0.23,0.84,-0.26,0.21,1 --0.12,-0.39,2.45,1.17,2.56,2.15,2.37,1.10,2.75,3.17,2.83,4.35,2.34,1.83,1.80,0.42,-0.08,-0.09,-1.32,-0.43,-1.15,1 --0.96,0.18,0.34,-1.36,-1.43,0.83,2.81,2.20,3.25,2.13,3.62,5.41,3.68,2.73,2.08,2.32,2.76,1.15,0.80,1.41,-1.38,2 --0.04,0.30,1.20,2.38,3.22,4.97,4.57,3.71,4.04,2.05,3.51,1.38,0.45,0.79,0.16,1.14,-0.43,-0.61,-2.05,0.16,0.19,1 -1.60,0.63,0.58,-0.56,1.47,0.95,3.68,5.06,4.81,6.62,6.06,2.33,2.42,2.38,2.27,1.76,-0.33,-0.30,0.17,-0.67,-2.09,1 -0.39,-0.20,2.55,3.58,4.14,5.34,4.17,3.63,3.32,4.51,2.97,0.20,0.99,-1.56,-0.23,-0.76,0.01,1.92,0.15,-0.71,0.87,0 -1.09,0.34,1.91,2.05,2.64,3.23,3.96,2.98,0.70,1.74,1.74,1.94,1.85,1.95,2.05,2.92,2.76,2.32,0.69,1.45,-1.08,0 -1.14,-0.56,0.17,0.12,1.56,2.59,3.16,2.43,3.21,4.71,5.97,4.64,4.66,2.01,4.16,1.71,-0.06,0.22,0.48,-1.84,-1.31,1 --0.97,0.94,1.25,2.36,0.99,3.86,2.37,3.81,4.66,4.79,4.12,3.24,3.53,1.26,2.48,0.87,-1.21,-0.13,-0.09,-0.09,-0.42,1 --0.44,-0.60,-0.71,0.02,-0.01,-0.63,0.63,2.82,4.32,2.48,6.53,7.29,5.54,2.74,2.91,2.35,-0.08,1.55,0.24,-1.17,-0.89,2 --2.25,2.01,0.99,1.99,3.34,4.54,4.66,3.69,4.22,3.02,-0.11,2.87,-0.82,-0.75,-0.29,2.45,-0.40,0.89,0.54,-1.38,-0.16,0 --0.20,-0.28,0.06,0.86,0.78,1.73,1.82,2.73,2.80,4.35,6.59,3.61,2.33,0.60,1.62,1.11,1.22,0.03,-0.11,0.37,-1.84,1 -0.76,-0.79,0.82,0.33,0.64,2.15,2.59,3.32,4.75,4.46,5.72,6.80,2.29,3.06,3.12,2.19,0.48,-0.35,0.79,0.42,0.34,1 -0.50,-0.39,1.56,3.21,2.83,3.27,5.23,4.47,3.59,1.58,1.63,0.73,1.84,2.86,-0.28,2.33,1.46,2.20,-1.56,0.49,0.62,0 -1.05,0.16,-0.26,0.11,1.65,1.11,0.31,1.62,3.60,3.17,6.92,3.81,4.25,2.15,1.40,0.37,-1.48,-0.19,-0.96,0.07,-1.05,1 --0.85,1.07,0.27,-1.52,1.54,-0.66,-0.63,1.02,2.20,2.84,4.69,3.85,4.20,4.21,4.03,2.65,1.02,2.23,-0.76,0.69,0.86,2 --0.38,1.22,0.45,3.62,2.24,3.62,6.60,5.07,4.14,3.62,1.42,0.57,1.45,0.26,-0.67,-0.90,0.40,2.28,-1.96,-0.50,0.92,0 --0.34,1.08,-0.70,1.13,-0.18,-1.19,-1.01,-0.80,1.56,-1.38,0.67,4.08,3.96,5.70,7.21,3.86,4.56,3.29,1.93,0.87,-0.47,2 --1.05,0.59,1.09,1.59,3.13,5.55,2.51,4.23,3.61,2.16,1.64,2.26,0.31,1.05,1.96,0.18,0.81,-2.15,0.48,-0.10,-0.35,0 -0.29,1.47,0.42,0.61,-0.32,1.70,1.74,2.05,3.72,4.67,5.10,5.36,4.46,4.23,1.34,0.81,0.45,0.45,0.67,0.34,-1.92,2 -0.06,-0.70,0.65,1.84,2.19,4.06,4.21,2.34,3.46,4.60,3.97,4.45,3.84,1.75,1.12,-0.63,-0.19,-0.02,-0.53,0.67,-0.70,1 -2.55,0.44,3.17,3.74,4.35,4.90,5.75,5.44,5.39,2.98,3.75,2.40,1.40,-0.47,2.14,0.31,-0.60,0.11,-1.72,-1.29,1.21,1 --2.00,-0.44,0.13,-1.41,0.27,-2.76,1.17,2.28,1.16,3.78,1.48,2.97,5.30,3.84,3.85,4.27,4.50,4.24,2.17,-0.10,1.87,2 --0.92,-0.04,2.71,2.57,2.50,5.31,5.11,4.36,3.51,2.18,1.60,0.92,2.03,1.22,1.26,1.23,-0.56,0.50,0.57,0.16,-0.27,0 -1.29,-0.45,1.56,3.21,2.59,2.17,5.53,4.63,4.89,4.64,4.08,4.77,2.43,2.87,0.58,0.38,-0.56,-1.50,-1.13,-1.22,-0.08,1 -1.02,1.76,2.48,4.25,4.16,5.46,6.61,3.52,3.73,4.38,3.68,1.07,-0.65,1.09,-0.37,-0.41,-0.25,-1.04,-0.12,0.33,0.20,1 -1.68,0.14,2.77,2.97,4.35,4.67,6.27,4.70,4.29,3.95,2.23,-0.01,0.49,-0.50,-1.20,-0.84,0.57,2.01,0.11,0.73,-0.65,0 --1.30,0.03,-0.01,1.10,2.78,5.03,4.73,5.21,5.02,4.49,4.82,5.81,1.83,2.10,0.85,1.59,0.04,-0.70,1.83,0.14,0.26,1 -0.63,0.96,-0.25,1.56,-0.97,0.14,0.73,0.32,1.48,1.63,2.33,5.10,3.91,2.59,6.12,3.88,2.46,1.68,1.40,0.87,-0.67,2 --0.16,1.40,-1.54,1.42,1.92,1.14,0.59,-1.51,0.92,2.94,2.85,2.79,3.61,4.34,5.27,4.51,3.08,1.73,2.43,1.09,1.26,2 -1.69,-1.79,1.00,-0.15,2.77,0.63,1.42,-0.12,0.50,2.55,1.32,4.16,4.48,4.78,4.87,4.18,3.83,4.18,2.46,-1.32,1.15,2 --0.23,0.46,2.31,-0.54,1.59,-0.99,0.34,2.27,0.49,-0.44,0.47,2.11,3.99,2.38,3.84,3.03,3.43,1.94,1.13,0.49,0.14,0 --0.88,1.55,1.48,0.52,1.97,1.84,3.98,2.79,2.58,0.91,2.47,3.00,2.62,3.79,4.29,2.97,1.02,1.47,0.98,0.77,1.01,0 -0.33,0.44,1.79,0.49,0.51,2.17,4.48,1.79,4.48,3.27,6.18,4.14,3.10,3.82,-0.89,0.60,-1.01,1.75,0.29,-0.16,0.64,1 -0.32,1.50,-0.47,1.33,0.78,0.88,1.93,1.82,2.96,1.94,4.82,4.20,3.09,4.88,4.16,1.80,1.95,1.35,1.20,1.94,-0.99,2 -1.40,0.54,0.96,2.16,2.33,2.53,3.74,4.17,4.94,4.03,5.25,3.13,1.04,2.37,3.63,-0.08,-1.57,-0.85,0.57,-0.59,0.15,1 -0.11,-1.27,1.44,3.02,2.06,3.18,3.19,5.42,3.19,3.22,3.96,1.33,1.89,0.57,1.96,1.41,1.12,0.23,0.16,-0.86,0.43,1 --0.90,1.07,-1.49,0.18,0.71,0.96,2.93,3.21,3.00,3.49,3.71,5.88,6.92,5.35,2.40,0.13,0.11,1.86,0.27,0.13,1.39,2 --1.30,1.01,1.01,0.04,1.35,2.12,1.33,2.49,4.93,3.66,4.60,4.31,2.87,1.68,0.91,1.39,1.01,0.22,-0.23,1.40,0.12,1 -0.23,0.51,0.72,1.40,0.79,1.37,3.11,2.77,4.16,5.37,5.64,4.09,3.56,3.71,4.46,-0.16,-0.78,-0.82,0.03,-1.07,0.51,1 --1.01,1.80,-0.02,0.98,2.59,2.40,3.79,3.00,4.23,4.54,3.96,1.69,-0.86,0.28,0.46,0.11,-0.80,0.14,0.82,-0.00,0.12,1 --0.84,1.60,2.42,0.25,1.64,2.93,4.26,3.68,3.05,1.88,1.93,1.08,-0.35,0.13,3.31,2.19,0.72,-1.33,-0.49,0.76,-2.33,0 --0.01,-1.28,1.74,2.72,4.46,3.40,3.90,2.74,3.02,2.83,2.06,0.74,0.56,0.85,2.19,2.03,1.55,1.27,0.97,-0.20,-2.04,0 -0.46,-0.70,1.89,0.90,0.76,0.97,2.73,2.73,5.31,4.86,2.17,3.83,2.31,3.34,1.96,0.80,-1.57,-0.01,0.86,-0.10,-0.91,1 -0.22,-0.50,-0.14,-1.12,1.04,1.28,-2.30,0.52,1.35,2.41,1.25,2.31,5.10,4.65,5.87,2.81,5.46,2.98,2.36,-0.02,-0.12,2 --0.10,1.52,1.42,0.31,1.65,2.79,2.95,2.09,2.35,3.98,3.14,3.09,2.25,3.49,3.98,0.82,3.14,1.48,1.74,-0.16,-1.44,0 --1.96,-0.41,0.68,1.99,1.63,2.69,2.27,2.78,4.50,2.03,1.66,1.80,2.44,2.09,2.57,0.78,1.42,2.25,1.07,1.68,-0.53,0 --0.68,0.45,-0.70,0.34,-0.54,-0.52,-0.98,-0.27,-0.21,2.29,0.90,3.38,5.16,4.60,5.17,5.56,5.02,3.89,1.73,1.63,0.90,2 -0.41,-0.50,1.39,1.77,1.73,0.58,2.96,3.64,3.88,3.18,4.63,2.08,3.46,1.82,2.76,1.92,-0.99,-0.59,-0.63,1.16,-2.05,1 --1.26,-0.05,0.75,-1.13,-0.26,2.30,-0.42,2.00,1.17,0.39,3.77,2.89,4.51,5.10,2.83,3.27,3.85,2.51,1.17,0.42,-0.88,2 --0.74,1.93,-0.26,0.03,0.05,-0.12,1.43,-1.04,-0.69,2.51,1.71,2.16,2.99,3.39,6.72,5.91,4.32,3.84,2.63,-0.24,0.94,2 --0.23,0.62,0.97,-0.83,-0.03,0.39,0.18,1.14,0.16,1.51,3.11,5.14,1.78,3.04,5.21,3.90,2.96,2.31,3.45,1.48,-0.45,2 -0.93,-0.28,-0.78,-0.00,-1.18,0.64,2.07,1.40,1.26,3.33,2.89,4.84,4.00,2.33,3.21,1.18,1.62,1.13,0.64,0.22,0.68,2 -0.38,1.20,0.34,3.30,1.85,4.39,3.66,4.54,2.72,3.90,3.81,1.66,1.14,0.36,1.42,1.63,1.47,1.81,-0.68,0.82,-0.63,0 -0.19,3.18,1.81,1.48,2.09,4.75,5.05,2.84,2.36,2.28,1.16,1.71,-0.12,0.89,0.40,0.87,-0.33,-0.29,-1.31,-0.25,-1.18,0 -0.92,1.57,-0.31,0.14,1.35,0.61,-1.12,2.01,2.81,2.82,3.42,3.14,3.33,5.35,4.11,3.92,3.00,1.43,2.45,1.92,0.82,2 -0.57,1.18,1.63,4.19,3.35,3.98,4.35,4.22,2.91,0.49,1.51,3.35,1.08,0.98,2.29,0.97,2.54,0.86,-0.59,0.05,-0.84,0 -0.68,-1.83,-0.35,2.45,3.45,3.37,5.04,3.13,2.83,3.49,5.45,1.30,1.59,1.29,-0.24,-0.62,0.81,0.13,0.33,1.37,-1.10,1 -1.31,1.17,0.95,0.48,3.48,3.40,5.49,5.09,4.46,2.88,2.92,0.98,0.15,0.27,-0.03,0.26,0.98,-0.70,-1.28,-0.81,0.32,1 -1.16,2.03,0.42,1.55,2.32,4.50,5.55,2.86,2.82,4.86,2.32,2.29,2.39,2.29,1.51,1.56,1.54,-0.13,1.16,1.15,1.15,0 --0.96,1.81,0.58,0.61,-1.44,1.16,0.31,0.65,0.02,0.68,2.01,1.13,3.16,5.86,4.82,5.40,5.00,2.95,1.06,0.36,2.76,0 -0.82,-0.61,-0.34,0.98,1.04,1.61,0.69,0.68,-0.93,0.87,2.64,2.00,3.26,2.68,5.21,2.83,3.97,0.99,3.45,-0.19,-0.39,0 -1.11,0.32,-0.14,0.08,0.75,0.07,-1.23,1.50,1.23,3.42,5.44,3.36,2.88,3.27,3.98,4.13,2.35,1.79,0.63,3.53,0.37,2 --1.16,-1.14,1.11,0.56,-0.42,3.39,2.30,3.46,2.27,3.43,4.38,4.23,2.67,3.35,4.13,-0.25,-0.07,0.92,-1.11,-1.48,-1.69,1 -0.25,-1.09,0.60,-0.93,-0.05,0.19,2.34,0.28,-1.30,1.13,2.90,2.76,2.87,5.73,5.10,2.54,3.67,2.82,2.09,0.41,-1.45,2 -0.28,0.13,1.13,3.57,2.95,2.93,5.10,2.52,2.66,1.49,0.46,1.53,1.96,2.71,3.41,3.04,1.00,0.83,1.94,1.64,0.40,0 -1.69,0.32,3.05,2.49,1.02,4.38,4.97,4.71,3.19,3.71,4.69,-0.32,2.46,2.41,1.79,-0.13,-0.88,0.15,0.43,-1.48,-0.21,1 --0.76,0.06,0.04,-0.06,1.62,1.32,2.38,4.95,5.99,6.46,6.79,6.34,4.75,2.46,1.17,0.97,-0.50,-0.29,0.22,1.26,0.23,2 --1.59,1.88,1.02,2.45,4.03,3.43,5.16,4.26,3.31,2.93,1.18,1.23,1.35,0.91,0.31,-0.35,-0.72,2.69,-1.58,1.58,1.26,0 --0.04,0.40,-0.70,-0.06,0.30,1.82,3.22,4.61,5.59,3.40,3.47,4.35,1.89,2.50,1.73,0.59,-0.73,-1.22,-1.11,0.88,0.50,1 --0.94,0.63,-1.13,1.06,-0.89,2.28,0.56,2.76,4.64,5.12,4.50,4.98,3.33,3.55,2.68,1.56,-0.61,-1.15,1.17,-0.53,2.03,1 --0.91,1.11,0.38,0.40,2.22,3.61,2.99,2.57,1.03,0.34,1.42,3.09,3.23,2.64,2.57,3.48,2.15,3.17,1.49,-0.30,0.11,0 -0.91,1.48,1.87,2.43,3.49,1.30,5.35,4.42,2.01,2.43,2.37,2.52,2.27,2.71,0.81,1.52,2.17,0.07,-0.82,0.83,-1.33,0 -0.69,0.74,1.29,-0.84,-0.07,2.05,2.46,4.58,4.93,4.87,6.20,5.32,3.77,3.81,0.90,0.90,0.99,-0.09,0.03,-1.10,0.64,1 -3.29,-0.72,-0.57,1.00,-0.11,0.14,-0.28,2.04,2.04,4.97,3.45,4.02,3.44,2.33,4.33,1.91,1.39,2.67,-0.28,0.36,1.22,2 -2.26,0.42,-0.51,-1.08,-0.05,-0.40,4.08,2.94,1.60,5.70,5.83,4.33,4.32,2.60,2.91,1.40,0.23,2.31,0.33,0.93,-0.48,2 -1.06,0.48,2.72,1.35,2.92,3.21,3.79,1.10,0.07,0.72,1.36,2.05,2.79,2.27,4.94,2.48,2.46,0.09,1.77,0.89,-0.59,0 --1.38,0.66,1.26,2.10,4.16,4.91,5.95,4.75,2.05,0.99,1.46,2.14,3.14,-0.13,1.81,1.43,-0.02,0.96,0.37,-0.37,-1.15,0 -0.50,-0.70,2.87,1.80,2.24,5.09,4.24,4.34,3.14,2.72,4.35,1.80,1.16,1.75,0.00,0.34,1.19,-0.56,-0.95,0.82,-0.30,1 --0.08,1.56,0.62,-0.57,-1.35,0.13,2.85,3.34,3.59,5.16,5.96,3.84,3.41,1.82,3.00,1.74,-0.39,0.96,0.29,-0.24,-0.79,2 -2.29,-1.55,-0.67,0.17,-1.56,2.07,0.12,-0.69,2.91,2.18,3.33,3.69,3.87,4.17,5.02,2.70,0.29,1.88,1.43,1.34,-0.10,2 -0.86,1.32,0.50,2.79,4.05,5.40,5.32,5.20,3.56,3.46,3.36,1.90,-0.45,1.52,-0.42,1.25,-1.47,-0.16,1.58,-0.43,-0.91,1 -0.11,-0.15,1.98,2.62,3.13,3.76,4.84,3.47,5.52,4.55,3.74,1.81,-0.06,0.10,0.99,-0.05,-0.21,-1.42,-0.96,1.12,-1.37,1 -0.04,0.53,2.51,3.51,2.59,2.28,4.97,4.91,3.82,3.42,3.54,1.43,1.10,0.42,1.49,-0.07,0.84,0.34,-0.18,-0.48,0.20,1 --1.01,-0.80,-0.15,1.33,-0.84,1.57,0.84,2.44,3.22,6.27,4.85,5.43,6.20,4.82,2.71,0.59,0.12,-0.04,0.37,0.18,0.96,2 --0.37,0.64,4.35,4.06,1.53,3.20,6.00,3.70,1.86,2.67,2.84,1.10,1.54,0.86,2.65,1.67,0.45,0.39,1.77,0.51,-0.74,0 --0.90,0.03,0.96,1.44,2.61,2.62,4.23,3.85,2.11,3.58,0.98,2.63,2.99,0.61,2.91,1.79,1.08,1.87,-0.27,-0.26,1.09,0 --0.10,0.52,1.57,0.46,3.64,4.49,3.83,2.19,3.36,3.95,2.23,1.18,1.24,0.69,-0.11,0.45,0.28,0.87,-2.25,-0.70,0.64,1 -0.09,-0.01,0.68,1.51,-1.46,0.12,0.70,2.60,3.43,4.91,4.68,5.11,3.62,3.51,3.98,0.68,-1.49,-0.77,-0.90,-1.23,-0.49,1 --0.73,-0.10,0.75,1.55,0.43,0.21,0.29,-0.14,0.26,1.69,3.18,4.01,2.78,3.95,5.63,3.57,4.09,2.53,2.59,1.34,0.21,0 -0.10,0.41,2.28,2.30,1.59,3.84,5.07,3.11,3.66,1.90,2.37,1.39,-1.95,0.52,3.16,-0.55,2.16,1.26,0.36,-1.55,1.26,0 -0.63,1.93,1.23,3.25,3.93,6.03,6.63,5.20,2.84,0.75,2.62,2.00,1.66,-1.36,0.53,-2.14,-0.99,1.02,1.68,0.61,0.13,0 -1.63,-2.03,-1.30,0.68,1.26,0.96,2.86,5.16,3.11,5.11,4.08,3.88,3.90,1.21,0.43,-2.19,2.00,0.72,0.30,1.13,0.54,1 --0.09,-0.82,0.57,-0.77,-0.81,0.58,0.31,2.81,2.22,4.78,5.97,4.45,4.46,4.59,4.11,5.02,3.24,1.45,1.04,0.14,-1.88,2 --0.04,-0.25,1.34,2.37,2.90,3.40,3.97,1.35,2.61,1.13,3.10,2.23,1.12,0.57,1.70,2.41,1.40,0.74,1.84,-0.81,0.27,0 -0.34,1.66,1.15,4.03,2.87,3.57,6.65,5.27,4.27,1.39,2.52,0.28,0.29,-0.77,-0.25,0.88,-1.07,-0.55,0.72,0.20,0.46,1 --0.45,0.17,-0.51,0.42,0.10,1.39,1.50,2.15,3.07,2.66,4.63,4.83,4.88,1.55,2.15,1.83,-0.45,-0.06,-0.91,-1.77,0.67,1 --1.64,-0.10,-0.49,-1.08,0.47,-0.42,-0.90,0.52,2.21,2.20,3.82,3.94,4.27,4.65,5.28,2.39,4.78,2.04,1.13,0.22,0.61,2 -1.08,-0.64,-0.18,1.43,-1.44,-0.74,1.41,2.30,2.07,2.99,1.93,3.75,3.43,4.38,3.85,2.78,1.25,0.70,1.42,-0.44,-0.11,2 --0.49,-0.31,2.88,2.71,2.96,3.62,5.42,5.96,3.05,2.43,3.04,-0.04,1.17,0.61,1.03,-1.51,-1.00,0.23,0.21,-1.32,-0.31,0 -0.39,1.16,2.18,2.83,2.65,2.84,5.35,4.00,2.34,2.22,1.38,2.50,1.59,1.26,1.21,2.82,0.94,1.26,3.50,0.09,2.28,0 --0.40,-1.39,1.73,0.38,2.49,1.97,2.95,1.99,1.33,1.74,3.13,2.76,4.02,4.82,1.63,2.62,2.16,0.35,0.33,0.18,-1.60,0 -1.19,0.46,0.10,0.07,2.11,4.23,3.17,4.12,2.47,2.12,3.04,1.57,-0.40,2.01,2.96,3.12,0.59,0.13,0.63,-2.36,-0.49,0 -0.81,0.61,3.23,3.43,3.54,4.74,3.22,5.09,5.78,2.87,2.87,1.04,1.50,1.43,0.48,0.49,0.20,0.16,-1.06,-0.33,-2.56,1 --1.11,2.60,-0.91,-0.76,0.84,-2.46,0.23,1.46,1.05,2.18,4.02,2.61,3.52,3.91,4.74,3.80,3.38,1.94,3.31,-0.36,0.67,2 -1.07,-2.46,-1.30,1.67,-0.09,0.85,1.45,0.69,1.06,1.64,3.23,3.37,3.93,4.78,6.92,2.85,3.30,2.27,2.07,1.40,-0.50,0 -0.24,-1.24,-2.03,-0.05,0.57,1.40,-0.59,0.96,2.13,0.72,4.49,3.46,3.04,3.33,3.06,3.24,0.17,2.38,0.32,0.12,-0.27,2 --0.96,0.39,0.05,2.23,2.69,2.45,2.48,3.68,3.62,4.50,3.66,4.38,3.35,1.69,1.88,0.61,0.14,-0.58,0.07,-0.15,1.36,1 --1.71,0.71,0.75,2.40,1.56,3.38,2.28,2.58,1.32,2.50,1.18,2.35,2.60,4.69,3.79,3.44,1.85,3.75,-0.56,0.47,-1.45,0 --0.15,-0.80,0.79,1.36,0.21,2.38,2.14,3.78,4.20,4.35,4.80,3.63,3.52,2.76,2.84,1.78,-0.79,0.69,-0.25,0.89,0.73,1 --0.28,-0.08,-0.50,-1.62,-1.59,0.85,1.99,1.22,0.01,2.98,4.96,3.84,4.29,6.10,3.26,1.44,1.08,0.09,-0.15,-0.84,-0.25,2 -0.73,1.53,2.16,1.60,4.67,3.00,3.25,5.32,2.55,1.18,1.66,1.15,2.12,1.44,3.14,1.48,1.68,2.66,-0.68,-1.34,-1.88,0 -2.72,1.13,0.68,-0.53,0.43,-2.35,2.01,1.73,1.13,1.13,1.30,4.93,3.89,4.86,4.58,3.56,4.35,0.58,0.99,0.66,2.07,2 --0.55,-0.88,1.75,-0.43,-1.84,-0.13,1.59,-0.53,-0.19,2.70,5.29,5.10,2.72,4.82,4.35,4.40,3.68,2.35,1.93,3.02,-1.50,2 --0.61,0.04,-0.84,0.24,0.17,-1.01,3.48,4.66,4.19,2.28,4.90,3.55,3.30,1.86,1.77,1.38,-0.54,0.69,1.54,-0.67,2.16,1 --0.26,0.17,0.85,1.22,0.91,0.61,3.69,4.15,4.05,5.34,4.95,3.94,2.16,0.58,0.79,2.39,-0.80,-0.40,0.11,1.33,0.81,1 --1.65,-0.07,-0.75,-0.21,1.78,1.02,3.87,3.65,2.97,5.64,4.06,6.09,5.05,1.32,2.17,0.85,-0.48,-0.59,-0.53,2.37,1.15,1 -0.97,2.11,-0.09,0.95,-0.53,1.43,-0.42,0.47,2.37,-0.67,2.42,3.18,2.65,4.27,4.10,1.84,2.70,1.55,2.62,1.60,-0.33,0 -1.16,-1.37,1.44,-1.09,0.78,2.31,3.94,4.31,7.77,3.40,5.39,2.97,3.79,2.32,1.41,1.22,-1.15,-0.99,-0.36,-0.00,-1.52,1 -0.09,1.54,3.66,-1.30,2.05,3.84,3.43,7.31,2.72,2.11,0.49,2.80,1.30,2.77,1.28,0.38,0.22,-0.73,-0.71,-0.11,0.39,1 --0.12,-0.29,1.83,-1.01,0.49,2.28,3.77,4.05,4.97,6.05,5.64,4.01,1.69,2.33,1.56,1.17,-0.18,1.83,-0.33,-2.28,-0.12,1 -0.92,-0.58,2.41,-0.86,-0.25,1.42,2.49,3.07,4.05,4.23,6.38,3.87,3.27,3.23,0.45,0.76,0.27,-0.49,0.30,0.80,-0.57,1 -1.39,-0.20,0.01,0.11,-0.98,0.71,1.33,2.04,3.17,2.48,4.18,4.58,5.10,3.94,4.43,3.42,4.41,1.44,0.99,0.20,-1.03,2 -0.07,1.98,3.38,1.25,5.73,6.76,6.58,2.82,3.02,5.58,3.94,0.73,0.72,-0.35,1.32,-1.04,0.73,0.67,-0.03,0.33,1.29,0 --0.24,0.90,0.44,3.29,4.28,4.92,5.48,5.36,4.36,2.60,2.16,0.46,0.47,0.55,-0.73,-1.42,0.01,-0.28,-0.12,-0.07,1.61,0 -0.66,-1.10,1.11,2.69,4.46,2.21,3.04,5.82,4.42,2.84,5.05,5.48,3.07,1.42,2.91,-0.37,-2.30,0.18,0.55,0.54,-3.45,1 --1.40,-1.56,0.47,0.24,0.78,1.99,2.05,2.54,5.10,7.53,6.96,5.40,3.94,3.13,0.03,0.26,-1.27,-0.44,-0.20,-1.27,-0.72,1 -0.42,0.58,1.21,2.20,0.06,1.59,0.68,1.72,1.87,0.58,1.94,1.64,3.12,5.24,3.81,2.49,4.00,1.07,1.63,1.51,-2.14,0 -0.37,-0.00,1.83,3.98,2.71,4.47,3.27,2.33,3.66,3.96,2.19,-0.72,2.27,3.10,1.05,2.01,0.27,1.09,-0.09,0.11,-1.52,0 -1.54,0.40,0.07,-0.08,2.57,5.20,5.34,4.14,5.03,3.96,3.31,4.70,0.88,2.78,0.66,-0.38,0.56,-0.03,0.55,-0.02,0.37,1 --2.15,1.79,0.58,0.63,1.63,2.19,0.20,0.80,1.47,1.10,2.29,2.13,2.27,3.97,3.91,4.54,2.88,2.59,-0.68,1.15,-0.37,0 --0.88,-0.53,0.94,0.30,1.47,2.84,4.52,2.37,4.94,5.00,3.16,5.29,3.32,2.12,0.55,0.92,-1.28,2.26,0.41,0.12,-0.76,1 --0.79,0.01,1.62,-0.63,0.27,-1.12,-1.07,1.62,-0.79,0.79,2.34,3.53,3.74,2.09,7.64,3.87,3.58,0.37,3.01,1.46,-0.12,2 --0.28,-0.67,1.17,-1.02,-1.67,-0.30,2.60,2.17,2.70,6.08,6.70,4.81,2.49,1.12,1.84,2.43,0.61,-0.65,1.03,1.17,-0.60,2 --0.02,0.14,0.87,0.82,3.86,1.92,2.12,4.60,4.36,2.67,2.84,1.55,1.04,2.15,1.47,0.67,0.04,0.67,-0.93,1.18,-0.23,1 --1.03,-0.51,0.05,0.80,-0.52,0.06,-0.09,-0.71,-0.15,-0.06,2.30,2.63,3.46,5.28,4.97,4.46,2.96,2.78,1.24,0.30,0.14,2 --0.55,-1.06,0.85,-0.82,1.81,1.06,0.14,3.09,4.08,3.50,3.78,3.34,4.15,1.86,1.98,0.88,0.35,1.83,-1.71,-0.16,-1.99,1 -0.56,-1.32,-0.49,0.18,1.05,-0.09,1.33,-0.24,-0.25,2.00,0.69,4.25,4.27,1.75,5.36,4.47,3.77,3.20,3.14,2.56,-0.00,2 --0.46,1.79,4.54,2.27,4.16,5.17,4.95,4.09,3.49,3.09,1.24,2.75,-0.78,0.97,2.07,0.79,1.45,1.08,-0.31,-0.40,-0.38,0 --1.14,0.97,0.78,3.61,4.80,5.64,6.55,6.50,4.81,3.67,0.68,0.43,0.02,0.65,1.23,-0.21,-0.28,2.02,0.20,-0.79,-1.66,0 --0.40,0.59,0.11,-0.02,0.07,1.96,1.19,1.01,1.54,3.11,2.89,2.35,5.13,4.48,3.93,4.73,3.67,2.38,1.69,0.38,-1.98,2 --0.71,0.02,0.59,1.65,2.84,3.82,3.31,1.75,1.91,3.34,1.27,1.23,1.57,1.69,1.19,2.50,0.75,3.10,-0.32,0.85,-0.74,0 --1.13,1.19,0.06,1.14,1.63,3.70,3.41,2.57,4.50,2.17,1.89,2.02,0.87,2.14,1.36,1.71,0.64,0.91,1.27,0.31,-0.46,0 -0.41,-0.96,0.14,0.61,0.63,1.12,1.37,2.57,2.93,5.50,5.46,4.98,3.66,1.98,2.45,1.48,-0.56,0.98,-0.87,1.51,-0.32,2 -0.13,-0.09,1.43,-0.05,0.90,3.32,3.23,2.58,1.76,1.32,3.58,3.87,2.10,1.59,4.10,1.64,-0.98,1.88,0.14,-0.11,-1.10,0 -0.61,-0.85,-1.41,0.18,0.29,-0.90,0.70,-0.25,-1.52,1.46,1.59,3.18,4.52,4.73,4.71,5.95,3.21,3.45,0.53,0.33,-0.09,2 -0.20,0.97,-0.12,2.43,-1.09,1.41,2.70,2.80,4.55,5.45,4.60,4.48,3.88,2.32,2.57,1.12,2.32,-0.23,-1.76,-0.63,0.97,1 -0.28,0.03,1.46,2.90,2.90,4.51,6.41,2.93,4.88,4.95,3.83,2.11,-2.05,2.41,-0.57,2.33,0.48,-0.19,0.37,-0.81,0.15,1 -0.65,-2.21,0.34,0.17,1.38,-0.15,1.90,2.85,2.89,2.96,5.86,5.19,3.66,4.07,2.51,2.39,0.72,1.47,1.32,1.44,-0.00,2 -0.33,0.34,-0.09,-0.91,-0.74,0.62,1.59,3.33,4.52,3.81,5.45,5.23,2.92,3.25,1.67,1.69,-0.48,-1.57,1.36,1.17,0.34,2 --1.03,-0.41,-0.67,1.55,0.56,1.72,0.87,3.64,1.45,5.08,5.08,4.57,2.70,2.71,2.61,3.01,0.14,1.23,-1.26,-0.32,0.17,2 --1.40,-1.72,1.18,-1.86,2.66,2.17,1.77,4.19,4.39,4.31,6.01,1.53,4.33,4.19,2.38,0.52,0.61,-0.17,-1.40,1.33,-1.73,1 -0.72,0.69,1.03,0.08,1.36,0.11,0.56,-0.69,2.36,0.01,3.22,2.87,2.24,3.79,4.09,3.59,5.16,2.11,2.17,0.85,2.02,0 --0.27,-0.63,0.37,0.77,1.53,3.14,3.48,3.38,4.97,3.30,2.26,4.68,1.13,1.74,1.74,1.36,-0.24,-0.97,1.37,-0.33,-0.17,1 --1.53,-0.17,-1.18,0.70,1.74,2.70,3.57,2.06,1.93,1.58,3.19,0.06,1.74,1.69,3.65,1.87,0.99,3.36,1.35,0.94,1.61,0 --0.80,2.38,2.08,1.94,1.17,5.01,5.93,3.44,3.05,3.14,0.70,1.82,2.47,2.91,1.92,-0.50,-0.78,-0.05,1.55,0.68,0.85,1 -0.23,-0.55,0.94,1.82,1.62,0.79,0.57,2.32,1.07,3.02,0.33,2.37,2.12,2.67,2.99,2.97,2.97,0.54,1.96,-0.04,0.05,0 -0.74,-1.43,-1.46,-0.18,-1.55,1.43,1.90,3.79,1.79,6.74,6.35,5.10,2.25,2.27,2.17,1.16,-1.00,1.43,0.81,0.01,0.41,1 --0.27,0.87,1.11,1.75,3.55,3.20,4.67,1.94,3.62,1.56,0.40,-1.45,-0.03,2.78,4.56,1.73,0.53,2.16,0.40,0.52,2.98,0 -0.03,-0.08,-0.96,0.90,0.29,1.11,1.69,1.76,1.18,1.30,3.67,3.73,3.33,2.96,5.50,3.33,3.72,2.69,1.30,-0.78,0.62,0 --1.94,-0.35,-0.26,1.20,0.58,0.12,-0.81,0.35,1.79,4.91,2.56,4.99,4.24,2.52,2.87,4.19,0.72,3.27,0.91,-1.32,1.54,2 -0.29,-0.20,2.23,0.20,4.30,3.92,3.80,3.86,1.85,1.02,0.10,0.79,2.55,1.22,2.57,0.51,1.02,0.25,0.90,0.34,1.62,0 --1.50,-1.03,1.09,1.90,0.68,1.63,3.16,2.09,1.52,0.88,2.11,1.92,2.17,2.16,4.71,4.54,3.29,3.58,1.15,-0.51,0.41,0 -1.74,2.23,1.97,1.45,2.82,5.95,6.17,5.66,3.24,4.38,3.94,1.76,1.86,0.74,-0.19,1.90,0.32,2.79,0.27,1.31,-1.99,1 --0.40,1.17,2.75,1.66,2.85,2.53,5.20,5.11,4.05,0.99,1.59,2.91,0.49,1.97,-0.50,2.61,0.49,1.06,0.26,1.08,-2.49,0 --1.29,-3.10,-0.17,-1.32,-0.07,0.34,1.17,1.41,0.27,0.59,1.37,3.27,4.92,5.05,5.68,4.45,3.79,3.66,2.56,2.28,1.74,2 -0.64,-1.41,1.50,-0.15,-0.76,0.62,1.45,1.58,3.05,5.20,4.44,4.04,4.31,2.16,0.86,0.11,1.43,0.10,1.00,0.28,-1.38,1 -0.26,0.38,-0.75,-0.65,-0.68,2.02,2.88,2.68,2.62,5.69,6.27,4.57,4.92,2.87,0.54,0.54,-1.23,-0.95,1.07,-1.73,0.69,1 -0.52,0.16,-0.40,1.51,1.14,0.55,0.08,0.70,1.51,1.46,1.98,2.51,3.19,5.46,5.20,6.42,3.97,2.51,2.84,1.75,-1.12,2 -1.11,1.81,1.18,2.19,0.86,2.94,5.21,3.95,3.26,3.63,4.18,3.62,4.12,1.96,1.74,0.55,0.77,0.28,0.18,0.10,1.49,1 --0.85,-0.71,0.26,1.61,3.16,1.78,2.37,3.70,3.01,1.11,4.99,3.81,2.33,1.06,3.63,2.54,3.34,1.86,0.05,2.38,-1.65,0 -1.07,1.45,0.84,0.66,2.25,3.47,3.45,4.93,2.37,1.88,1.39,2.29,1.47,2.57,4.89,-0.61,1.85,2.18,-0.15,1.37,-0.28,0 -0.43,0.27,0.94,2.89,2.40,4.37,5.51,3.76,2.37,3.04,1.73,2.15,2.45,3.19,0.67,0.42,1.33,1.30,3.12,-0.46,0.08,0 --1.69,2.41,0.37,2.63,3.24,2.69,3.98,2.72,3.58,3.87,5.97,3.82,1.44,0.94,1.58,1.91,0.01,0.20,-1.88,-0.09,-1.39,1 --0.30,-0.13,0.05,0.72,4.40,3.76,6.04,4.87,2.49,4.87,4.07,1.33,2.53,0.43,0.76,1.13,-1.64,0.28,-0.47,-0.08,-1.32,1 --0.66,0.62,0.46,1.47,0.61,2.10,2.81,1.55,0.73,0.53,1.49,0.55,1.94,3.15,4.16,3.70,3.12,1.23,0.25,0.86,-0.10,0 -0.67,2.01,1.51,2.15,1.58,3.48,4.96,5.29,1.31,0.17,1.40,3.50,1.84,3.96,1.57,2.77,1.67,3.20,0.48,1.11,-0.84,0 -0.32,-0.34,-0.38,0.81,0.59,1.52,2.50,0.69,2.22,5.22,4.51,4.88,5.29,5.41,1.41,0.63,-1.70,1.62,-0.70,-0.07,0.94,2 -0.22,0.46,0.07,0.07,1.89,1.62,-1.05,2.86,2.02,0.87,3.80,2.06,3.53,4.50,4.92,5.02,2.11,1.37,0.58,0.08,-0.22,2 -0.84,0.33,-1.64,1.97,1.66,-1.04,0.42,2.08,1.75,0.91,1.20,2.68,3.22,1.97,5.36,3.90,2.16,3.11,2.76,1.71,-1.45,2 --0.83,0.22,1.17,-0.07,0.84,1.46,-0.06,2.55,0.44,3.20,1.59,2.30,3.00,4.89,4.92,3.47,4.44,4.17,2.66,0.69,0.09,0 --1.07,0.62,-0.18,0.10,0.68,2.39,1.61,2.97,1.96,4.26,4.37,5.99,4.70,4.42,2.13,1.58,2.14,1.85,0.99,-0.35,-0.55,2 -2.01,-0.58,-0.85,0.32,-0.22,0.92,2.12,-0.37,1.92,0.29,1.57,0.29,2.66,3.37,6.36,2.02,3.53,2.52,2.49,1.20,-0.92,0 -0.60,1.54,1.16,1.28,4.11,5.83,4.96,3.83,4.06,3.86,3.06,1.43,0.20,0.03,-0.02,-1.92,1.30,2.44,0.04,-0.05,0.06,0 -2.32,0.94,-0.13,0.77,-0.73,0.63,1.57,0.87,1.58,2.77,4.37,3.24,4.22,4.17,4.26,3.24,3.77,1.38,0.97,1.32,1.86,2 --0.97,0.26,0.77,2.68,2.99,5.46,3.33,3.59,2.44,3.46,2.90,1.91,-0.32,0.29,0.03,1.44,0.27,0.50,0.56,0.87,-1.41,0 -1.91,2.22,2.05,3.42,5.89,4.71,5.15,3.08,4.17,3.31,2.30,1.70,0.15,1.21,1.07,0.73,-0.13,-0.11,-0.79,0.64,-0.52,1 -0.95,-0.41,0.81,-1.04,0.01,1.07,3.10,3.33,2.74,4.38,3.93,3.54,5.11,3.22,2.62,1.81,1.73,3.20,1.97,0.08,0.56,2 --0.63,0.12,2.77,3.10,1.89,3.02,5.29,3.35,2.61,5.11,1.84,3.80,0.97,-1.11,-0.52,-0.37,-2.33,-0.76,-0.39,0.29,-0.17,1 -0.05,-0.45,-0.42,-1.28,0.01,1.45,0.76,0.54,2.43,1.09,3.05,4.82,3.30,6.28,3.85,3.45,4.08,2.09,0.59,1.01,0.67,2 -0.35,-0.31,1.19,0.83,1.98,3.43,3.31,3.62,4.64,5.49,5.67,2.09,2.20,2.43,3.50,1.23,0.58,-0.57,-0.42,1.83,-0.48,1 --1.36,0.39,-0.01,0.95,0.03,2.52,2.31,1.02,0.11,2.63,2.96,4.09,3.08,5.49,6.84,5.39,4.45,2.27,0.39,0.04,0.20,0 --0.93,0.96,1.03,-0.79,1.74,0.05,0.72,0.84,0.80,1.11,3.02,3.26,3.62,4.25,3.67,2.78,3.27,0.79,-0.08,1.73,-2.80,2 -0.69,-1.02,-0.43,0.90,0.99,1.05,1.05,1.33,-0.75,1.87,1.89,2.30,2.19,3.19,5.49,3.93,5.47,3.43,2.37,1.01,-2.26,0 -0.32,-1.61,2.37,-1.52,-0.23,-2.30,-0.71,1.54,0.68,0.64,1.67,4.56,3.89,6.49,6.87,4.57,3.20,1.88,1.77,1.21,-0.28,2 -0.90,1.54,1.10,2.56,2.25,3.87,5.87,3.69,5.33,3.90,1.38,1.75,1.31,1.33,0.54,-0.23,-0.66,-1.13,2.36,0.71,-0.64,1 --0.35,0.40,2.60,1.24,0.79,4.31,4.02,2.29,2.76,4.25,3.91,4.35,4.39,2.57,1.70,-1.16,-0.76,-1.21,-0.22,-1.22,0.24,1 -0.80,-0.96,0.19,2.31,0.12,3.83,2.79,3.00,3.89,3.18,4.53,1.77,3.19,2.55,1.45,0.68,0.56,-0.56,-0.16,0.64,-1.51,1 -0.90,-0.87,0.22,1.73,-0.46,1.35,1.76,3.78,5.07,3.54,4.97,4.04,4.83,3.11,0.77,2.23,-1.64,0.43,0.86,0.65,-1.11,2 --1.53,-0.09,0.38,1.76,-0.52,1.15,0.07,1.40,-0.92,1.46,1.26,2.57,4.25,4.52,3.90,6.37,1.62,2.01,2.64,0.05,-0.65,0 -2.27,0.45,2.84,1.79,0.06,2.80,3.43,4.73,5.35,4.66,4.78,4.37,3.42,2.35,1.11,0.66,-0.76,-0.13,2.06,-1.26,-2.16,1 --0.79,1.49,-0.69,0.81,3.43,4.83,2.43,2.63,4.86,5.24,4.55,2.56,2.69,2.20,2.77,-0.21,0.46,0.37,-1.84,-0.23,-1.44,1 --0.86,0.30,0.82,1.91,1.40,3.40,4.30,5.06,3.12,4.23,3.92,1.49,2.67,0.40,-1.15,1.20,-0.59,-1.71,0.10,-0.51,-0.69,1 --0.10,0.61,-0.86,-0.99,0.09,0.94,1.03,3.90,4.27,5.66,6.41,3.83,3.34,5.12,2.44,-0.43,-0.90,0.81,0.81,-1.84,-0.84,1 -0.33,-0.51,-0.18,-0.45,-0.09,0.02,0.71,3.39,2.26,4.28,5.83,3.56,3.45,4.19,3.04,1.71,0.75,1.27,2.01,1.10,-0.77,2 --0.63,-0.15,0.65,0.54,0.46,-0.51,1.36,-0.89,0.32,1.45,3.22,3.59,3.45,3.82,6.14,4.09,3.21,3.68,-0.78,0.92,-0.69,0 --1.31,0.28,-0.13,1.75,1.79,1.31,3.02,3.37,4.75,4.10,5.66,5.24,3.42,3.56,1.42,0.38,-0.14,1.66,0.30,-0.23,0.30,1 --0.68,0.68,0.46,3.87,3.06,4.85,4.28,3.66,3.99,2.19,4.07,0.72,1.06,1.44,1.07,-0.30,0.35,-1.02,1.16,-1.15,0.24,0 -1.25,-1.26,2.74,2.05,4.19,5.89,5.85,5.02,3.16,1.29,0.31,2.22,-0.68,-0.97,-0.34,2.24,0.74,0.18,-0.33,-0.32,-0.98,1 -0.97,1.86,2.46,3.18,3.41,5.54,6.92,3.06,4.48,3.49,2.51,0.43,0.46,0.41,-0.51,1.67,-1.59,-0.28,-0.15,0.18,-0.10,1 --0.25,0.20,2.28,3.49,2.23,5.63,4.78,4.70,4.01,3.71,3.55,1.84,2.78,-0.70,0.26,1.53,0.02,0.96,0.75,1.27,1.93,1 -0.54,0.59,0.72,1.84,1.16,-1.11,1.90,2.11,2.41,0.52,0.60,3.10,2.31,2.15,4.31,1.24,4.21,2.62,0.97,0.39,-1.18,0 --1.26,0.74,-1.84,1.54,-0.21,-0.03,1.86,2.95,4.96,3.88,6.85,4.23,2.54,3.38,1.08,1.57,1.26,1.32,-0.30,0.98,-1.84,2 -0.28,0.14,0.76,-0.24,-0.53,0.35,0.27,-0.46,1.26,0.92,2.82,2.42,5.29,3.88,6.74,4.31,3.39,2.21,1.15,-0.60,2.10,2 -0.81,1.76,-0.10,2.31,2.65,3.93,5.50,4.23,6.37,4.36,1.92,1.09,1.95,1.21,-0.65,-0.99,-0.28,0.15,0.17,0.37,0.44,1 -0.51,-0.07,0.01,1.81,1.15,2.36,4.40,3.76,4.61,4.19,5.30,3.43,3.91,3.07,1.76,-0.23,-1.60,-1.00,-0.18,-0.47,0.84,1 -1.12,-1.82,1.25,1.70,1.93,2.01,0.13,2.44,1.29,1.68,3.48,2.51,1.82,5.09,5.37,2.84,3.43,0.86,1.28,0.21,-0.77,0 -0.54,-0.36,-0.30,0.22,0.20,0.65,1.02,3.66,5.21,2.57,5.84,4.94,1.98,2.49,1.73,0.36,0.90,-1.32,0.07,-0.11,-1.23,1 -0.27,-0.65,1.55,4.43,4.03,6.14,5.36,5.56,3.45,3.71,3.22,2.51,1.93,0.34,0.14,0.44,1.16,0.50,-0.89,0.60,0.55,1 -0.06,0.42,0.66,0.58,3.20,3.18,4.28,-0.15,1.93,1.58,1.76,2.76,1.56,0.45,1.62,1.57,2.06,0.90,1.18,0.86,0.51,0 -1.38,-0.83,0.90,0.68,-0.19,0.62,-1.43,-0.81,1.88,2.47,0.57,3.19,6.04,4.03,5.64,3.28,2.44,1.43,0.86,2.31,1.38,2 -0.94,-1.71,0.44,-0.57,-1.38,1.24,2.45,0.90,3.54,4.17,3.74,4.25,3.77,3.19,3.35,1.69,3.27,2.42,0.32,1.38,-0.36,2 --0.04,0.47,0.43,0.69,-0.14,2.97,1.87,5.13,3.11,3.18,6.31,3.70,3.73,2.49,2.55,1.02,-0.87,2.62,-1.74,0.26,0.20,2 -1.19,0.20,-0.27,-0.10,1.95,1.66,3.24,2.31,0.87,3.20,1.04,2.44,1.94,2.92,3.80,0.84,2.24,0.37,0.33,0.54,-0.23,0 --2.33,-0.26,-0.42,-0.02,0.16,-0.24,0.40,1.90,-0.38,3.66,3.14,1.80,3.07,5.20,4.55,3.30,3.15,2.97,2.01,1.05,0.28,2 --0.27,-0.76,1.02,2.84,3.62,3.62,3.88,1.28,3.32,1.66,0.92,2.23,0.23,3.16,3.73,0.81,0.74,2.47,-0.74,-0.66,-1.51,0 --0.61,0.82,-0.24,0.37,-0.15,-0.37,0.44,1.99,0.00,0.82,-0.02,1.76,2.81,5.51,6.48,5.88,3.14,3.87,1.67,0.86,-2.03,0 --1.68,-0.48,1.52,-0.22,2.21,-0.40,1.62,-0.63,0.16,1.11,1.58,2.48,2.99,4.99,6.12,4.82,4.12,1.84,1.19,1.44,-1.98,0 --0.49,0.70,1.89,2.90,5.43,6.75,6.81,6.87,4.44,3.61,3.87,1.17,-0.26,-1.33,0.76,-0.06,-0.43,-0.19,-0.40,0.88,-0.30,1 -0.30,-0.61,0.62,2.22,-1.15,-0.44,-0.78,-0.08,1.82,0.94,1.97,4.43,5.60,4.35,6.82,3.59,3.79,4.40,2.73,0.41,1.24,2 --0.25,0.15,1.42,3.08,0.67,0.50,3.98,3.35,3.39,4.09,5.63,2.79,4.56,2.95,2.00,1.27,0.87,-1.87,-0.16,0.25,-0.47,1 --1.60,-0.31,-0.15,-1.16,-1.80,-0.28,0.98,1.86,1.17,1.57,2.90,3.99,4.05,4.58,4.53,2.80,3.12,2.15,1.54,1.60,0.89,2 --2.35,-0.28,1.03,1.55,-0.13,-0.44,1.66,0.52,1.66,1.07,1.44,1.13,2.93,2.93,3.12,3.40,3.14,1.17,2.48,1.24,-0.44,0 -2.29,1.68,2.55,1.70,3.98,4.26,4.84,4.60,3.29,4.38,3.24,2.08,-1.63,-0.43,-0.45,1.04,0.29,-1.69,1.00,0.56,-0.71,1 --0.63,0.96,2.40,1.39,5.25,5.19,6.15,6.65,3.45,4.88,4.24,2.60,-0.65,-1.26,1.06,-0.86,1.10,1.00,0.37,0.35,-0.97,1 --1.20,1.62,1.89,3.86,1.68,5.21,6.30,3.41,2.98,2.49,1.13,1.92,0.01,1.92,1.36,0.77,-0.15,-0.85,0.82,0.14,-0.43,0 -0.20,1.09,1.67,1.36,1.13,2.14,2.61,1.70,1.42,2.94,2.06,2.48,0.33,3.11,3.89,4.52,0.58,3.03,2.08,-0.90,1.46,0 --1.09,0.69,0.68,0.62,-0.22,0.75,2.48,3.21,4.49,4.97,5.00,5.97,3.32,5.44,2.08,1.69,0.00,0.86,0.19,0.75,1.92,2 -0.46,0.35,3.23,2.88,2.50,5.27,6.88,5.46,2.03,2.84,1.82,0.94,0.66,-1.62,1.26,1.42,0.35,1.90,0.04,0.05,0.75,1 -1.48,0.54,0.96,0.85,-0.67,-0.71,-1.45,-0.31,-0.16,0.20,2.38,2.35,1.97,4.78,3.53,4.35,3.05,3.31,1.13,3.32,-0.95,0 -0.04,0.75,0.08,0.21,-0.46,3.11,1.91,3.50,5.24,3.15,5.01,3.69,3.00,3.31,-0.82,1.46,0.43,-0.77,0.24,-1.51,0.65,2 -0.14,-0.88,-0.45,-0.99,0.35,0.93,1.96,0.49,0.09,2.33,3.42,4.19,3.18,4.92,6.23,3.42,2.28,0.90,0.10,0.87,0.03,2 --1.41,-0.31,0.92,2.43,2.78,3.03,2.33,2.93,2.87,4.43,5.92,3.08,4.20,0.69,0.19,-0.04,0.21,0.50,1.86,-0.70,-0.74,1 --0.96,-0.22,-1.20,0.91,-0.38,1.36,1.26,0.41,1.45,2.67,2.49,2.84,3.22,5.50,6.36,4.85,5.64,2.60,2.62,0.64,-1.43,2 -1.04,1.05,-1.67,1.35,1.32,-1.25,3.28,1.49,0.22,1.58,2.00,0.91,2.96,3.68,5.19,5.20,1.32,2.17,0.27,0.84,-0.63,0 --1.19,0.53,2.28,1.83,4.70,5.52,7.24,4.78,4.29,3.02,2.59,1.51,0.80,-0.49,1.21,-0.29,0.55,0.15,0.38,-1.05,0.44,1 --0.02,0.11,-1.62,0.37,-0.38,1.50,0.17,1.09,1.43,3.28,3.11,3.44,4.90,4.65,6.77,5.39,3.23,1.58,1.16,-1.41,0.81,2 -0.85,1.33,1.02,-1.41,1.94,2.00,2.03,2.89,4.38,5.50,5.03,3.01,3.14,0.78,2.25,1.43,-0.01,2.03,0.53,-0.37,0.42,1 --0.36,-0.38,-1.58,2.04,0.72,1.46,2.94,-0.66,2.15,1.83,1.90,2.62,4.18,4.45,5.77,2.77,4.19,2.99,1.91,0.28,-0.67,0 -1.43,-0.53,-0.57,-0.32,-0.44,0.59,1.97,1.64,3.34,3.90,7.46,3.77,3.80,3.56,2.66,1.59,1.34,0.10,1.35,-0.58,-0.66,2 -1.29,1.61,-1.43,0.53,-0.02,1.79,0.83,-0.34,1.29,1.31,2.63,4.42,5.10,5.87,6.10,4.24,3.11,0.64,0.98,-0.30,-1.13,2 -0.06,1.53,-0.50,2.11,-1.11,1.06,0.98,1.59,2.02,4.95,4.44,2.88,5.51,4.93,4.13,0.89,1.14,1.62,0.07,1.10,-0.25,2 -0.67,1.99,1.98,3.55,4.01,4.30,4.92,2.71,1.65,2.71,0.83,2.03,1.09,1.26,1.57,1.18,-0.28,1.69,-1.04,0.86,-0.19,0 --0.37,-0.19,1.11,0.11,1.54,1.42,1.98,5.00,4.09,5.39,4.48,4.11,2.90,2.17,1.34,1.16,0.34,2.47,2.23,-0.04,1.41,1 --1.37,0.20,0.69,-0.19,1.25,1.10,2.06,3.08,4.41,2.95,5.46,3.89,3.43,2.59,0.28,0.64,-0.43,0.07,-0.06,0.03,-1.03,1 -2.29,0.87,2.75,0.48,2.02,2.92,4.64,3.56,5.79,4.08,3.21,3.83,1.26,0.54,1.01,1.20,0.54,-0.65,0.33,0.79,-0.97,1 -0.43,0.50,-0.81,1.18,0.72,-0.71,0.86,-1.83,0.37,0.52,2.33,2.71,4.58,4.50,4.85,5.98,3.40,4.41,1.71,0.79,0.95,0 -1.24,-0.19,0.04,0.05,-0.29,-2.04,-0.05,0.62,-0.89,0.10,2.69,3.42,5.23,6.28,7.80,4.88,4.66,3.36,2.06,2.74,-0.93,2 -0.13,1.34,0.78,3.73,2.96,2.19,3.45,3.59,1.39,3.76,2.46,1.21,1.23,1.90,0.29,1.96,2.55,0.07,0.33,0.20,0.03,0 --1.80,0.06,-0.59,0.11,2.32,1.78,1.24,3.02,2.58,1.55,3.50,2.35,0.46,1.87,2.15,3.25,1.70,-0.07,1.20,-0.31,2.11,0 -1.62,0.06,1.86,-1.84,1.00,3.22,3.43,4.03,3.09,4.77,4.28,4.57,0.93,1.68,0.86,-0.83,0.17,0.05,0.38,-0.40,0.66,1 -0.24,-0.02,1.93,2.23,1.60,3.59,3.31,4.45,4.37,3.56,3.46,3.31,1.99,0.95,1.19,-0.02,-0.31,-1.34,0.01,-0.45,-1.39,1 -0.33,0.61,-1.00,1.03,-1.34,0.95,3.39,3.67,3.15,4.84,5.50,5.00,2.35,2.18,0.69,0.68,0.49,2.95,0.04,-0.15,-0.34,1 -0.50,2.25,-1.00,0.17,1.18,2.68,0.54,1.15,1.39,0.48,2.30,3.49,4.18,4.62,4.74,5.69,3.35,2.61,3.21,0.70,-0.61,2 -0.95,0.33,-0.56,1.56,0.66,3.13,2.48,2.33,5.37,3.94,5.92,6.42,3.11,2.47,1.23,2.92,1.31,1.84,-1.71,0.47,-0.13,1 -0.75,-1.82,-1.47,-0.02,1.09,1.01,0.99,0.81,-0.52,1.14,2.63,3.28,4.49,4.32,4.98,3.56,2.74,2.65,2.17,1.89,0.19,2 --0.47,-0.71,0.89,1.15,0.64,2.46,2.76,2.18,4.33,2.90,5.97,3.85,2.39,1.89,1.98,1.00,0.43,0.76,0.21,0.34,0.01,1 --1.23,1.39,1.34,2.53,5.81,4.23,4.28,4.02,5.23,5.05,2.21,1.61,-0.02,0.26,-0.12,-1.98,1.98,-0.76,-1.46,1.45,-0.72,1 -0.22,0.29,0.53,2.53,2.52,4.39,5.10,4.03,5.14,4.51,2.41,1.84,-0.65,0.27,0.51,2.15,-0.57,1.16,-0.09,-1.18,0.57,0 -0.72,-1.44,-0.12,1.72,-0.07,-0.88,-1.61,-0.15,0.07,2.01,2.26,4.06,3.56,5.56,5.88,4.90,5.14,3.34,2.64,-0.72,1.14,2 --2.19,-0.80,0.04,1.29,-1.02,2.90,1.34,4.34,3.25,6.12,4.60,4.13,2.97,4.48,1.76,1.07,-0.53,-0.68,-1.12,1.05,-0.23,1 --0.87,-1.41,1.08,0.68,0.72,0.29,1.00,1.10,0.92,1.90,4.56,4.01,4.58,5.11,3.33,5.28,3.43,1.71,2.63,0.00,0.47,2 --0.36,-0.73,-1.21,-0.95,0.51,-0.78,2.38,1.49,2.00,2.52,3.74,4.79,2.63,5.50,4.57,3.92,0.93,2.41,0.90,0.26,-0.34,2 --0.46,0.03,-0.70,-0.37,-1.21,-1.12,0.65,-0.02,0.11,2.35,1.64,3.60,3.89,5.01,5.61,3.79,3.31,3.12,3.81,-1.57,1.91,2 -0.41,-1.23,1.21,0.08,0.53,1.51,2.20,3.56,3.01,4.16,3.71,3.84,3.51,1.45,2.41,2.52,2.28,0.51,0.32,0.42,-0.33,1 --1.20,0.08,0.94,0.39,0.53,2.95,0.90,1.96,0.58,1.57,3.49,1.67,3.18,3.43,5.35,4.42,3.68,2.84,3.50,0.56,1.39,0 -0.15,-0.22,-0.10,2.41,3.01,2.30,4.09,1.60,3.70,3.05,0.92,1.26,1.82,3.02,2.91,1.77,0.63,0.02,2.71,1.29,0.58,0 -0.23,0.08,2.19,-1.81,2.58,3.09,1.09,2.99,0.65,3.95,2.52,0.61,2.16,3.00,2.40,4.16,2.04,-0.03,-0.88,-1.62,0.44,0 --0.09,0.35,-0.95,-0.23,-0.07,0.72,0.22,0.63,0.71,2.19,2.69,3.24,4.86,3.57,5.31,5.16,4.85,2.16,1.69,0.60,-0.66,2 --0.11,-0.57,-0.19,0.73,0.81,3.20,2.69,3.90,2.57,3.77,3.47,3.50,1.48,1.09,1.93,0.35,0.29,-0.95,-1.13,0.78,-2.49,1 -0.36,0.44,1.89,1.38,3.33,2.46,4.37,3.12,3.93,3.01,0.58,-0.17,1.06,1.52,2.46,0.75,0.73,1.15,-0.40,0.73,-0.53,0 --1.49,0.86,2.11,-0.82,-1.52,-0.34,-0.24,0.33,1.07,1.29,3.06,3.96,4.10,4.22,3.31,3.35,3.24,1.94,2.27,-0.35,-1.31,2 -0.69,0.78,1.05,2.63,3.01,3.69,5.82,6.20,5.24,2.83,1.88,1.61,-0.51,-0.21,1.12,0.26,-1.75,-0.06,0.98,0.82,2.29,0 --0.97,0.92,1.05,0.87,3.92,4.36,3.32,1.89,3.11,2.82,0.86,0.41,2.13,1.66,3.22,1.10,2.01,3.51,-0.45,2.05,-1.42,0 -0.48,0.29,-0.37,0.70,1.93,2.89,1.27,1.45,0.00,1.31,2.08,0.72,2.96,2.04,4.07,1.92,3.93,1.65,2.33,0.97,0.32,0 -0.31,-0.35,1.35,-0.03,1.49,1.92,2.66,3.90,4.65,2.47,4.39,2.33,3.07,2.45,2.06,0.11,-1.06,1.34,-0.33,0.29,-0.81,1 --1.59,-0.02,-1.22,0.20,-0.68,0.96,1.65,1.76,1.19,1.10,3.00,4.36,2.39,3.23,4.87,2.72,3.57,2.13,2.69,1.43,-0.35,2 --1.35,1.24,-1.62,0.78,0.30,0.49,1.53,1.63,2.39,1.97,3.39,4.98,3.99,3.89,3.70,3.99,1.40,1.86,0.32,-0.33,1.23,2 -0.01,-0.34,2.26,4.94,2.91,3.14,8.08,3.02,2.12,2.86,2.50,0.72,0.60,0.79,0.62,1.11,-1.51,-1.43,0.81,-0.67,-0.11,1 -1.86,1.50,0.42,1.30,0.92,0.68,2.04,3.25,2.89,3.77,3.90,3.16,3.93,3.47,2.92,0.10,1.81,0.61,-0.68,1.46,-0.66,2 -2.32,-0.95,-0.65,0.40,0.73,2.29,1.45,1.10,0.41,-0.49,3.19,1.56,3.51,3.01,2.80,4.56,1.74,3.30,3.37,0.94,-0.59,0 --0.65,1.87,0.45,1.73,5.54,4.66,4.57,4.20,1.96,1.89,1.21,-0.42,0.96,0.13,1.17,-1.25,1.22,-0.60,-0.16,1.46,-0.23,0 -0.67,-1.10,-1.47,1.05,-0.25,1.81,2.25,3.38,1.83,3.45,4.89,5.55,3.96,3.88,5.02,1.71,0.93,1.10,-0.52,-0.45,-0.58,2 -0.18,1.12,-1.49,-1.06,0.41,0.09,2.18,1.49,0.48,3.30,1.53,4.00,2.94,3.87,3.09,3.03,1.80,3.64,1.72,-0.23,0.31,2 --1.21,1.36,0.01,1.91,2.79,1.30,3.03,2.44,0.03,2.55,1.11,3.73,0.57,3.99,2.94,4.50,2.64,2.60,2.60,0.14,2.01,0 -0.46,-0.09,-0.26,0.30,1.32,1.59,3.98,2.55,5.08,5.75,6.18,4.96,3.55,0.85,3.21,1.02,0.82,1.27,0.95,1.40,0.15,1 -0.61,0.26,1.91,2.25,2.42,4.39,5.24,2.51,2.34,0.74,2.08,0.18,-1.43,0.40,0.52,0.54,1.14,0.87,1.53,0.32,-0.08,0 --0.03,-0.31,-0.73,0.47,0.44,2.64,0.85,1.56,1.21,0.54,3.75,3.00,5.07,6.14,4.43,4.96,2.82,4.00,0.28,0.52,-1.38,2 --0.67,-0.19,1.02,0.12,0.14,1.33,2.28,3.32,4.63,6.09,5.55,3.01,5.11,2.69,1.96,2.23,0.31,-1.27,-1.13,-0.51,-0.19,1 -0.89,0.13,-0.17,-1.25,1.18,1.22,2.04,1.27,1.49,0.99,2.30,2.40,3.51,3.71,6.79,4.11,3.67,3.41,2.63,2.19,1.69,0 --0.19,0.75,-0.21,1.08,2.00,2.89,1.55,2.96,0.22,2.74,0.11,3.24,4.44,4.23,4.07,2.28,3.92,1.52,3.65,-1.01,1.09,0 --1.46,0.46,0.89,2.92,1.64,1.38,4.44,2.46,0.44,0.56,0.26,1.30,1.49,0.51,2.30,1.51,1.24,1.82,0.55,1.25,1.22,0 --0.12,-1.23,1.13,1.87,4.72,4.93,4.43,4.97,3.34,4.24,4.33,1.52,1.88,0.87,1.39,1.18,0.21,-0.12,0.83,-0.52,-0.42,1 -0.03,-1.10,-0.92,-0.69,-0.11,1.22,0.67,2.78,4.55,3.33,6.12,3.67,3.27,2.36,3.94,3.18,2.28,1.70,0.17,-0.32,0.57,2 --0.27,0.07,2.33,-0.16,0.91,4.13,4.96,4.78,2.51,4.08,1.59,2.52,0.53,1.93,1.82,2.20,-0.41,1.00,2.09,-0.10,-0.91,0 --1.87,0.11,1.76,1.90,2.04,2.22,3.12,2.85,3.65,0.55,1.60,0.67,2.13,2.96,2.44,4.03,4.16,1.25,0.35,-1.28,0.44,0 --1.08,0.08,-0.85,0.03,0.32,-2.00,1.05,0.44,3.98,2.58,3.49,2.50,3.99,4.44,4.33,3.07,2.22,1.78,0.94,1.84,-1.68,2 -0.18,-0.29,-1.13,-1.42,-1.44,-0.95,0.06,0.25,0.05,1.36,2.40,2.58,3.39,5.29,4.23,3.83,3.39,1.85,1.62,2.24,-0.82,2 --1.53,0.81,1.97,-0.66,2.77,-0.72,2.54,3.29,1.70,0.94,4.39,3.83,2.09,5.02,4.72,3.68,2.20,2.62,1.58,0.46,-1.27,0 -0.86,0.83,1.22,1.18,1.33,4.11,3.91,2.08,3.14,4.36,5.46,3.85,2.37,3.17,1.43,1.16,0.99,0.33,-0.22,1.65,0.36,1 -0.10,0.65,1.53,1.59,1.54,4.04,3.99,3.76,4.40,3.97,2.47,2.91,5.41,3.04,0.97,0.31,0.10,0.61,0.04,-0.49,0.65,1 -0.42,0.58,-0.67,-0.12,-0.14,0.48,-0.37,3.12,0.76,1.71,4.11,3.29,3.38,3.44,2.31,5.05,2.46,0.87,2.87,0.08,0.89,2 --1.26,-1.20,-2.01,0.09,-0.72,-0.53,0.69,-0.21,1.23,3.38,3.69,2.61,3.71,2.48,3.02,3.05,1.81,2.08,2.23,1.32,-0.50,2 -0.63,1.64,0.52,3.53,1.63,3.74,3.90,3.89,3.74,3.25,4.43,4.04,2.05,0.55,1.49,1.23,1.02,-0.37,0.13,-0.49,-1.68,1 --1.76,1.84,2.19,1.62,2.38,0.31,2.66,3.25,5.17,4.72,4.75,6.28,3.33,2.12,3.30,3.20,0.30,-0.11,-1.90,1.14,-0.89,1 -1.11,0.44,0.04,-0.15,0.17,1.79,-0.82,2.16,1.70,3.46,4.80,4.86,2.69,2.84,3.28,4.19,4.03,1.72,1.67,-0.36,0.15,2 --0.35,0.48,0.84,1.48,3.10,0.65,1.85,4.62,5.20,3.61,5.05,3.44,2.29,3.82,-0.27,0.01,0.34,-0.79,-1.54,-0.65,-0.25,1 -2.15,1.32,0.58,2.06,0.04,0.37,0.85,1.38,3.12,3.41,3.86,4.10,3.36,4.01,3.51,1.72,1.64,1.87,0.84,-1.06,-0.41,2 --0.05,0.45,2.25,1.05,2.99,1.60,3.07,4.45,5.08,4.74,4.05,2.26,4.00,-1.22,1.61,-0.60,-0.34,0.51,0.69,-0.99,0.04,1 --0.10,0.62,2.28,1.40,0.46,1.46,3.32,3.03,0.75,5.69,4.70,1.24,1.98,1.83,1.47,-0.12,0.17,-0.50,0.67,0.13,0.57,1 --1.31,2.76,3.32,1.72,3.62,4.47,6.61,4.35,3.69,3.86,1.32,1.06,2.67,-0.65,0.84,0.24,-0.55,-1.18,2.88,-0.15,2.35,1 -0.45,1.33,-0.67,0.32,1.12,1.60,-1.06,0.51,-0.07,1.35,3.01,3.34,3.69,4.16,6.11,4.45,2.90,0.87,1.13,-0.15,-1.60,0 --1.48,0.30,1.47,-0.50,-0.03,0.74,-0.04,-0.65,-0.06,0.60,4.31,3.31,4.08,5.00,6.03,4.03,5.20,1.76,2.32,0.14,-0.81,0 --0.56,-0.26,0.80,1.15,1.39,1.99,3.10,3.52,3.09,3.02,1.77,3.56,2.14,3.91,3.06,1.16,0.75,1.88,0.07,-0.51,-0.98,0 -1.33,0.81,0.85,1.73,1.11,2.63,0.74,1.52,-0.54,0.77,3.27,3.35,1.92,2.44,2.21,5.25,3.42,3.55,3.87,-1.72,0.87,0 --0.71,1.27,2.06,3.62,3.34,3.42,6.78,3.63,2.09,2.51,2.23,2.85,1.39,0.44,1.51,0.60,1.82,1.07,2.30,-2.63,0.98,0 -1.44,0.98,-1.85,-2.37,0.04,1.23,0.69,2.23,2.34,2.95,3.29,3.57,4.21,5.18,4.45,3.51,3.26,2.32,1.81,-0.54,0.90,2 --0.47,-0.02,0.59,-0.44,0.84,0.37,1.30,0.31,0.87,1.05,3.20,3.79,3.43,5.37,4.64,2.71,2.59,2.92,2.13,1.56,0.58,2 --0.77,2.58,0.21,0.57,-0.37,1.99,1.00,2.84,3.01,5.71,4.54,3.29,3.13,2.64,4.35,0.65,1.27,0.55,1.85,0.68,-0.83,2 --0.24,-1.11,1.12,0.48,0.33,2.65,3.62,3.74,3.64,3.43,4.44,2.92,3.32,-1.16,2.10,0.95,-2.06,-3.19,2.28,-1.44,0.27,1 -1.34,2.32,1.24,0.18,-0.61,-0.84,1.55,2.09,0.56,3.73,3.16,4.26,4.51,3.70,3.56,3.49,2.60,2.12,1.89,-2.24,0.14,2 -0.52,0.44,0.23,2.48,2.79,5.05,4.72,6.04,4.69,5.20,2.73,1.42,2.11,1.26,0.08,1.81,-0.87,0.13,0.46,-1.91,-1.16,1 -0.25,-0.99,0.22,0.98,0.27,2.48,1.92,1.90,3.44,6.10,6.48,6.89,2.10,3.77,3.27,1.99,-0.51,0.53,-0.01,-0.92,1.09,2 -1.02,2.25,2.17,2.91,3.06,2.51,3.29,4.42,4.08,1.24,2.59,1.84,1.59,2.72,1.85,1.25,0.14,1.82,0.89,-0.62,-0.48,0 -0.90,0.79,1.09,1.48,-0.87,-1.03,0.33,0.42,0.24,2.03,0.89,1.75,7.04,6.35,6.04,4.10,2.38,2.34,0.26,1.19,-0.41,0 -1.81,-1.91,1.23,1.08,0.32,1.21,2.13,2.03,2.27,4.67,3.90,3.82,2.97,2.07,2.13,2.17,0.17,2.32,-0.52,-0.66,1.66,1 -0.85,1.03,2.80,3.04,2.65,4.30,4.00,5.63,4.63,3.22,1.75,1.13,1.30,-0.63,0.01,-0.81,-1.63,-0.55,0.35,0.83,-1.57,1 -1.28,0.54,-0.64,0.33,-0.86,2.29,1.37,2.97,5.19,5.97,5.35,4.86,4.66,2.61,1.48,0.41,0.80,-0.51,-0.85,1.11,-0.56,1 --0.01,-0.33,2.13,2.51,2.73,3.31,3.05,3.18,0.05,1.70,0.89,1.94,3.25,0.45,2.46,3.45,3.34,2.20,0.43,1.97,-0.29,0 -0.38,-0.73,-0.43,1.11,2.40,1.86,5.17,5.49,4.32,3.01,3.20,3.00,0.88,1.57,2.29,0.83,0.44,-1.42,0.12,-0.32,-1.26,1 -1.42,0.05,0.80,1.37,2.07,-0.34,5.20,4.28,4.87,2.91,6.08,4.66,3.00,2.48,3.07,0.67,0.95,0.65,2.17,1.34,-0.40,1 --0.33,0.67,-0.00,1.85,1.43,2.05,3.27,4.94,4.62,3.97,5.65,5.24,4.42,2.11,-0.43,-0.62,0.43,2.40,-0.35,1.51,0.21,1 --1.79,2.35,0.36,2.59,2.73,0.21,2.61,2.03,4.51,4.20,4.52,2.71,3.15,-0.71,0.07,1.09,-2.49,-0.74,-1.29,-1.72,1.31,1 --2.02,0.87,-0.98,1.49,1.31,-0.90,0.73,1.24,2.45,1.46,4.59,2.69,5.27,5.00,4.33,1.60,3.92,0.79,1.89,-0.72,-0.98,2 --0.34,-1.47,1.17,1.31,2.20,3.91,3.56,3.21,4.29,4.41,4.04,2.97,1.70,0.15,1.06,-0.43,0.62,-0.32,0.11,0.12,1.77,1 -1.10,2.62,0.51,3.52,2.91,3.58,2.45,3.73,3.66,1.66,2.47,2.72,1.44,1.25,0.94,-0.18,0.56,2.91,0.47,-0.65,-0.32,0 -0.23,0.01,-0.70,0.61,-2.94,0.20,1.55,2.80,3.30,3.07,4.47,4.85,3.90,2.71,3.95,2.93,-0.47,0.01,1.10,1.64,-1.35,2 --1.08,0.30,2.88,1.49,4.00,3.80,5.50,3.22,4.06,1.80,3.39,0.37,1.04,0.41,1.45,1.31,-0.38,1.05,-0.95,0.60,-0.57,0 --1.05,1.51,0.20,2.95,0.21,0.79,2.46,0.97,-0.54,2.03,2.44,2.16,4.06,3.35,6.59,3.32,2.29,2.01,2.32,0.75,1.11,0 -0.36,0.09,-0.89,1.27,2.16,5.37,3.93,3.37,4.07,2.51,3.73,3.25,1.00,1.86,-0.67,1.82,2.30,0.70,-1.01,-0.18,0.77,1 -1.37,0.42,-1.03,0.19,1.22,2.46,1.18,-0.39,1.23,1.33,-0.25,1.23,2.21,4.34,5.31,2.53,2.26,2.88,1.72,0.22,1.16,0 -1.92,1.09,0.72,0.95,2.58,4.15,2.84,4.56,3.19,4.09,3.25,3.47,2.42,1.84,1.81,0.76,0.50,-0.10,0.67,1.41,1.11,1 --0.73,0.14,0.20,0.87,0.82,1.92,1.43,1.73,1.36,0.80,1.51,1.82,3.10,3.08,4.60,3.55,0.55,3.75,0.97,-1.11,0.43,0 --0.22,-1.94,-0.09,1.48,-0.02,0.24,2.02,2.46,2.84,3.26,4.38,5.72,4.83,3.27,1.70,2.32,0.81,-0.24,1.72,3.04,-0.91,2 --0.68,0.05,-0.29,-0.32,0.45,2.53,0.92,1.18,4.66,3.11,4.37,3.90,4.18,4.02,2.64,2.15,-0.30,-2.74,0.24,-1.20,0.43,1 -0.78,1.44,2.07,1.74,1.67,2.61,4.76,1.92,2.28,2.54,2.20,4.58,2.97,1.71,3.14,4.55,3.53,1.69,0.14,0.55,0.54,0 --0.40,-0.28,-0.32,0.44,1.09,-1.53,0.76,1.16,1.93,3.13,2.91,2.24,6.23,4.73,3.10,4.23,2.77,1.98,-0.93,0.42,-0.36,2 --1.13,-0.48,-0.58,-0.47,-0.09,0.24,-1.16,1.64,2.84,4.00,5.10,3.79,4.67,1.94,2.32,2.59,0.74,1.32,1.84,0.67,-0.24,2 -0.29,1.32,1.42,1.30,1.63,2.74,2.51,3.19,1.48,1.07,0.86,3.41,2.34,2.51,3.52,1.80,2.05,1.44,0.92,0.97,0.05,0 -0.01,1.14,0.75,-0.23,-0.50,-0.80,-0.08,-0.49,1.76,1.57,1.34,2.50,3.99,4.36,4.91,4.13,3.23,3.31,1.92,3.08,1.11,2 --1.99,-0.73,-1.15,-0.86,-0.51,2.11,2.12,3.09,2.69,4.11,4.77,3.43,3.61,4.19,1.58,1.63,0.25,0.36,-0.17,0.43,-0.90,2 --1.12,2.12,0.45,2.51,3.49,5.39,7.69,3.82,4.32,4.05,2.89,2.33,2.05,0.48,0.22,1.62,-0.87,0.76,-0.54,-1.74,0.94,1 --1.17,-0.63,-1.04,-1.10,-1.40,-1.09,1.98,2.84,1.39,4.52,4.87,5.61,1.85,3.41,1.94,1.63,2.08,2.76,1.60,0.30,3.03,2 --0.45,1.06,-1.09,0.54,2.12,2.28,1.91,1.71,0.69,3.09,2.40,0.86,4.44,4.31,4.01,3.49,2.16,2.29,0.83,1.73,1.95,0 --0.46,0.33,0.77,1.94,2.56,4.34,7.11,2.13,1.80,3.87,2.97,1.40,-0.70,2.64,0.56,0.45,0.72,-1.01,0.99,0.76,-0.17,0 -0.55,0.08,-0.48,0.20,0.11,1.42,-0.53,0.01,0.09,2.87,5.55,4.87,4.44,5.23,5.22,1.43,3.27,0.85,0.96,-0.60,0.78,2 --0.28,-0.20,0.98,0.62,1.05,0.91,1.61,1.19,0.98,0.40,0.64,1.88,2.57,3.91,4.10,3.60,4.96,3.34,2.17,0.48,-0.92,0 --0.78,0.91,0.80,1.70,1.76,2.21,3.08,3.29,1.62,1.03,2.93,2.63,1.69,1.54,3.85,4.56,2.81,2.49,1.33,0.03,-0.99,0 -2.26,1.17,0.92,1.43,0.46,3.08,4.29,2.60,5.40,2.64,5.79,1.83,1.28,1.98,1.55,1.95,0.26,-0.86,0.53,-3.00,0.21,1 -0.01,2.06,-2.74,0.86,-0.39,1.71,-0.63,-1.28,0.63,0.56,4.58,5.12,3.25,3.43,7.42,5.65,4.79,2.89,-0.44,2.53,-0.40,0 -0.43,-1.17,-0.67,-0.10,0.50,-0.58,-0.01,1.27,3.67,5.65,3.89,3.87,2.70,5.38,2.49,2.27,0.48,1.19,0.84,-0.49,2.05,2 -0.16,0.38,1.62,-0.80,-1.06,-1.70,-0.19,2.18,0.08,2.16,3.15,3.50,5.02,5.12,5.60,5.58,5.70,2.54,1.74,0.04,-0.34,2 --0.23,-1.58,-0.92,1.50,-0.34,0.73,0.20,1.39,0.36,1.66,2.45,2.23,2.60,3.96,5.14,4.44,4.17,1.12,1.68,-1.66,0.22,0 -0.67,-0.30,2.46,1.69,3.40,3.06,3.40,4.70,3.80,3.42,3.24,4.21,1.39,3.48,1.43,-0.80,0.36,0.91,-1.82,0.45,1.02,1 -0.62,0.22,1.77,1.85,1.41,1.18,3.16,3.04,4.46,3.36,3.27,4.56,4.72,1.08,1.68,2.16,-0.20,1.22,-0.79,0.76,-0.35,1 -0.58,0.63,1.43,3.01,4.89,4.83,5.35,5.97,3.24,3.66,3.87,1.09,0.16,-1.07,-1.14,-0.34,-1.02,-2.13,-0.04,0.88,-0.75,1 --0.65,0.66,1.07,2.12,1.80,5.46,4.28,3.57,4.81,2.26,1.83,4.63,2.02,0.52,1.70,2.04,-0.38,0.39,-0.99,0.37,0.37,1 -0.64,-0.73,1.81,1.68,1.20,3.02,4.62,3.97,4.02,3.40,2.77,3.48,1.67,1.32,1.57,2.25,-0.70,0.23,1.91,-0.33,-0.91,1 --0.77,0.75,0.71,0.86,0.57,1.37,0.89,1.52,1.98,5.37,6.83,5.88,5.37,2.08,1.65,2.67,-0.22,0.37,0.22,0.93,0.07,2 -0.25,-1.44,1.76,1.43,-2.09,-0.62,2.20,1.52,1.55,2.84,3.07,2.45,1.39,3.27,2.63,4.70,2.01,1.20,1.35,0.14,-0.58,2 --1.21,0.98,-1.30,-1.85,-1.36,0.55,1.61,1.24,0.19,2.41,3.75,4.28,3.77,4.65,5.59,3.92,4.42,3.23,1.03,-0.47,-0.42,2 -0.34,-0.24,0.62,-0.39,-0.19,0.05,0.34,2.43,1.12,2.06,4.32,2.68,6.32,5.16,4.52,4.12,0.64,2.70,0.74,1.97,-0.43,2 --0.31,0.11,0.42,-1.31,-0.40,-0.18,1.49,2.04,0.17,2.70,5.04,3.34,3.96,2.89,4.57,5.22,3.15,3.11,1.44,1.57,0.48,2 --1.33,-1.68,0.04,-0.72,-0.70,0.94,0.74,0.82,3.80,3.27,6.54,5.01,3.42,3.04,3.21,2.17,1.32,-0.12,0.03,2.09,0.42,2 -1.50,0.74,-0.40,1.88,2.96,4.50,6.22,4.25,5.24,6.08,3.27,0.43,-0.28,0.50,0.28,-0.00,-0.23,-0.61,2.29,0.37,-0.18,1 -1.46,0.16,3.00,-1.06,-0.53,0.44,0.82,1.29,0.47,0.92,4.80,4.27,4.26,3.54,5.27,4.55,1.93,1.71,1.48,-1.20,-1.46,2 -1.64,1.15,2.44,2.09,2.30,3.94,2.50,1.75,2.51,-0.51,3.36,1.75,1.99,1.71,3.44,2.06,1.71,3.14,1.32,0.12,-0.06,0 -0.01,0.54,1.44,2.38,3.09,4.17,4.17,6.85,4.98,5.12,3.83,2.91,0.11,-0.15,1.90,0.48,-1.69,-0.31,0.93,-0.55,-1.37,1 -0.50,1.51,1.32,0.51,0.00,1.29,3.32,1.71,1.99,0.20,1.07,1.10,4.51,3.92,4.61,4.58,2.96,2.27,1.14,-0.03,-0.86,0 -0.33,-0.12,-0.42,0.49,0.48,0.08,1.61,-1.08,0.51,2.19,1.85,1.89,4.40,4.39,4.06,5.55,2.19,4.01,1.49,1.37,-0.40,0 --0.87,2.50,0.68,-0.59,0.09,0.51,0.41,-1.46,-1.07,0.50,1.24,2.45,3.55,5.39,6.59,4.64,3.59,1.88,1.55,0.77,0.50,0 -0.59,1.08,-1.66,-0.70,0.33,1.24,-0.66,1.36,2.64,4.35,5.66,3.91,2.88,2.86,3.96,3.09,3.35,2.18,-0.21,1.49,-0.76,2 --1.41,-0.10,2.75,1.42,2.58,2.44,2.70,5.13,4.48,3.07,4.34,3.71,2.67,0.29,1.57,-0.47,-0.81,0.88,0.35,1.50,0.42,1 -0.31,-2.12,2.79,-1.50,-0.31,-1.12,0.34,1.94,2.00,0.97,4.36,3.93,4.10,3.66,3.93,3.05,2.86,2.41,3.07,0.59,-0.60,2 -0.45,-0.62,1.14,1.93,2.18,1.86,4.30,5.43,4.16,4.77,2.57,4.14,2.62,2.11,0.58,1.04,-0.68,1.08,1.54,0.29,-0.46,1 --0.37,-0.93,-0.39,0.89,0.04,0.10,0.73,4.70,3.79,5.08,5.26,5.52,2.34,4.65,3.47,0.84,1.88,0.85,0.21,2.41,-0.44,2 -0.11,1.79,-0.41,1.18,-0.63,-0.15,0.76,1.05,1.67,2.88,2.39,4.93,3.04,3.90,4.46,4.35,2.60,2.64,2.17,-0.08,0.02,2 --1.17,-0.78,-0.19,-1.91,0.53,-0.78,1.71,2.31,0.72,0.37,3.61,4.10,3.19,5.76,6.46,2.99,3.30,3.18,0.85,0.03,-0.61,2 -1.47,2.37,1.94,3.16,4.67,6.22,5.94,2.97,2.33,0.36,-0.29,0.81,0.06,-0.23,0.58,-1.05,0.43,0.71,0.49,2.07,0.17,1 -0.07,0.36,0.34,-1.61,0.08,1.41,3.13,2.78,3.34,5.51,7.26,3.95,4.24,3.82,1.53,1.06,0.28,0.25,-0.27,-0.10,-0.80,1 -0.18,0.09,2.87,1.98,4.97,4.58,6.12,4.51,3.36,3.69,2.05,1.79,-0.84,-1.33,0.49,-0.57,0.02,-0.26,-0.43,1.16,-1.56,1 -0.72,-0.41,1.29,1.11,0.87,1.36,4.44,3.79,3.19,5.23,4.89,2.46,2.85,2.62,-0.59,0.73,-0.16,0.51,-1.24,1.54,-0.82,1 -0.15,-1.60,0.78,-0.37,0.08,-0.53,-2.67,0.20,1.78,1.37,2.60,4.67,3.95,4.84,5.99,4.34,3.25,2.82,0.89,1.18,1.23,2 -0.30,-0.32,-0.91,-0.18,-0.21,-0.97,-0.15,1.83,-0.55,1.52,0.01,3.68,5.21,6.32,8.28,4.44,2.41,1.89,2.10,2.11,-0.42,2 -0.04,-0.21,0.16,-0.51,0.80,1.15,2.80,3.87,2.26,2.13,1.61,1.11,2.92,3.66,3.38,4.01,1.92,0.91,0.33,0.75,-0.86,0 --0.71,0.47,1.76,0.02,0.42,2.10,4.44,3.73,4.85,4.83,4.40,5.04,3.66,3.92,2.33,1.21,-0.50,0.67,-0.95,0.23,-1.21,1 -1.16,1.19,0.04,1.59,2.79,4.48,5.09,3.84,2.85,2.98,4.46,1.64,0.49,2.34,3.33,1.67,-0.44,0.86,-1.82,0.05,0.54,1 -0.11,-0.73,1.07,1.99,2.65,2.14,4.66,4.81,3.90,3.22,4.53,1.78,1.91,1.49,1.29,0.52,-1.55,-0.43,-0.25,0.16,-0.61,1 -0.95,0.82,1.83,0.90,-0.62,1.81,3.81,1.28,3.83,4.39,5.42,3.51,3.89,2.37,2.50,1.45,1.01,1.27,0.07,-0.75,-0.07,1 -2.17,0.83,-0.16,0.86,1.10,1.45,3.06,3.69,4.82,3.57,3.53,5.07,3.55,2.76,0.14,-0.96,-0.38,1.41,0.35,0.69,-0.19,1 -0.52,1.69,1.10,0.44,-0.03,-1.29,0.29,1.23,0.45,4.03,3.06,3.20,2.99,3.36,3.38,4.59,4.39,2.19,1.55,1.17,0.88,2 -1.58,0.57,1.20,-0.99,-0.55,0.38,-0.61,-0.65,1.32,3.20,1.61,3.67,4.61,3.00,3.70,4.63,2.31,0.01,1.80,0.03,-0.98,2 --1.54,1.13,-1.42,-0.37,0.15,0.35,1.17,1.27,0.37,0.96,4.83,3.12,3.96,5.06,6.72,3.63,2.22,1.93,2.13,-0.16,-0.34,2 -1.07,-0.79,0.08,-0.48,-0.18,0.28,2.55,1.55,5.51,3.09,5.46,3.29,4.74,5.24,1.94,1.53,0.37,2.19,1.21,0.20,-1.03,2 --0.35,0.94,-0.19,0.36,1.03,0.94,0.95,1.76,1.08,0.36,0.27,0.50,2.27,3.53,3.99,4.32,3.34,3.16,1.54,2.54,-1.08,0 -1.15,-0.47,3.16,2.31,5.03,3.75,5.84,4.41,5.89,2.56,1.84,1.47,1.65,0.65,-0.58,0.26,0.53,1.60,-0.40,0.96,0.05,1 --0.19,1.39,-1.26,0.62,-0.02,2.74,-0.12,0.85,2.31,3.64,3.60,5.63,5.49,2.08,4.48,2.00,3.49,2.12,0.30,0.50,1.55,2 --0.51,-0.41,0.68,0.85,1.28,2.70,3.97,3.38,2.31,1.11,1.71,-1.00,1.34,3.10,3.18,1.27,2.26,2.38,1.11,-1.38,-2.13,0 -0.17,1.37,1.99,2.55,1.72,2.02,3.84,3.61,2.20,2.72,0.09,1.71,1.91,0.66,0.72,1.38,0.15,-0.18,0.58,0.09,1.48,0 --0.52,2.51,-0.34,1.32,1.00,3.38,1.25,3.96,3.74,4.45,4.65,3.97,2.51,3.28,1.32,0.74,0.81,-0.24,0.46,1.54,1.60,1 --0.53,-0.51,0.94,2.36,-0.35,1.07,2.91,2.67,5.45,4.95,5.10,4.06,2.68,1.22,3.52,2.05,0.61,-0.22,0.60,-0.53,0.79,1 -1.79,1.16,2.19,3.19,3.10,5.57,5.70,3.12,3.90,4.01,3.87,2.33,0.93,0.82,-1.50,1.45,0.12,-0.06,0.87,-0.47,-2.23,1 --1.07,0.33,0.31,0.91,1.53,0.42,2.02,3.31,4.77,3.88,5.16,4.29,5.91,2.53,2.08,2.73,1.26,1.30,0.14,1.49,1.31,2 --1.57,0.34,0.73,2.25,0.64,3.06,3.45,2.52,4.33,2.17,3.04,2.95,1.74,1.38,1.06,0.70,0.01,1.53,-1.75,-0.85,-1.27,1 -0.12,0.11,2.24,0.42,1.75,3.08,2.51,3.63,1.32,1.56,0.48,1.17,-0.05,3.38,4.51,4.37,2.42,1.79,-0.42,0.60,0.27,0 --0.92,-1.24,-1.17,-0.29,-0.37,-0.93,-0.25,0.11,2.80,2.37,4.73,2.21,2.79,3.55,5.59,2.78,3.09,2.73,-0.04,1.89,-0.46,2 --0.44,-0.41,2.81,1.09,1.67,3.14,4.55,4.98,3.93,3.77,4.67,2.67,2.93,2.90,1.32,0.30,0.02,-1.00,-1.82,1.70,0.17,1 -0.07,0.27,-0.70,-0.07,1.68,0.76,2.65,3.29,3.73,5.09,6.98,4.04,4.33,1.31,0.53,2.46,1.35,0.25,-1.52,1.04,0.27,1 -1.36,-0.24,1.79,1.22,1.00,2.21,0.03,2.23,3.21,4.42,4.82,4.41,3.74,3.24,1.36,2.98,-0.25,1.76,0.99,-0.67,-0.71,2 --0.25,2.50,0.06,2.75,4.73,4.61,7.09,3.72,2.32,2.15,3.56,2.50,0.43,0.20,0.94,2.23,-0.49,0.39,-1.35,0.94,-1.25,0 -0.41,1.16,1.90,0.76,3.63,4.01,5.46,5.14,3.28,2.75,1.73,1.24,1.73,-0.51,1.12,1.35,0.10,-0.10,-0.35,0.81,-0.84,0 -0.70,-0.29,0.81,0.04,0.70,-0.97,-0.35,-0.17,-0.48,0.64,2.17,1.96,4.04,5.73,5.34,4.98,3.18,4.60,2.24,3.30,-1.52,0 --0.27,-1.23,2.17,-1.41,0.40,0.42,0.19,-0.01,0.29,0.98,3.16,3.12,5.19,4.77,7.58,4.39,4.00,3.61,2.21,2.25,0.03,2 -1.48,1.37,2.72,2.70,3.61,3.58,4.41,3.57,3.98,3.59,1.73,2.33,2.45,2.24,0.41,0.67,-0.17,-0.91,2.01,0.70,-1.41,1 --1.62,-0.60,-0.11,0.16,-0.25,-0.65,0.42,-1.50,0.12,2.14,2.28,5.60,2.77,3.43,5.82,4.08,2.20,1.32,0.95,-0.47,0.37,2 --0.81,1.41,2.63,0.82,0.99,2.61,5.78,4.87,5.96,4.21,3.03,2.22,3.04,0.33,-2.29,0.81,0.32,0.01,-0.21,0.44,1.74,1 -1.68,0.22,2.00,1.76,1.14,2.47,2.12,3.84,1.91,1.28,3.39,0.46,1.68,3.32,2.91,3.96,2.76,1.74,0.49,0.37,0.68,0 -2.42,1.27,2.06,0.66,-0.98,2.33,1.95,1.48,0.67,2.72,0.92,2.25,2.88,3.63,3.63,1.73,0.99,1.77,0.14,1.62,-0.20,0 --0.89,0.40,-0.09,1.27,1.13,0.31,1.11,2.21,-1.55,0.45,2.21,4.02,3.41,2.17,5.70,4.69,4.25,1.77,3.38,-0.19,-0.03,0 -1.13,0.46,2.63,0.42,5.51,4.32,4.87,6.50,2.48,3.97,2.01,2.00,1.03,1.01,0.90,-0.80,-1.04,-0.15,-1.15,1.57,0.39,1 --0.37,1.98,1.36,4.23,3.49,4.11,5.18,4.59,3.38,5.00,3.30,3.04,0.96,0.74,1.20,0.88,-1.08,-0.18,-0.16,-1.41,-0.62,1 -0.18,0.79,1.68,1.62,1.31,2.78,5.07,5.19,3.28,3.06,4.70,0.59,1.57,2.02,1.64,0.71,0.16,-0.95,-1.35,-0.23,1.27,1 -0.76,2.00,2.09,2.38,2.96,3.91,4.46,5.08,4.29,3.00,1.41,2.33,0.97,0.32,1.70,-0.02,-1.52,0.30,-1.10,-0.66,0.54,0 -1.89,-0.88,0.49,-0.46,-0.81,0.73,0.60,2.26,4.55,2.73,5.45,6.41,4.90,5.91,2.76,0.92,-0.36,0.43,1.26,0.25,-1.03,2 -0.02,1.64,0.37,1.04,0.41,1.24,2.86,4.37,3.39,5.60,5.47,4.46,2.63,1.05,0.65,0.91,1.04,0.54,-0.49,0.59,0.55,1 --1.73,0.39,0.43,1.47,-0.34,1.31,-1.34,2.27,-0.68,1.39,1.85,6.82,4.13,6.26,6.13,6.38,3.78,1.98,-0.75,2.35,0.61,2 -0.95,-0.38,-0.31,0.82,-0.29,1.90,0.94,1.74,2.90,4.46,4.57,4.19,4.73,3.63,1.26,2.70,2.71,1.69,1.78,1.89,-0.19,2 -1.97,-1.73,0.51,2.06,2.58,1.46,3.18,4.30,2.70,4.72,3.86,2.83,2.47,1.15,1.07,0.92,0.04,0.89,-0.66,-1.57,1.60,1 --1.02,0.26,1.48,1.27,0.34,3.41,4.29,3.45,4.67,3.75,5.65,3.96,0.37,2.58,2.31,0.28,-1.49,0.03,-1.19,-0.45,0.21,1 -2.00,-1.64,0.56,2.12,1.52,1.69,4.81,2.99,1.85,2.46,2.55,1.47,3.20,1.34,3.00,0.35,2.13,1.19,0.66,-2.06,-1.06,0 --0.09,0.51,0.69,-0.64,-2.33,-0.09,2.60,2.15,2.54,1.91,6.02,5.65,4.73,4.08,2.08,0.06,-0.40,-0.73,-0.35,2.03,0.84,2 --1.16,0.91,1.25,0.89,5.16,3.41,6.03,5.79,3.37,3.23,1.48,2.55,1.53,-0.13,2.31,2.33,0.81,2.00,-0.99,1.05,0.06,0 --0.71,1.11,0.54,0.99,2.20,0.30,1.26,0.74,0.26,0.56,2.06,3.35,2.87,2.90,4.39,2.90,1.99,0.25,0.54,0.95,0.93,0 --0.86,0.52,3.18,1.26,2.83,2.67,3.47,4.43,3.40,2.78,1.72,3.18,1.96,2.68,4.79,1.42,0.05,1.17,0.58,0.68,-1.19,0 --0.20,-1.18,-0.75,0.80,-0.39,0.65,1.72,3.84,3.68,1.73,6.11,4.81,5.47,3.54,2.34,0.58,0.95,-1.51,0.62,-0.13,0.53,2 --0.90,0.85,1.40,3.30,3.31,4.58,4.73,3.38,3.97,3.24,1.09,0.43,1.83,3.09,0.28,2.80,2.29,-2.59,-0.76,0.02,1.34,0 -0.89,-0.17,0.55,1.79,0.03,0.60,1.88,3.17,-0.48,1.51,1.85,2.96,1.59,3.98,4.05,3.81,4.79,1.84,3.50,-0.86,0.54,0 --0.15,-0.13,0.20,3.03,3.36,2.77,3.42,4.77,2.71,5.47,2.79,5.83,1.36,0.98,0.75,1.11,1.99,-0.12,1.09,1.50,-0.88,1 -0.91,-0.29,0.35,1.00,-0.19,0.92,2.07,1.08,3.05,2.54,6.43,5.73,4.08,3.73,1.53,1.34,-0.66,-1.64,0.01,-0.79,-0.71,2 -0.51,2.83,1.54,3.23,2.35,4.28,3.48,1.73,5.70,2.66,2.53,1.18,0.70,1.49,-0.80,0.07,-0.25,0.14,0.11,1.60,0.92,1 -0.87,-0.85,-0.35,0.08,-1.23,1.05,0.56,0.47,-0.02,1.87,3.35,4.23,3.19,4.70,3.98,3.27,1.94,3.58,-0.03,-0.09,3.32,2 -0.51,0.70,1.31,0.23,0.73,3.53,3.78,5.33,3.77,4.57,4.59,3.37,1.43,1.48,-0.04,-0.25,0.97,0.04,0.38,1.57,1.61,1 --0.59,1.58,2.59,3.37,2.88,6.61,6.61,4.96,2.94,2.03,4.36,-0.17,0.13,-0.13,0.76,-1.17,-0.56,-0.07,0.84,0.69,0.62,1 --0.37,1.43,0.14,3.58,1.44,3.22,4.60,3.19,5.10,4.38,3.49,1.91,2.36,1.65,2.37,1.60,-0.64,-0.04,-1.47,0.64,0.75,1 -0.04,0.46,-0.93,-0.26,0.12,0.50,0.37,1.64,1.51,-0.61,0.69,3.01,2.50,4.51,5.78,3.45,3.87,2.56,-0.32,0.18,0.49,0 -0.29,0.27,-0.16,-0.46,-1.24,1.40,1.26,0.87,-1.75,0.49,3.42,3.85,2.38,4.60,7.39,5.07,5.13,3.26,1.14,1.02,-2.08,2 -2.58,0.42,-2.02,0.11,-2.86,-0.45,1.05,1.68,2.07,2.85,4.66,6.51,3.88,1.84,1.48,2.48,2.29,1.50,2.01,-1.05,-0.69,2 -0.96,0.64,-0.33,1.38,1.12,1.84,2.20,1.38,1.17,3.15,3.03,1.68,1.19,2.60,3.51,3.27,3.23,2.54,3.15,2.71,0.73,0 --1.02,1.35,1.30,0.69,4.34,2.45,4.36,2.03,3.32,5.11,7.05,3.82,3.54,2.05,1.79,1.35,0.85,0.08,1.09,0.69,-1.56,1 -2.60,1.63,0.07,0.54,0.29,2.79,2.49,1.57,-0.29,1.76,2.75,1.32,2.64,3.66,3.19,4.03,1.17,1.59,2.13,-0.04,-1.05,0 -1.03,-1.20,-1.07,-0.79,0.25,1.03,0.43,-0.92,1.10,2.20,1.77,2.35,4.83,3.40,6.83,4.41,2.87,2.37,2.07,0.53,-0.72,0 -0.46,0.02,1.98,2.50,0.73,2.71,1.69,0.55,0.46,2.19,2.06,1.45,0.84,1.42,4.08,4.13,2.64,1.66,1.63,3.13,0.92,0 --0.46,1.70,0.18,1.16,0.79,2.86,4.54,5.05,3.31,4.95,5.61,1.23,0.06,2.81,0.94,-0.24,-0.24,-0.24,0.41,0.17,0.21,1 -0.91,-0.50,1.04,-1.26,0.73,1.98,0.27,0.45,1.27,2.18,0.81,4.21,3.22,4.53,5.47,4.40,2.53,0.40,0.06,1.17,-0.72,2 --0.97,2.43,3.08,2.68,4.06,4.93,5.48,4.62,4.89,2.70,0.89,2.13,0.04,1.00,0.89,-0.01,-0.95,0.26,0.40,-0.76,-0.11,1 -0.18,0.59,-0.41,1.40,2.41,4.27,2.57,2.14,4.58,4.64,4.29,4.64,4.62,2.32,2.59,1.37,0.90,-0.60,0.85,1.41,-1.62,1 -0.49,-0.27,2.02,1.99,0.95,3.02,5.76,4.39,4.37,4.19,4.44,1.73,1.97,0.50,2.49,0.89,0.28,-0.89,2.17,1.44,-0.39,1 -0.71,0.80,3.11,1.97,2.22,3.39,3.21,2.53,2.09,2.78,1.32,3.71,2.13,3.35,2.27,2.27,2.44,1.39,2.07,0.63,1.28,0 --0.83,1.19,3.39,1.66,3.29,3.75,4.38,2.76,3.63,2.20,1.92,1.86,3.32,0.77,2.84,4.03,1.80,1.99,-0.59,1.13,0.45,0 -0.35,1.66,0.43,2.39,2.73,5.52,4.53,3.51,2.64,3.57,2.68,2.35,-0.14,0.33,1.06,0.55,-1.05,-0.47,-0.37,0.54,0.10,1 -0.83,0.74,3.11,3.03,2.48,2.79,4.15,3.81,5.02,2.42,2.66,-0.61,0.27,-1.05,1.11,-0.35,0.82,-1.42,1.18,0.25,-0.09,1 -0.58,0.48,-0.41,0.29,0.77,1.68,1.41,1.89,1.44,4.31,3.54,1.99,4.39,3.13,4.94,3.28,3.28,-0.56,3.00,-0.48,-0.17,2 -1.85,-0.76,0.14,-0.17,2.01,1.60,1.67,3.97,3.20,5.23,6.33,2.86,5.68,3.85,2.37,1.99,0.66,-0.14,-0.73,-0.81,-0.49,2 --2.63,0.88,1.83,0.49,4.29,5.16,4.20,5.28,4.30,2.22,3.56,0.69,0.07,0.42,0.07,0.12,0.50,0.27,-0.51,-0.73,0.41,0 --0.52,0.28,2.93,2.06,3.69,5.48,4.04,2.86,3.63,3.49,1.24,-1.61,0.05,-0.97,1.95,-1.53,0.75,0.27,-0.18,-0.75,-0.78,1 --0.71,-0.40,-0.84,-0.67,1.58,0.98,2.54,2.23,2.61,2.09,4.11,4.75,5.82,3.17,3.21,-0.40,1.63,-0.35,-1.15,-0.33,0.54,2 --0.14,2.15,1.48,2.01,1.63,1.93,5.23,4.42,3.60,2.63,3.44,1.84,2.51,0.22,0.16,-0.06,1.01,0.47,-0.99,2.25,0.23,1 --0.33,-0.09,0.16,-1.03,-0.03,1.35,1.73,0.21,0.35,2.42,2.29,2.28,2.81,4.75,5.03,3.74,3.16,1.97,1.46,0.14,-1.06,2 --0.07,-0.64,1.03,-0.07,0.20,0.87,-0.33,1.87,-0.88,2.11,2.31,2.94,1.34,3.98,5.90,4.04,1.95,2.70,1.60,0.97,-0.35,2 --0.27,-0.71,-0.12,0.15,0.13,0.40,3.14,1.42,3.16,5.11,5.39,4.18,5.10,4.51,2.21,1.54,0.24,0.54,0.31,0.14,1.50,2 -0.99,0.19,1.09,-0.76,0.10,1.63,2.00,1.80,2.78,4.05,3.58,4.40,4.43,3.51,3.71,1.77,2.19,0.38,-0.65,-0.07,-0.50,2 -0.81,0.65,-1.63,-1.52,0.42,2.29,2.48,4.39,3.83,6.21,5.38,4.54,1.50,1.09,1.19,0.67,-1.32,-0.25,1.12,0.55,0.18,1 --0.47,-0.45,-0.07,-0.46,0.67,-0.09,1.70,0.54,0.46,0.72,2.14,2.81,2.56,2.49,5.51,2.68,1.74,3.29,3.33,2.75,-0.30,0 --2.49,-0.34,1.57,3.22,2.13,3.22,3.79,3.17,4.27,2.92,1.79,1.23,3.19,0.56,1.57,1.80,0.33,1.31,-0.09,0.12,0.87,0 -1.61,0.69,-0.92,0.55,1.87,2.45,0.69,-0.20,1.03,0.11,2.35,2.98,4.54,3.91,6.11,5.40,3.89,2.91,4.16,3.08,0.82,0 --0.36,0.91,0.96,1.17,-0.89,2.48,1.83,2.34,4.83,5.14,5.67,6.43,4.86,2.74,2.62,-0.08,1.34,-0.20,-0.22,2.05,-0.03,2 --0.80,1.33,1.15,2.00,3.36,3.97,6.38,6.05,4.45,3.09,2.19,1.71,0.97,2.03,0.60,1.04,0.70,1.45,-0.14,0.20,-1.71,0 -0.70,2.97,3.69,2.56,3.23,2.92,5.33,2.52,4.40,3.41,1.85,1.21,-0.73,0.78,0.92,1.06,-0.84,-1.14,-0.14,0.07,1.41,1 --0.84,1.08,2.70,0.29,2.16,2.07,6.14,3.07,3.93,3.70,3.82,3.60,1.75,3.30,-0.47,1.34,-0.56,1.00,-0.58,-0.10,-1.00,1 --1.49,2.40,3.25,2.50,5.16,6.54,5.49,4.08,4.24,2.73,1.52,0.86,1.96,2.53,-0.97,1.43,0.68,0.00,0.61,-1.39,1.23,1 --0.62,0.87,1.69,0.40,0.92,3.56,4.17,5.26,2.19,5.30,4.15,2.72,2.45,1.99,2.00,0.12,-0.53,-0.79,-1.31,0.11,-1.09,1 --1.39,1.17,1.53,-0.07,0.74,1.19,1.49,2.28,3.24,6.77,5.18,5.37,2.75,1.62,1.35,0.80,-0.11,-1.08,0.62,-0.22,-2.42,1 -0.04,0.16,4.35,2.22,3.61,4.80,5.53,4.22,3.99,0.87,2.62,1.57,-0.00,-0.70,0.40,1.00,0.00,0.08,0.47,0.35,-0.13,1 -0.06,1.23,-0.01,-1.16,-0.27,1.16,1.71,1.73,0.69,2.00,2.26,3.07,5.58,5.77,5.67,2.48,4.30,3.85,0.89,0.17,-0.44,0 --0.16,-0.29,-1.02,0.47,1.90,-0.42,-1.06,1.80,1.43,1.84,2.61,4.72,3.33,4.70,5.10,4.44,0.64,2.96,2.82,1.08,0.47,2 --0.32,0.34,1.57,0.04,0.85,0.37,-0.24,2.61,1.11,0.02,1.75,2.48,4.46,3.77,3.55,4.05,4.26,2.69,1.23,2.13,1.43,0 -0.11,-0.92,-0.81,0.52,0.15,1.83,1.12,2.23,-0.64,1.17,3.53,3.70,4.69,4.38,5.29,4.59,2.13,1.23,2.29,2.70,0.75,0 -0.62,0.55,0.15,-0.47,1.32,2.82,3.98,4.48,3.20,4.62,4.33,1.88,1.40,2.48,0.06,-1.51,0.09,0.55,0.59,-0.11,-0.62,1 -0.13,-0.14,-0.48,0.27,-0.43,0.35,3.19,2.59,3.20,3.19,6.66,4.10,3.61,4.90,3.68,2.45,2.34,0.70,-0.92,-1.43,-0.04,2 --0.16,3.05,3.33,3.64,4.62,3.70,7.04,3.84,3.59,3.51,2.90,1.79,-0.22,-0.38,0.76,-0.57,-1.22,0.60,1.51,0.16,1.03,0 --0.29,-0.90,-1.18,0.27,1.62,1.60,1.01,3.64,2.50,3.01,6.24,4.66,5.03,2.54,3.37,0.77,0.83,-0.21,-1.83,-0.22,-2.42,1 -0.53,2.74,1.01,0.59,1.18,5.00,4.04,4.04,4.56,2.73,4.11,3.74,1.83,2.76,0.90,0.27,-1.76,0.07,-0.96,-0.57,2.65,1 --0.72,1.00,2.96,3.07,2.78,5.69,4.29,3.75,2.79,3.06,3.43,1.77,1.78,-0.90,1.28,0.81,-1.16,-0.13,0.24,-0.60,-0.24,1 -0.38,-0.08,1.22,0.73,2.70,3.14,4.37,1.97,0.31,1.05,1.61,-0.41,0.98,2.49,4.07,3.14,2.51,0.09,1.64,3.66,0.51,0 --0.30,1.17,1.69,3.20,3.51,4.85,6.15,6.30,5.52,4.24,3.57,0.87,2.07,0.61,0.84,0.12,-0.45,0.49,1.49,0.05,-0.96,1 --1.41,0.55,-0.38,2.78,2.32,1.57,3.91,4.30,2.59,4.63,2.14,0.07,1.22,2.29,3.41,1.87,0.57,1.45,-0.76,0.08,0.73,0 -2.61,0.51,-0.99,-0.26,0.04,0.97,1.85,1.99,0.25,2.56,3.78,4.43,4.88,3.83,4.13,4.02,3.37,2.42,1.22,0.15,-1.27,2 -1.05,2.06,0.78,4.38,2.70,4.44,5.28,4.54,2.49,2.01,1.92,1.24,-0.70,0.18,0.75,0.24,1.89,0.59,2.12,1.25,-0.96,0 --1.28,0.39,2.02,-0.40,1.29,-2.28,1.58,1.07,3.10,3.36,2.66,4.69,3.49,5.24,4.54,3.54,1.86,1.86,0.82,0.89,-1.62,2 --0.04,0.72,2.42,1.63,3.26,3.02,6.64,4.05,4.66,2.82,4.15,2.52,0.72,0.92,2.14,-1.10,-1.20,1.90,-0.05,1.85,-0.25,1 --0.42,0.45,-0.60,1.53,1.25,1.28,-0.53,-0.05,1.63,2.74,2.11,3.44,6.16,4.55,2.29,6.02,3.78,3.12,4.17,2.14,0.55,2 --0.33,1.80,0.20,-1.32,-0.63,0.92,0.69,1.74,-0.54,2.59,2.51,2.03,4.05,3.72,5.38,3.84,2.86,2.60,1.58,1.48,-0.10,2 --1.60,-1.84,1.32,1.45,1.79,3.19,4.46,2.63,2.40,2.05,2.74,3.29,-0.95,3.68,1.93,2.24,0.76,0.43,2.26,1.49,-0.75,0 -1.02,-0.81,-0.14,1.20,-1.05,-0.23,-0.51,-0.26,2.78,1.59,3.74,5.33,2.23,4.57,4.80,2.50,3.79,1.43,2.56,0.78,-1.52,2 --0.62,1.17,-1.04,-0.76,0.30,-0.69,0.62,2.89,2.46,1.90,1.97,3.71,3.50,6.24,5.41,3.10,1.76,2.91,3.11,0.24,-0.87,2 --0.94,0.58,1.57,1.80,5.33,3.78,8.20,4.10,2.38,1.78,0.49,0.71,-0.24,0.60,0.15,2.70,0.57,0.63,0.31,0.52,-1.77,1 --0.54,1.54,0.56,1.67,-0.01,0.78,2.16,4.13,3.58,3.93,6.17,4.78,3.75,1.98,1.56,1.75,0.77,2.25,0.50,-0.72,2.07,2 --0.24,1.56,2.35,1.11,1.22,2.76,3.20,2.30,0.71,1.72,0.68,2.55,0.97,3.26,4.28,3.28,2.34,1.77,1.92,0.55,-0.13,0 -2.09,-1.27,1.03,1.00,1.32,1.99,2.40,4.45,4.04,3.53,4.80,2.88,2.62,2.31,-0.02,0.59,-0.89,0.04,0.75,-1.60,0.71,1 -0.39,0.68,-0.05,-0.41,-0.04,0.66,3.03,3.32,3.63,4.37,6.66,5.35,2.21,3.76,1.05,1.41,-0.52,-0.09,0.13,-0.24,0.06,2 --0.12,-0.06,-0.20,-0.39,0.10,0.76,1.17,2.01,1.77,1.81,1.75,4.24,4.11,4.08,5.29,3.32,2.35,2.81,2.15,-0.02,-0.47,2 -0.25,0.85,0.75,-0.15,0.71,1.02,0.79,1.60,0.29,1.78,2.38,3.11,5.39,5.86,4.12,5.31,2.90,2.89,0.96,0.25,-1.62,2 --0.99,2.29,2.27,3.51,2.38,5.62,5.43,4.05,3.25,4.37,1.73,1.37,-1.72,1.89,0.47,0.60,-1.31,-0.24,0.99,-1.95,-0.76,1 -1.49,0.65,0.08,0.11,0.78,0.26,3.59,2.97,4.55,4.56,2.09,2.92,1.03,2.96,2.36,-0.55,-1.18,-0.52,-1.53,0.36,-1.47,1 --0.48,-1.18,2.82,3.01,4.01,4.20,5.55,5.73,3.39,3.01,0.54,0.64,0.19,-0.37,1.20,-0.53,-0.45,-0.07,-0.15,-0.04,0.22,0 -0.19,0.31,1.05,1.82,2.32,2.45,2.39,3.31,2.10,0.05,1.72,1.92,0.86,2.39,1.90,2.13,1.48,1.45,1.02,0.98,0.90,0 -0.32,-0.72,1.43,1.05,0.40,3.13,3.51,4.80,4.07,1.66,5.45,2.84,1.72,2.08,1.70,1.18,0.21,0.16,1.78,1.36,0.12,1 --0.67,0.73,0.21,1.29,0.06,-0.47,0.13,1.00,0.79,2.21,0.93,1.41,2.89,4.73,5.19,5.86,3.33,2.47,2.77,3.18,-0.57,0 -0.18,-1.18,0.70,1.13,1.49,0.78,1.42,1.47,0.61,1.52,2.25,3.82,6.08,2.86,4.41,2.26,3.40,2.90,1.66,-0.92,0.96,0 -0.07,-0.13,-0.67,-0.48,0.70,-0.13,0.34,0.47,-1.18,2.30,2.68,2.19,4.01,3.70,5.38,3.14,2.57,5.24,1.31,-1.35,0.82,2 -0.75,-0.15,-0.64,-1.20,0.85,1.94,-0.19,1.48,0.91,3.82,3.67,3.49,3.51,4.53,5.77,5.23,3.40,1.32,1.10,0.57,0.10,2 --0.43,0.59,0.81,0.20,-0.41,2.42,4.05,4.06,2.75,4.01,3.91,4.81,3.35,1.58,1.64,2.05,0.56,0.59,-0.43,0.66,-1.28,1 -0.64,-0.44,-1.51,2.23,0.40,1.97,2.56,1.60,2.01,2.67,3.94,3.93,3.72,3.22,1.33,5.47,2.18,2.92,1.62,0.73,0.01,2 -0.26,-1.84,0.76,-0.72,0.75,0.81,0.95,0.79,1.84,3.63,2.38,4.39,4.45,4.74,2.49,2.29,1.03,0.52,1.00,1.20,-1.25,2 -0.20,1.42,1.81,2.44,2.91,5.60,8.58,3.11,5.11,3.33,2.90,1.27,0.10,2.26,0.51,-1.56,-0.43,0.15,-0.45,1.52,1.55,1 --0.73,0.27,2.63,1.53,2.54,3.29,6.61,3.36,4.22,2.45,3.64,3.47,0.37,0.47,0.55,0.67,2.70,-1.52,0.19,-1.19,0.25,1 -1.90,0.64,0.11,1.19,-0.27,0.75,0.32,2.29,0.84,1.98,3.46,1.34,5.28,6.53,3.83,2.55,4.55,2.05,2.95,1.33,0.11,2 -0.19,-0.10,3.45,2.91,3.63,3.73,6.02,5.87,2.93,3.90,1.98,1.84,-0.04,-0.84,1.13,-0.46,-0.36,0.27,0.19,0.49,1.13,1 -0.12,0.69,0.19,1.85,3.09,3.45,5.13,3.98,5.00,4.43,4.40,1.24,2.31,0.85,1.92,-0.70,-0.50,-1.54,0.83,-1.42,0.92,1 -0.34,0.86,0.56,0.73,5.02,2.23,5.69,5.40,2.36,3.11,3.37,0.70,0.84,1.52,0.09,0.70,-2.35,0.37,-2.19,-0.26,-0.69,0 -0.68,1.46,1.13,-0.72,1.16,0.61,0.10,2.54,0.42,1.88,2.58,1.68,5.05,3.77,4.43,2.62,2.10,0.46,0.39,-0.07,0.09,2 -1.93,0.10,0.37,-1.67,0.95,2.97,4.25,2.53,2.84,4.14,5.50,5.74,2.45,0.43,1.27,1.90,-0.06,0.96,-1.31,-0.52,-0.35,1 --0.12,-0.87,0.35,-1.12,1.00,0.52,1.76,0.85,2.60,0.45,2.12,3.07,4.08,4.38,4.63,3.95,4.21,2.85,1.90,0.71,0.22,0 --1.73,-1.82,0.79,0.66,-1.15,0.98,1.29,3.38,2.02,3.96,4.68,5.39,2.65,4.16,3.44,1.56,0.76,-0.01,-0.51,2.36,0.03,2 --1.26,0.20,-1.18,-0.56,-0.10,0.61,0.67,1.89,0.67,3.56,3.55,4.55,4.54,2.98,3.46,2.51,1.62,0.50,1.05,0.66,1.29,2 -2.18,0.05,0.60,1.32,2.93,3.09,5.19,3.29,4.20,4.19,0.65,1.19,1.40,1.97,-0.30,-0.30,0.69,0.43,-0.41,1.05,-1.37,1 --0.92,0.57,0.47,-0.06,0.41,1.57,1.45,0.84,-1.44,1.54,2.95,2.78,3.25,3.38,3.57,2.81,2.83,2.38,0.30,-0.27,-0.10,0 -1.20,-0.60,1.13,1.35,1.97,2.51,1.16,1.36,3.45,0.97,1.65,1.93,1.93,0.89,3.59,2.97,3.46,2.03,0.38,-1.60,-0.42,0 --0.19,2.78,2.59,0.05,-0.87,2.44,2.37,-0.17,1.12,2.08,1.03,3.18,4.61,3.78,4.69,2.55,3.51,0.83,3.49,-0.24,1.07,0 -0.61,-0.26,-0.59,2.57,3.64,2.98,3.08,1.78,2.31,1.29,3.07,3.08,2.87,3.65,4.21,1.88,2.71,1.33,1.68,0.26,2.33,0 -0.10,-0.25,1.36,-0.54,1.30,2.98,0.81,-0.12,0.26,0.42,1.68,2.31,3.01,4.56,4.66,4.18,2.99,3.35,1.30,1.35,0.65,0 -1.52,-0.17,2.97,3.25,2.82,2.17,3.02,3.19,1.38,2.95,3.27,4.25,-1.20,2.31,-0.33,1.47,2.83,0.63,-0.38,1.15,-0.22,0 -0.01,0.64,0.20,1.73,0.42,0.08,3.19,5.18,4.08,4.60,5.22,3.12,3.03,1.40,2.09,0.92,1.01,-1.18,1.45,-2.17,-1.11,1 --0.84,0.53,-0.27,2.05,-0.25,2.05,0.72,-0.32,0.66,2.54,2.44,2.84,4.69,4.47,5.37,4.90,3.05,2.73,2.38,1.70,0.17,0 --0.20,-0.21,-0.90,2.42,2.13,2.34,4.94,3.93,6.29,2.84,2.68,2.55,2.16,0.82,0.39,-0.39,0.53,-1.00,-0.34,-0.00,0.77,1 --1.52,-0.29,1.27,1.91,3.25,1.84,1.39,3.13,1.52,2.46,0.57,2.44,1.59,2.63,3.60,3.10,2.74,0.92,0.92,2.02,0.65,0 -0.99,1.59,2.47,3.52,4.13,3.65,5.53,3.60,3.74,3.39,1.94,0.04,1.20,-0.04,0.53,0.68,-0.92,-0.30,1.25,-3.57,-1.40,1 -0.20,-0.27,1.14,-0.07,0.34,2.15,4.19,3.35,2.45,4.21,4.75,5.59,3.09,0.91,2.85,0.12,1.14,-0.47,0.08,0.74,-2.16,1 --1.77,0.16,1.47,1.36,0.86,2.23,4.15,2.13,4.93,5.27,5.52,4.87,3.29,2.65,-0.07,1.49,1.36,-0.56,-0.19,-0.05,1.23,1 -0.80,0.82,0.55,1.70,2.56,5.06,5.51,3.39,2.69,3.97,2.60,1.03,1.04,1.83,2.32,-0.37,1.07,1.65,0.86,1.19,-0.02,0 -1.07,2.60,1.10,2.44,4.18,4.38,5.69,5.21,3.87,1.75,2.90,0.95,-1.28,1.07,-0.75,-0.14,-0.45,0.64,1.57,-0.30,-0.58,1 --1.14,-0.43,1.27,3.12,0.71,2.64,3.66,2.57,5.39,1.47,5.31,3.28,1.68,1.43,0.65,0.34,1.08,0.38,-0.49,-0.11,-0.77,1 -0.67,0.31,0.97,0.44,-0.18,1.90,1.82,1.04,1.75,0.87,1.23,1.90,2.79,4.46,4.99,4.77,3.61,3.15,-0.52,0.73,-1.06,0 -0.13,-0.10,1.05,1.89,2.97,4.03,4.39,3.60,3.02,3.02,1.89,2.12,0.70,2.46,4.28,1.52,1.25,1.00,1.73,0.97,0.06,0 --1.29,1.35,0.94,3.43,2.17,4.17,4.47,3.30,3.36,2.29,2.77,2.54,1.27,1.51,2.43,3.46,2.35,1.07,2.83,0.81,-0.81,0 --0.34,2.88,2.78,2.27,5.14,5.11,5.66,5.12,4.86,3.62,1.90,0.54,1.58,0.26,1.68,-0.38,0.22,1.60,0.80,0.49,0.68,0 --1.04,-1.82,0.86,-1.05,0.82,-0.14,-0.57,-0.62,0.82,1.38,0.55,3.59,4.21,5.47,6.26,4.16,4.95,1.77,0.62,1.59,-0.44,2 --0.61,1.44,-0.37,-0.83,-0.70,0.65,1.67,2.03,4.82,4.02,4.62,3.47,2.91,4.15,4.80,2.60,0.37,1.97,0.47,0.15,0.36,2 -1.97,-1.45,0.27,-0.89,-1.23,2.22,1.22,5.36,3.95,4.99,6.48,6.71,3.50,3.22,2.03,0.79,-0.22,-2.45,-0.14,-1.97,-1.41,1 -0.87,1.22,1.08,2.97,4.44,3.99,3.63,3.68,2.97,3.42,0.59,0.70,0.73,-0.14,-1.62,0.57,0.93,0.43,0.16,-0.36,0.21,0 -1.30,0.79,3.59,3.69,4.51,7.00,5.16,5.90,3.90,2.54,3.62,0.03,1.43,3.14,-1.22,-0.26,-0.44,-1.50,-0.01,1.32,1.58,1 --2.03,0.35,2.13,2.05,0.18,2.64,2.82,3.81,3.14,4.55,4.34,4.46,2.89,2.99,1.33,2.36,0.80,-1.27,0.60,0.59,-2.23,1 --0.76,0.20,2.10,-0.62,0.52,1.52,0.11,1.17,2.60,0.99,2.93,1.09,1.10,4.23,5.37,4.56,3.04,4.12,0.83,0.47,-0.11,0 -1.25,-1.28,-0.32,1.33,0.26,1.29,-0.32,0.60,1.26,3.20,3.78,2.58,4.88,4.81,5.77,1.23,2.48,1.35,0.83,0.34,0.90,2 --1.51,-0.49,0.96,1.64,1.85,4.58,3.75,6.32,3.35,2.71,0.99,0.82,1.24,1.27,0.63,-0.63,0.94,0.01,-0.27,-1.57,0.16,1 --0.18,0.55,0.66,3.21,4.87,3.10,4.92,4.13,4.32,3.68,4.17,0.46,1.23,0.62,0.44,0.52,0.41,1.39,-1.10,0.77,0.49,1 -0.23,1.18,-0.59,2.35,3.50,2.97,3.11,5.61,2.41,2.24,4.26,4.66,1.95,2.56,1.31,-0.53,-0.29,-0.41,1.45,-0.17,0.57,1 --0.18,0.90,0.63,1.32,0.31,0.53,-0.99,1.84,1.03,0.98,2.47,3.92,3.14,6.60,5.75,2.41,4.28,1.32,2.43,2.57,-1.95,0 --0.51,0.06,0.49,1.26,0.73,0.97,1.95,2.03,3.35,4.44,4.86,4.36,2.86,4.40,4.29,3.14,1.20,2.15,1.95,0.21,-0.17,2 -0.43,-0.17,2.38,2.20,2.25,4.71,3.92,5.15,3.00,2.10,0.24,0.88,1.81,0.95,1.96,0.53,-0.20,0.73,-0.08,-0.26,0.67,0 -1.31,0.11,0.21,1.78,0.26,1.52,-0.16,4.10,3.83,4.61,7.09,4.29,3.24,1.80,3.91,1.22,0.73,0.19,-0.63,-0.59,1.74,2 --1.04,0.81,-1.59,-0.58,0.78,0.13,0.82,3.32,1.50,3.34,4.71,5.10,3.56,3.79,1.45,2.75,1.59,1.93,0.36,0.47,0.11,2 -0.93,-2.25,-0.81,-1.34,-0.04,0.34,2.28,2.68,4.29,3.34,7.43,4.76,4.08,3.42,2.01,1.71,0.25,2.81,-0.58,1.90,0.25,2 -0.21,-0.72,1.29,1.99,3.70,3.08,5.50,2.92,2.07,3.10,1.99,1.56,2.72,2.46,0.41,0.54,2.75,1.55,0.46,1.17,-2.21,0 --1.45,-0.12,-0.35,-0.57,-1.08,1.02,-1.39,0.17,0.95,1.04,3.79,3.31,5.43,3.34,5.19,4.91,3.39,2.38,1.84,0.79,-0.06,2 -0.63,-0.98,1.78,-0.73,-0.52,1.96,2.11,2.73,5.03,5.08,6.46,4.31,3.04,2.40,0.90,1.38,-2.17,2.97,-0.32,1.04,-0.40,1 --0.38,0.56,1.39,-2.00,2.68,1.33,1.27,3.62,0.19,0.94,1.63,0.62,3.83,2.97,5.67,4.52,2.64,3.41,1.30,0.39,-0.06,0 -1.02,0.09,0.23,1.63,2.43,1.24,0.45,1.00,0.72,1.39,2.71,2.54,2.45,3.00,4.89,5.14,2.16,2.85,1.22,-0.87,0.76,0 --1.06,1.37,0.03,1.36,0.71,2.87,4.11,3.29,3.98,1.10,1.73,2.57,0.87,1.39,1.21,0.46,1.71,0.03,1.11,-0.09,-0.42,0 -1.23,0.86,-0.18,1.07,2.45,1.53,5.81,4.45,4.36,2.97,5.11,2.55,2.29,0.75,1.31,-0.75,1.99,-0.43,0.31,-0.16,0.69,1 --1.81,1.39,1.51,0.01,1.59,1.13,2.35,0.36,0.56,3.11,2.20,1.80,2.53,1.04,3.68,3.35,1.02,2.19,3.12,-0.57,-1.13,0 -0.45,-0.02,2.11,2.81,4.60,2.59,4.43,1.62,2.42,4.34,2.50,2.57,0.69,1.99,0.82,2.05,1.71,-0.14,1.50,0.58,0.14,0 -3.12,0.88,2.40,2.47,3.71,3.94,3.41,2.60,1.46,0.07,1.52,1.85,2.24,2.26,0.66,1.24,2.07,-1.03,0.57,-0.40,-0.72,0 -0.85,1.09,0.73,-0.37,-0.77,0.41,-0.48,0.78,0.74,2.62,3.41,3.74,3.62,6.29,5.12,5.60,4.03,2.49,0.50,1.21,0.62,0 -0.21,0.49,0.21,3.13,1.53,2.73,6.78,5.59,5.57,3.10,3.79,1.53,2.38,-0.12,0.94,-0.66,0.60,1.69,1.40,0.88,-0.99,1 --1.62,0.68,1.20,-0.74,0.49,1.24,1.79,0.53,-0.61,2.00,2.66,4.24,2.43,3.79,5.17,4.44,4.51,3.09,2.41,1.62,-0.44,0 -0.74,-0.91,0.78,0.24,0.09,0.57,2.84,3.30,3.41,5.42,6.83,4.31,4.90,3.28,3.55,0.13,0.42,-1.68,0.53,-0.45,-1.07,2 -0.29,0.31,-0.31,-0.50,0.02,1.58,0.80,0.49,4.47,2.81,4.30,3.42,3.29,4.42,3.66,3.47,3.21,2.74,0.46,1.49,1.32,2 --0.02,-0.12,0.80,0.25,1.81,0.02,1.17,2.90,1.92,2.16,6.04,7.24,2.55,0.44,3.14,-0.27,1.49,2.64,3.37,0.35,0.13,2 -1.40,0.86,0.27,1.91,2.48,5.17,5.10,4.46,4.33,2.65,3.28,3.34,0.40,1.07,-0.39,0.31,1.08,0.56,-0.62,2.49,-0.91,0 -0.25,0.93,2.91,3.28,1.66,1.75,2.19,2.24,2.46,2.04,1.90,1.40,2.06,2.34,2.88,4.74,1.52,2.09,0.45,1.41,1.16,0 --0.86,-0.59,1.96,0.26,1.55,2.10,2.05,1.08,3.26,2.12,2.77,1.56,1.93,1.78,5.16,2.02,2.57,1.91,0.14,0.32,-1.20,0 -0.60,0.91,0.91,0.88,0.79,3.36,4.26,2.56,3.38,2.42,2.07,2.49,1.28,1.07,0.66,1.87,1.07,0.28,-1.66,-0.43,-0.66,0 --0.50,0.07,-0.74,0.94,0.44,1.54,2.56,3.81,3.28,3.49,6.08,5.90,3.18,2.58,4.08,2.33,1.58,-0.53,-0.41,0.21,1.26,2 -0.88,-0.55,-0.89,1.06,-1.40,-0.50,4.47,0.57,2.05,5.45,2.68,4.43,3.36,2.63,2.74,2.43,0.72,1.14,0.93,0.38,-0.84,2 -1.24,0.92,0.54,1.86,1.63,2.06,1.91,1.17,1.15,1.77,2.77,0.96,3.64,2.31,1.79,1.69,2.54,0.52,-1.22,-1.09,0.34,0 -0.39,1.02,2.81,0.78,3.38,3.38,6.08,3.22,5.34,4.99,2.82,5.37,1.02,1.17,0.95,0.03,-1.02,-2.01,0.26,-0.43,1.36,1 -1.21,0.72,-0.30,-0.67,0.54,0.48,0.04,1.13,-1.83,0.08,1.34,2.96,2.79,4.68,6.28,4.98,3.32,2.41,0.12,2.28,-0.20,0 --1.35,0.98,0.74,3.33,2.65,0.58,3.69,3.80,1.65,3.15,0.62,2.73,0.20,4.66,2.91,2.73,1.36,0.44,0.36,3.31,0.05,0 --0.03,1.51,1.33,-0.08,-1.20,0.91,2.16,3.48,4.21,4.40,6.02,5.73,4.52,4.24,0.63,-0.70,-0.90,-0.06,0.15,-0.89,1.09,2 -0.29,0.86,-0.57,1.09,-1.02,0.80,1.89,2.84,1.56,4.02,3.32,4.44,4.41,5.89,3.52,2.68,1.49,-0.23,0.08,-0.29,0.18,2 -1.25,0.48,2.90,2.12,3.38,5.43,6.42,6.34,4.58,1.81,1.33,0.57,-0.59,0.74,0.16,-1.42,-0.40,0.78,-0.81,-0.84,0.39,0 -0.75,-0.14,0.17,2.55,-0.33,2.69,2.28,3.69,3.27,5.19,5.84,3.62,2.14,4.31,0.74,-0.26,-1.14,-0.38,0.54,0.68,0.80,1 --1.35,-0.34,-0.08,1.61,0.32,2.79,4.60,2.64,0.95,1.40,1.51,1.69,1.42,2.30,3.78,4.13,0.96,0.74,1.02,1.60,0.34,0 -2.09,-0.24,0.24,-1.01,-1.74,2.75,0.89,0.37,2.97,0.78,2.36,3.66,4.14,4.34,3.36,3.26,2.33,0.41,0.48,1.84,0.45,2 -1.39,0.36,-0.62,0.52,-0.09,-0.19,0.18,-0.24,-0.67,0.55,3.20,3.21,3.99,6.15,5.53,5.97,5.63,2.71,1.52,1.18,0.25,0 -1.06,1.48,2.27,3.91,2.37,3.66,5.44,3.24,3.10,2.07,2.51,1.77,0.89,-1.25,0.21,1.71,-0.55,0.93,0.99,1.57,0.48,0 --0.97,-0.69,2.90,1.28,-0.28,3.38,3.69,5.74,5.61,2.80,3.19,2.74,0.25,1.17,-0.23,0.17,0.62,-1.60,-1.05,0.34,1.22,1 -2.00,-0.73,-0.26,0.62,-1.50,0.05,0.97,1.55,3.19,4.47,4.10,5.12,3.70,4.31,3.85,0.75,2.87,0.10,-0.42,-1.20,-0.79,2 --0.04,-0.52,-0.81,1.88,0.55,1.05,1.41,1.80,4.53,4.21,6.10,4.30,4.46,2.94,1.93,2.75,0.71,1.03,0.29,-0.06,-0.63,2 -0.73,0.00,0.28,2.70,2.47,1.18,3.61,1.26,1.71,1.43,2.28,1.72,2.23,2.50,4.91,3.57,3.09,2.22,1.35,0.50,0.58,0 --0.13,1.19,0.11,1.43,1.21,0.39,-0.36,2.10,2.66,2.32,4.95,4.66,3.97,3.01,2.64,1.99,1.49,-0.19,0.43,-1.18,1.69,2 --0.85,-0.23,0.61,-0.30,1.87,1.77,1.13,2.84,5.05,3.17,5.14,3.77,3.93,1.75,2.27,1.27,-0.76,0.57,-0.91,-1.15,-0.24,1 -1.59,0.77,-0.04,1.64,1.66,2.88,1.48,1.56,1.66,3.68,2.47,1.98,0.54,2.48,2.84,1.80,2.75,1.26,0.97,0.94,-0.42,0 -0.13,-0.65,0.43,-0.55,0.07,-0.29,1.58,2.11,3.08,3.90,3.87,5.56,5.02,5.97,2.79,4.51,3.22,0.57,1.44,0.02,-0.57,2 -1.34,0.42,0.02,0.01,1.12,2.10,1.70,3.11,2.27,3.41,3.73,5.24,4.54,2.33,3.39,2.68,1.53,-0.33,2.78,-0.34,-1.26,2 --1.25,0.91,-0.72,-1.30,-0.39,1.72,1.96,2.67,2.59,3.76,4.48,5.11,4.52,4.70,2.29,1.26,1.60,0.41,-0.63,-2.24,0.42,2 -0.31,1.08,1.00,0.18,1.65,1.03,4.96,2.56,2.98,3.36,3.08,3.03,2.44,2.16,0.74,1.47,0.30,-0.61,-1.70,1.39,-1.44,1 -0.06,0.23,0.40,3.62,2.49,2.16,3.89,3.28,4.06,5.30,3.90,2.77,1.63,1.66,1.68,0.27,1.14,-1.43,-1.14,0.31,-0.54,1 -0.15,0.61,0.70,0.92,1.60,3.40,2.63,3.69,3.24,1.26,2.51,1.66,0.96,2.12,2.32,2.07,-0.93,1.80,1.88,0.66,0.37,0 --0.33,1.08,0.94,3.93,2.55,3.24,5.29,3.75,4.01,2.02,3.23,4.66,0.76,1.31,0.54,0.23,-0.49,-0.43,1.42,0.17,-0.51,1 -0.44,2.99,-0.23,-1.20,-0.39,1.65,0.42,1.69,1.60,0.99,1.91,2.00,3.00,3.91,5.24,5.05,4.11,1.55,0.28,-0.16,-0.24,0 --2.10,-0.47,-1.80,0.89,2.05,3.91,3.89,3.78,3.00,2.65,0.65,1.71,4.46,2.05,1.59,1.22,1.94,-0.14,0.03,-2.50,0.04,0 --0.69,-0.85,0.39,-0.19,2.52,2.35,1.22,2.23,1.90,2.63,0.23,-0.29,3.35,2.18,3.57,3.66,2.19,2.26,0.45,-0.22,-0.64,0 --0.24,0.20,0.78,-0.36,2.55,4.19,3.76,5.49,3.21,3.67,5.29,2.86,1.87,1.23,-0.15,1.04,0.90,-0.03,-0.55,0.15,0.70,1 -0.31,0.66,2.88,0.33,1.47,0.66,0.41,2.68,4.57,6.77,5.97,4.51,4.16,1.94,1.97,2.03,0.26,0.62,-0.61,-1.45,0.42,2 --0.59,-0.13,2.04,4.06,4.91,4.62,5.41,2.27,3.87,2.13,1.12,0.44,-0.75,1.23,-0.04,1.09,-2.23,-0.75,0.79,-1.50,-1.17,0 --0.83,-0.15,-1.73,2.20,0.96,0.48,1.47,0.74,0.72,0.82,1.85,2.22,1.45,4.63,5.14,3.68,2.66,3.09,2.05,0.12,0.78,0 -1.31,-0.75,1.00,3.17,4.19,3.78,4.24,3.86,3.46,3.16,1.04,1.27,2.24,1.14,1.86,0.90,-0.39,0.48,-0.16,-0.06,0.36,0 --1.15,1.02,-0.16,0.22,0.43,2.02,4.23,3.60,2.87,3.46,5.26,4.15,5.50,1.33,2.10,-0.33,-0.51,1.20,0.35,-0.29,2.18,1 --1.10,2.06,1.04,1.33,-0.44,0.42,1.75,1.94,2.61,4.72,3.86,6.89,3.46,4.22,1.34,2.02,0.69,0.08,-0.66,-1.68,0.35,2 -0.17,-0.87,-1.65,2.41,1.87,2.17,4.19,1.94,2.65,2.90,1.72,2.23,2.32,1.92,3.75,2.80,1.17,2.42,2.56,1.45,-0.94,0 -0.84,-0.74,0.58,3.06,-0.59,4.18,2.34,2.65,4.08,5.24,2.87,4.20,3.62,2.03,0.66,2.32,1.92,1.34,0.47,0.91,0.17,1 -0.78,-0.36,1.15,-1.36,2.50,2.40,1.45,1.74,0.94,2.72,2.81,1.44,2.69,4.53,5.03,2.03,2.60,1.57,0.70,-0.85,0.77,0 -0.09,-0.79,-0.39,-0.67,-0.26,-0.12,1.26,2.58,1.82,5.44,6.08,4.33,4.65,3.28,3.92,0.12,-1.45,1.80,0.12,1.98,0.90,2 -0.14,2.03,3.50,1.54,1.99,5.96,5.52,3.83,4.22,2.82,1.00,1.16,2.96,-0.97,-0.21,2.07,0.92,1.15,2.82,-1.00,1.15,1 --0.28,0.41,1.34,1.15,-0.02,0.11,3.12,3.41,4.46,4.87,5.86,5.02,4.55,1.77,3.17,2.41,1.49,1.47,-0.25,-1.12,-2.04,2 -0.26,0.88,1.71,1.41,1.88,2.96,5.49,3.08,3.81,3.36,2.45,0.77,0.89,-0.78,1.53,0.55,-0.85,-1.91,-1.52,0.24,-0.57,1 -0.02,-1.18,1.27,0.62,0.75,4.48,4.87,3.71,5.01,6.00,3.84,3.07,2.10,3.32,1.14,0.33,-0.43,-0.90,0.12,0.53,0.20,1 -0.11,0.96,1.36,1.54,3.96,4.33,6.03,7.57,4.18,2.91,2.01,0.98,-0.01,-0.19,-0.42,-0.61,1.63,1.79,1.37,-0.44,-0.53,0 --1.72,1.03,1.46,2.39,2.01,1.97,3.78,2.54,1.31,2.22,2.98,-0.68,2.16,2.51,2.42,2.34,1.29,1.46,0.69,-0.20,-1.25,0 --1.90,0.58,1.50,1.82,1.97,3.38,3.88,3.42,4.49,4.63,4.08,5.34,1.99,2.35,1.10,0.87,-0.64,1.20,-0.16,-0.81,0.38,1 -0.53,-0.72,0.55,0.60,2.63,3.94,4.53,4.63,3.55,2.86,1.76,3.90,1.65,2.14,2.57,1.88,1.11,0.95,0.11,-1.33,0.18,0 -0.78,1.18,2.21,2.42,4.08,4.90,3.43,4.33,1.47,3.40,1.63,1.65,1.33,2.50,0.55,1.47,1.13,-0.35,-1.15,0.37,0.34,0 --0.44,1.09,-1.21,-1.52,0.21,0.35,2.46,0.86,4.01,3.55,5.91,5.18,5.58,5.07,1.75,1.78,2.74,-1.10,1.06,0.26,0.19,2 -1.96,0.83,-0.85,-1.89,0.06,0.46,1.04,1.88,-0.47,0.70,2.00,3.02,3.90,4.77,5.13,3.60,3.25,1.64,4.34,1.34,0.08,2 --1.79,-1.85,1.45,2.03,-0.41,2.24,-0.19,0.12,0.81,2.55,1.38,3.23,4.32,5.58,5.81,2.68,4.35,0.93,1.07,0.73,-0.06,0 -1.29,-0.91,1.93,1.58,-0.68,1.56,3.50,1.01,0.82,3.22,2.10,4.55,2.43,5.27,5.74,2.56,3.21,1.22,0.77,0.11,0.54,0 -1.11,0.09,1.49,0.76,1.70,4.86,3.36,4.11,1.83,1.75,1.85,1.80,1.33,2.99,0.07,1.99,0.69,2.47,0.97,1.30,1.57,0 -1.31,-1.72,2.44,-0.50,-1.88,0.32,3.32,1.45,2.73,2.50,4.11,4.59,4.85,4.39,3.16,2.23,-1.07,2.12,-0.31,1.37,0.42,2 -0.26,-0.74,1.38,1.58,1.94,-0.31,-1.08,-0.47,-0.13,0.86,2.09,3.04,2.71,4.34,2.86,4.18,1.56,2.41,1.42,1.66,0.30,2 --2.28,0.82,0.77,-0.13,0.51,0.21,-0.97,0.76,1.42,2.01,3.60,2.69,4.71,4.10,5.61,4.19,4.27,2.95,-0.04,3.18,-1.13,2 -0.73,-0.61,-0.13,-1.10,1.26,-0.64,2.26,0.34,2.53,0.47,4.17,4.27,3.08,4.70,5.00,2.29,1.31,1.95,2.10,1.67,-2.92,2 --0.36,1.25,-0.43,0.20,-1.99,-0.03,3.10,4.34,3.40,5.97,4.57,4.53,5.26,3.98,1.79,-0.03,0.37,0.88,-0.69,-0.07,-0.38,1 --0.32,1.17,0.90,-1.01,-0.42,0.11,0.78,0.94,2.69,1.27,3.50,1.60,2.90,3.68,4.36,2.94,3.53,2.84,1.22,1.19,-1.71,0 -0.14,-0.50,0.05,1.45,1.35,1.71,5.54,3.81,3.49,3.66,4.09,3.72,1.83,0.32,2.12,0.01,1.24,0.08,1.06,0.92,-0.21,1 --1.79,0.48,1.36,0.30,0.74,3.09,3.04,2.02,1.34,5.97,5.30,3.62,3.85,1.81,1.13,0.05,0.28,-1.40,0.66,0.09,0.47,1 -1.53,0.67,2.77,3.21,1.27,3.63,6.02,4.31,5.54,2.33,3.49,0.91,0.94,1.51,-0.17,1.40,1.30,-0.20,1.94,-0.26,-0.19,1 -1.08,-0.64,1.04,1.70,0.36,0.26,0.27,1.48,-0.08,1.99,3.06,2.18,4.36,5.01,5.53,5.62,2.56,1.09,3.39,-0.18,0.11,0 -0.41,1.67,2.27,0.94,3.31,2.04,3.40,3.17,0.80,2.85,1.90,2.27,0.31,0.59,3.02,1.58,3.37,0.23,1.16,0.83,-0.45,0 -0.63,-1.47,0.43,1.15,-1.40,0.99,-1.68,0.55,-0.80,1.28,2.54,3.46,4.52,3.74,7.10,5.16,3.36,4.69,2.00,3.15,-0.09,2 --0.88,-1.07,1.24,1.17,2.37,0.61,2.68,1.89,0.31,2.07,1.40,4.02,1.53,3.57,3.52,1.46,2.46,0.86,1.96,0.42,0.02,0 --0.68,1.71,1.78,0.29,1.48,0.40,1.62,2.03,2.23,1.22,0.23,2.77,2.01,3.65,5.47,2.15,3.28,1.55,-1.16,1.19,1.02,0 --0.96,1.18,0.81,0.82,-0.09,1.20,0.18,1.71,3.69,3.52,5.04,4.56,2.97,2.43,4.43,3.37,-0.37,0.57,2.92,-1.00,-1.17,2 --0.63,0.73,2.38,1.13,1.63,2.60,4.77,2.56,1.90,2.03,2.98,0.71,1.40,1.82,2.40,1.66,1.31,0.20,-1.03,-0.01,-0.46,0 --0.28,0.43,-1.54,-1.71,0.04,-0.39,-0.67,1.57,3.80,5.03,3.28,3.43,4.26,2.05,2.71,1.88,0.93,3.39,0.05,-2.41,-0.84,2 --0.96,-0.30,2.95,3.07,3.57,3.37,4.21,5.35,4.32,4.36,4.10,2.04,0.48,0.45,1.50,0.45,1.46,1.00,-0.49,1.19,-0.05,0 --1.02,1.49,0.25,1.53,0.16,2.10,3.08,3.44,4.21,4.80,3.47,3.62,2.42,1.52,0.11,0.70,0.33,-0.79,0.60,-0.05,2.00,1 -0.34,1.33,-0.67,1.48,2.84,2.90,5.38,2.77,2.64,1.21,2.48,1.92,3.17,1.35,3.36,1.46,2.37,0.55,1.03,1.90,-0.22,0 -0.39,1.54,0.56,1.62,0.35,0.96,1.25,2.34,2.23,0.94,3.20,2.10,3.74,3.91,5.50,2.52,1.55,1.88,2.20,0.58,-1.92,2 -0.41,-0.37,1.47,-0.43,-2.03,1.65,0.28,2.67,0.89,2.35,5.06,3.74,3.56,5.56,5.96,2.90,2.91,0.84,1.21,1.30,-0.18,2 --1.96,0.95,-0.75,-0.87,1.41,2.44,3.67,2.43,3.07,4.80,3.97,2.76,4.49,3.12,2.29,0.10,1.75,-1.54,-0.77,1.57,-0.64,1 --2.36,2.47,3.31,-0.18,3.52,3.01,3.38,4.74,3.72,5.34,2.99,3.35,-0.80,1.91,0.66,0.53,0.16,1.53,-1.08,0.07,-0.04,1 --0.30,-1.23,1.23,1.81,2.10,2.74,5.86,4.43,2.40,3.68,3.97,2.87,1.02,0.58,1.62,-0.72,-0.01,0.15,-0.55,-0.43,0.56,1 --0.21,0.11,0.66,0.08,-1.51,0.32,0.82,0.60,-0.55,0.87,1.89,2.12,2.72,4.96,5.37,5.86,4.39,3.72,0.87,1.61,-0.85,0 --1.92,-1.45,0.23,0.32,0.24,1.16,0.89,0.84,1.70,0.55,1.53,3.32,4.20,4.87,6.08,6.12,5.23,2.43,2.66,0.12,1.25,2 --0.12,-0.42,0.05,1.01,-1.16,2.51,1.95,2.42,4.78,6.56,7.24,5.60,4.71,3.71,1.80,0.76,1.36,0.27,2.11,0.57,-0.75,2 --0.03,-0.11,1.50,0.90,-0.92,0.60,0.27,0.10,0.63,4.30,3.73,2.52,4.64,4.88,5.77,3.51,4.47,1.56,2.11,0.43,0.49,2 -1.69,-0.17,-0.30,-0.10,0.52,0.78,2.18,2.45,1.71,5.15,5.76,4.23,4.63,2.15,3.30,0.94,-0.14,0.48,-0.77,2.19,-0.43,2 --0.46,2.32,0.88,0.12,-0.93,1.94,-0.82,0.70,1.62,0.90,2.10,1.04,4.43,5.60,5.05,2.13,2.49,2.75,2.08,-0.00,0.01,2 --1.13,0.83,0.33,2.25,2.38,4.27,4.50,5.86,6.32,1.99,4.79,1.05,-1.35,-0.34,0.80,1.33,-0.48,0.45,-1.15,-1.71,0.03,0 --0.31,-0.48,-0.87,-0.77,-2.04,0.21,-0.44,0.73,0.60,0.53,1.79,3.07,3.70,2.85,4.29,4.11,2.81,2.04,1.20,-0.73,-0.43,2 -0.56,1.26,0.45,1.04,0.54,4.16,4.66,3.93,3.92,3.60,2.69,0.96,1.70,2.13,1.94,0.58,-0.17,0.94,-0.30,0.52,-1.74,1 --0.33,1.02,1.98,2.27,2.04,6.35,5.52,4.14,4.48,3.71,2.37,0.08,-0.78,-1.97,-2.11,1.84,1.27,0.21,-0.79,-0.77,0.29,0 -1.16,1.25,2.86,2.44,2.86,3.44,6.67,5.90,3.62,3.03,2.91,1.94,1.23,-1.66,-0.36,1.32,0.37,-3.07,0.50,1.99,0.75,1 --0.96,-1.13,1.22,2.24,1.92,2.75,3.72,2.60,4.66,5.18,4.83,4.17,3.49,3.02,0.23,0.32,1.38,-1.01,1.61,0.43,1.31,1 -0.77,0.30,0.48,3.89,1.83,1.89,3.18,3.02,2.88,3.33,6.07,4.07,4.14,0.54,0.91,0.83,0.35,-0.25,-1.09,-0.09,1.91,1 -0.94,0.16,2.82,2.97,1.58,2.24,4.31,2.88,1.19,1.51,0.74,1.09,1.82,0.47,1.29,1.60,-0.39,-0.02,-0.61,-0.11,0.19,0 --0.14,-0.07,1.00,2.02,2.39,4.32,3.85,3.29,2.23,4.66,5.88,1.75,3.24,-0.65,-1.25,0.06,0.06,0.30,-0.65,1.16,-0.10,1 --1.45,-0.27,0.67,0.11,3.02,4.28,3.32,4.19,3.68,4.31,3.35,2.97,1.23,1.04,2.42,-0.63,-0.75,-0.32,-0.25,-0.60,0.34,1 --0.65,0.99,0.14,4.50,3.90,3.60,4.66,5.61,3.41,3.77,3.33,0.79,2.90,-0.59,-0.89,-1.83,1.07,1.76,-0.76,1.10,0.70,1 -0.48,1.51,0.27,4.10,4.28,5.47,5.97,6.16,3.34,3.29,1.67,0.76,1.19,-0.99,1.27,-1.10,-1.80,0.48,-0.32,-0.47,-0.19,1 --0.61,0.09,0.58,-0.28,0.93,1.13,3.63,2.21,4.65,5.86,7.16,3.77,4.44,0.56,2.42,1.63,0.07,0.06,-0.39,-0.21,0.94,1 --0.06,0.54,0.06,3.88,1.59,3.53,4.35,5.62,4.14,3.40,3.33,2.53,2.66,1.38,1.37,-0.25,-0.94,-0.45,-0.53,-0.22,1.73,1 -1.28,-0.27,0.69,-0.69,-0.46,-0.26,2.52,1.19,0.09,1.50,1.58,4.83,2.59,3.93,5.06,4.98,2.58,3.86,3.35,0.62,-0.22,2 -1.20,-0.50,3.34,3.58,4.29,4.58,5.11,4.22,3.25,1.97,0.80,2.14,1.68,1.48,1.49,-0.44,0.24,0.43,0.75,-0.57,-0.07,0 --1.09,0.23,1.76,2.52,3.34,4.23,7.85,3.02,2.13,3.44,1.64,0.76,-1.04,0.45,1.18,1.39,1.18,0.06,0.83,-0.41,1.67,0 -0.32,-0.22,0.27,0.41,0.77,2.08,1.44,-0.09,1.77,1.74,4.46,1.09,3.01,4.35,4.24,2.59,3.42,1.54,1.87,1.47,-0.44,0 --1.20,-1.50,-0.21,0.63,-1.02,-0.13,3.06,2.88,2.73,3.12,7.77,3.47,3.78,3.40,3.36,1.34,1.98,1.44,-0.01,-0.31,-0.86,2 --1.36,-1.56,0.73,0.78,1.30,-1.05,2.00,-0.16,1.30,2.61,2.69,2.92,4.87,4.99,4.37,4.26,3.18,2.52,3.08,0.59,0.67,0 -0.07,1.00,2.48,2.20,2.34,4.65,5.49,6.71,5.86,2.46,5.44,2.73,2.09,-0.29,2.31,0.73,1.85,0.49,0.87,-0.95,-0.41,1 --0.21,0.80,0.97,1.69,3.50,3.71,6.79,6.50,4.38,2.66,3.20,1.68,0.46,0.72,-1.12,0.72,0.15,-1.49,1.15,-1.77,0.33,1 -1.30,-0.27,1.90,-0.41,3.19,0.58,1.43,1.98,2.34,2.78,1.35,2.58,3.54,2.61,3.00,3.14,1.81,2.53,1.11,0.00,2.48,0 -1.01,-0.47,-1.45,-1.51,-0.11,0.61,0.19,2.03,2.35,3.79,5.10,4.23,4.72,3.72,2.38,3.21,1.34,-0.26,1.10,0.74,-1.49,2 --1.59,-0.43,-1.02,-0.53,-1.36,2.24,1.99,1.81,3.82,5.25,6.05,1.19,4.01,4.21,2.65,2.79,-1.40,0.36,-1.05,0.73,1.26,2 --0.59,0.71,1.48,2.02,1.65,3.87,4.90,1.24,4.47,3.93,3.85,1.34,1.78,1.46,2.93,2.09,0.57,-0.53,1.31,0.08,0.21,0 -1.04,-0.41,-2.07,0.87,1.94,-0.20,-1.33,-0.59,-0.90,-0.54,2.62,2.44,4.43,3.85,6.43,4.55,4.38,2.90,1.68,-1.64,1.16,2 -1.30,2.26,-0.28,-0.59,0.52,2.24,0.72,3.02,1.88,2.07,1.26,1.55,3.88,4.54,6.19,4.80,3.61,2.76,1.35,1.84,1.62,0 -0.85,0.43,1.92,4.88,2.01,2.39,4.94,3.77,2.35,2.72,0.76,1.18,3.84,3.01,1.17,2.39,2.94,0.11,1.03,1.57,0.38,0 -0.11,0.58,-0.02,0.92,-2.20,-1.82,1.18,0.66,-0.28,0.70,2.28,1.84,2.21,3.85,6.54,5.03,4.59,2.17,1.00,2.20,-0.86,0 -0.73,0.99,1.67,3.42,0.88,3.68,3.95,3.95,4.15,4.77,5.21,1.05,1.75,1.63,1.40,0.65,0.68,0.69,1.01,0.29,1.03,1 -0.91,-1.12,0.57,0.56,-1.52,-0.98,3.59,3.37,2.56,4.20,4.43,4.65,4.13,3.08,3.10,1.29,0.51,-0.20,-0.29,1.40,-1.58,2 -1.19,-0.64,1.03,-3.84,-0.32,0.55,0.75,3.76,3.23,3.72,4.78,6.18,2.06,3.16,3.66,2.71,1.02,1.26,0.36,0.49,-1.27,2 --0.33,-0.83,0.61,-1.35,-0.00,2.08,2.16,0.35,2.36,2.27,5.12,4.89,3.54,3.51,3.97,2.36,1.81,0.60,-0.24,0.91,0.46,2 --1.80,2.71,1.93,1.42,1.26,4.31,3.01,4.69,3.41,1.23,2.35,1.59,1.70,2.91,0.76,-0.51,-1.40,-0.52,-0.05,-0.96,-0.12,1 -0.35,0.26,1.19,0.20,2.01,5.15,3.90,1.56,2.15,1.79,2.02,2.53,0.88,3.00,0.48,3.22,-0.49,1.65,0.07,-1.01,-0.11,0 --1.16,-1.11,0.11,-1.09,0.94,1.25,1.37,1.67,4.82,3.88,4.33,6.84,3.29,2.91,3.50,0.82,-0.00,0.40,-0.04,-1.73,-0.06,2 -0.32,1.06,0.30,-1.71,1.41,-0.56,1.94,1.40,1.45,4.67,5.08,4.45,3.07,3.88,2.55,2.11,1.63,0.66,0.82,0.90,0.79,2 --0.48,0.18,0.63,2.55,0.50,1.05,-0.59,-0.15,0.30,1.79,3.25,3.10,1.03,3.23,3.75,5.39,3.93,3.79,-0.71,-0.23,-0.56,0 -1.00,0.02,0.21,0.38,-0.46,1.64,1.11,1.14,2.88,3.26,3.40,3.25,5.63,4.96,6.37,5.25,1.26,3.57,3.14,1.73,-0.50,2 --0.96,-1.81,-0.44,0.05,1.55,0.90,0.27,1.53,1.99,1.21,1.46,4.28,4.93,6.46,4.21,4.68,1.53,0.99,0.88,0.63,0.72,0 -0.50,-1.82,-1.30,-1.30,0.68,-1.85,1.55,-0.04,1.85,3.88,2.31,3.06,2.61,4.20,3.85,5.19,1.77,1.16,3.02,-0.44,-1.33,2 -0.36,0.21,0.59,1.11,3.24,2.40,5.03,2.72,4.92,4.62,2.56,1.96,3.04,2.55,0.52,0.84,-0.25,-0.45,-0.20,-1.68,-2.00,1 --0.52,-0.27,3.25,2.87,3.16,4.23,3.83,2.43,3.69,4.34,2.35,-0.05,0.14,-0.56,2.71,0.42,1.35,0.76,1.47,1.04,-0.47,0 -1.09,2.36,2.20,2.10,3.34,5.45,6.70,3.96,4.29,5.11,2.14,1.11,-0.06,0.65,0.51,-1.81,0.79,1.90,0.67,0.28,1.17,1 -0.58,0.27,0.60,1.17,2.97,2.45,4.31,4.26,2.39,2.41,0.11,2.74,0.38,1.56,1.06,0.89,0.11,-0.58,-0.04,-1.36,-1.07,0 -0.11,0.97,-0.48,1.90,-1.16,0.98,0.29,2.48,3.78,3.17,5.03,5.01,2.23,3.48,2.76,3.47,1.64,1.82,1.46,3.19,-1.59,2 --0.24,1.19,-0.95,2.03,1.78,3.09,3.58,3.26,1.18,2.99,2.59,1.96,1.32,3.89,3.45,4.93,2.38,0.44,1.67,0.40,0.20,0 --0.65,-1.24,3.02,3.36,5.01,4.07,5.02,4.26,4.30,3.26,3.44,1.56,1.37,-0.05,-0.84,1.52,2.88,-0.72,0.66,-1.25,0.86,0 --0.74,0.45,-0.60,-1.24,-0.86,3.34,3.60,4.11,4.93,6.63,5.01,5.93,4.12,3.09,2.96,0.66,-1.01,-0.56,0.20,-2.16,1.49,1 --0.56,-0.64,0.97,-1.24,0.23,1.82,4.03,4.10,2.71,4.80,5.10,4.23,1.64,2.83,0.24,1.99,0.97,-1.75,-1.09,-2.01,-0.43,1 --1.07,1.22,0.02,0.34,0.00,0.30,1.61,1.06,1.98,3.11,4.97,3.64,4.34,3.98,3.89,3.49,1.67,1.48,-0.14,1.71,-1.38,2 --1.30,1.25,-0.39,0.99,1.40,0.60,1.95,0.80,1.96,2.54,4.26,1.84,3.79,2.72,3.62,2.52,2.74,2.03,2.38,-0.03,-2.00,0 -0.24,0.10,1.84,1.61,2.22,4.42,5.29,1.94,3.81,3.88,3.71,3.14,1.93,1.71,0.34,0.53,0.55,1.05,0.59,-0.19,0.65,1 -0.86,-0.62,2.72,1.51,1.75,4.98,5.35,4.88,4.27,4.97,1.94,0.87,0.29,-0.97,1.10,0.27,1.85,0.23,1.35,0.56,-0.04,1 --0.41,1.12,0.81,-1.26,0.08,0.74,2.03,1.56,2.08,4.22,3.49,3.24,3.73,4.22,1.99,2.31,1.12,-1.05,1.11,0.45,0.23,2 --1.38,-0.17,-0.06,0.34,-0.66,0.59,1.84,2.23,4.46,5.68,4.90,5.29,2.83,3.64,1.90,0.77,0.35,1.88,-0.39,0.39,-1.19,2 --0.51,1.46,1.67,2.68,2.69,3.25,5.29,5.55,3.36,3.16,3.23,3.54,3.97,2.23,-0.34,0.40,-0.94,0.44,-2.23,0.57,0.60,1 --0.24,-0.13,0.74,1.45,0.94,2.40,3.22,4.51,3.17,3.48,3.58,2.52,1.31,1.37,1.48,1.28,-1.11,0.81,0.43,-1.24,1.04,1 -0.60,2.89,1.50,2.90,4.75,5.62,5.16,5.83,3.92,3.48,3.24,0.66,0.35,-1.65,1.57,-0.39,1.98,-0.37,1.06,0.60,-1.37,1 -0.99,0.62,1.15,1.23,1.73,1.77,0.87,0.16,1.27,1.07,2.62,3.63,1.28,5.20,4.52,4.02,2.16,2.53,0.01,1.45,1.10,0 -0.13,-0.54,-0.77,0.01,1.80,1.97,4.72,4.41,3.52,3.68,6.29,2.32,1.90,3.42,0.96,-0.15,-1.24,1.31,1.10,-0.14,-0.58,1 -1.31,-0.28,2.08,1.26,1.77,-1.00,1.42,1.74,3.88,2.30,2.79,3.86,4.18,3.58,1.49,0.92,1.97,1.26,0.59,-0.22,-0.05,2 --1.19,1.14,-0.00,1.74,1.83,2.31,4.76,3.29,3.51,0.31,2.93,2.67,2.50,2.98,1.82,2.31,3.97,3.09,1.59,3.43,0.04,0 -0.94,-0.91,1.87,3.83,3.65,3.29,2.79,1.69,0.17,3.01,2.36,1.51,2.50,0.70,2.62,0.02,0.83,1.39,1.43,0.48,0.43,0 --1.62,-0.31,1.12,1.62,1.95,1.47,1.70,4.58,5.21,2.33,5.38,3.80,4.88,1.15,0.40,0.63,0.04,-0.59,1.40,0.22,0.31,1 --0.78,-1.16,-0.37,0.51,0.10,-0.02,0.42,0.19,0.37,2.29,2.51,3.16,5.02,3.50,5.77,4.56,3.10,3.56,0.67,1.73,0.58,2 --0.27,0.18,0.42,0.68,-1.14,2.11,-0.45,1.61,1.60,2.73,2.36,3.58,3.93,3.99,6.44,5.14,3.34,1.55,2.22,2.23,-1.30,2 --1.08,1.59,0.91,2.95,5.01,5.42,4.79,5.32,3.07,1.35,1.89,1.85,-0.61,2.12,-1.07,2.20,1.31,1.24,0.66,0.86,0.47,0 -0.24,-1.09,-1.92,1.28,0.71,1.23,0.31,0.08,2.02,2.91,4.53,3.40,3.22,4.70,3.69,3.57,1.20,0.51,1.32,1.48,0.15,2 --1.85,-1.65,0.15,-0.81,-1.24,1.83,0.52,0.21,0.50,1.70,0.93,3.28,2.98,2.83,5.91,6.34,4.07,4.24,2.15,2.44,-0.16,2 --0.03,-0.65,-0.06,-0.14,0.05,3.06,2.17,1.39,-0.25,1.80,1.86,3.03,1.62,4.35,5.52,2.72,2.33,1.72,0.57,0.52,0.85,0 --0.09,0.90,3.08,1.65,4.86,3.10,4.94,4.13,1.54,2.56,2.72,1.73,1.51,1.98,2.27,0.71,0.34,1.10,0.03,2.47,-0.09,0 --0.53,-0.55,0.67,1.23,-0.68,1.30,2.65,5.50,4.48,5.97,4.39,3.54,3.34,3.18,0.70,2.15,1.35,2.07,0.70,-0.70,1.55,1 -0.38,-0.98,1.66,3.62,2.39,1.99,4.02,5.73,3.41,3.51,4.36,-0.34,2.05,0.95,1.83,1.58,0.76,1.05,0.62,-0.21,0.18,1 --1.17,-1.30,-0.48,0.94,0.66,0.49,0.15,-1.74,0.82,-1.04,2.62,2.20,3.61,4.11,5.11,6.28,4.11,3.07,1.27,-0.42,-0.36,2 --1.44,1.64,0.36,3.02,3.38,2.84,4.52,2.87,2.52,1.08,1.58,-0.96,-0.68,1.76,1.13,1.50,0.55,2.95,1.03,-1.15,-0.00,0 -2.66,-0.15,0.35,0.50,0.20,0.05,1.30,1.90,2.32,3.50,2.91,5.98,3.48,3.19,3.16,3.05,1.72,1.27,2.09,-0.47,0.57,2 -0.23,0.47,1.25,2.14,3.99,6.37,6.37,5.12,3.68,2.74,0.26,-0.53,-0.13,0.33,1.10,-0.96,-0.09,-1.03,-1.29,0.47,1.93,1 -0.01,-0.27,1.24,5.19,3.38,3.09,6.14,3.11,2.46,3.79,3.57,1.13,1.15,-1.38,-0.25,-0.00,-0.03,-1.11,0.87,1.28,-0.28,1 --0.87,1.05,-0.83,0.33,-0.57,0.55,-0.48,0.36,4.27,2.61,3.05,3.34,2.29,3.92,3.84,3.98,1.08,1.21,2.70,-0.16,-0.17,2 -0.85,0.59,1.19,-0.20,0.70,2.75,5.26,2.00,4.56,3.86,4.35,2.88,0.40,1.41,0.75,-0.44,0.47,-0.63,-0.28,1.07,-1.25,1 --1.47,0.61,0.52,0.99,0.37,1.96,2.47,0.54,1.68,4.25,4.52,2.96,3.14,3.89,1.10,2.42,2.01,0.78,-0.33,0.35,-0.70,2 -0.56,0.85,1.57,2.20,2.90,2.58,3.21,2.00,1.56,2.11,1.70,2.91,2.15,4.28,4.16,1.99,2.81,0.11,0.73,0.58,1.97,0 -0.22,1.31,0.41,-1.40,-1.25,-0.59,1.40,2.12,2.47,5.24,3.51,5.77,3.14,2.20,3.32,2.85,0.89,0.60,1.10,-0.25,-0.30,2 --0.75,2.15,1.87,0.57,1.63,1.94,3.09,2.45,0.35,0.21,2.72,1.67,0.87,2.92,3.60,2.68,0.83,0.57,2.16,1.92,1.03,0 -1.29,0.16,0.70,-0.02,0.51,0.91,0.84,0.42,0.43,2.82,2.77,2.88,2.77,5.82,6.27,4.33,2.29,2.11,1.44,-1.08,0.22,2 -1.56,-0.27,0.85,-0.67,-0.01,1.78,1.72,3.84,3.48,6.07,5.92,5.58,4.57,0.16,1.02,-0.16,-0.55,0.99,-0.40,0.23,-0.50,1 -0.55,-0.72,0.52,-1.20,0.48,2.16,2.94,2.12,3.70,4.69,6.46,2.94,2.95,3.12,1.94,1.87,0.78,-0.58,-0.04,-0.54,-1.10,2 -1.22,0.12,1.88,0.88,-0.56,1.47,0.89,3.22,4.05,5.07,6.41,5.25,3.56,2.09,2.74,1.17,-1.10,0.59,-1.79,-0.34,1.76,2 -1.72,-0.37,1.52,0.18,0.02,1.00,-0.32,0.97,0.25,0.99,1.03,3.43,3.04,4.55,5.25,5.18,2.86,3.93,2.51,0.13,-0.43,0 --0.24,0.06,1.80,2.44,1.39,2.41,2.92,2.58,2.32,2.17,2.58,1.77,2.37,3.31,3.84,4.50,1.01,2.90,1.54,0.84,0.52,0 --0.72,-0.44,-0.39,-0.12,0.43,1.55,-0.30,0.42,0.45,1.79,1.72,3.95,2.83,5.46,4.40,4.07,2.21,2.66,2.47,1.19,0.26,2 --0.62,1.28,1.93,2.80,-1.07,0.93,1.10,0.19,0.80,0.43,4.07,2.22,3.47,2.94,5.89,4.37,4.11,2.99,1.67,0.92,-1.94,0 -0.75,-1.76,-0.33,-0.83,0.20,1.84,-1.62,0.49,0.73,3.29,2.79,3.78,3.25,4.69,4.48,4.21,4.16,2.86,0.25,0.54,-0.99,2 --1.63,-0.61,0.95,4.06,0.90,3.95,4.48,2.56,2.47,0.83,3.32,1.77,3.42,2.29,2.45,0.62,0.58,1.29,0.92,-0.79,0.33,0 --0.29,0.69,-0.35,3.36,2.56,2.85,5.32,3.09,2.96,5.15,3.52,2.29,3.97,0.18,3.12,1.76,1.97,0.51,-0.32,1.11,-0.33,1 --0.16,-0.12,0.07,0.91,0.36,2.69,4.27,3.68,3.76,3.54,2.92,1.81,3.10,0.22,0.31,-1.22,-1.10,-1.11,0.25,-0.24,-0.13,1 --0.32,0.42,-0.20,1.92,2.65,2.64,4.81,3.13,5.38,3.61,3.97,2.07,0.09,0.73,2.19,0.53,-0.43,0.28,-1.07,-1.18,0.43,1 -0.95,-0.00,-1.58,1.84,-0.12,2.77,2.87,3.44,4.68,3.28,5.17,2.89,2.12,1.69,2.27,1.49,1.54,-1.19,1.28,-0.29,-1.43,1 -0.79,0.65,1.61,1.12,0.94,3.08,3.06,3.29,2.82,2.19,1.54,0.76,1.00,1.80,-1.12,0.01,1.09,1.87,0.65,0.45,0.45,0 --0.54,-0.66,0.41,-0.92,-0.28,2.16,-0.43,2.92,1.50,1.00,1.85,2.38,3.18,3.24,6.13,3.49,2.32,2.40,1.76,0.54,0.37,0 -1.61,0.50,1.47,-0.46,-2.02,2.06,2.24,2.95,4.90,5.86,6.42,5.59,3.13,1.84,2.63,0.81,1.04,0.51,-1.47,-0.29,-0.40,1 -0.63,1.10,1.43,-0.10,-0.21,1.00,2.23,0.92,5.13,4.62,7.38,4.96,1.71,3.45,1.97,0.70,1.17,2.16,-0.30,-2.33,0.92,1 --0.48,-1.86,-1.42,-0.06,-0.18,0.90,-2.30,-1.40,0.21,0.60,3.42,3.91,2.94,5.70,4.52,4.54,2.81,1.36,4.27,1.34,0.42,2 --0.71,-1.92,-2.19,0.17,-0.42,1.11,0.96,0.96,3.20,3.92,4.11,3.60,4.34,2.79,3.41,3.60,2.32,0.61,0.87,0.34,0.42,2 --0.28,2.35,-0.25,1.96,1.04,3.05,1.73,3.67,2.23,2.36,2.39,2.11,0.65,2.17,1.70,1.67,1.55,0.89,1.08,0.54,0.25,0 --0.39,-0.64,-0.57,2.12,3.11,-1.29,0.93,0.80,-0.38,1.09,2.92,2.44,3.11,3.61,4.26,4.27,2.55,2.44,0.92,1.33,2.05,0 -0.51,-0.08,0.02,-0.34,0.61,3.15,3.20,3.47,4.23,4.03,4.09,4.70,3.66,2.09,1.02,1.69,0.27,-1.35,-1.04,1.46,-0.57,1 -0.62,-1.00,-0.32,0.26,-0.39,-0.02,0.03,1.49,0.85,1.71,3.25,4.33,4.33,2.43,5.27,3.68,4.26,2.12,1.11,2.59,-0.94,2 --0.17,0.67,2.65,4.15,2.87,3.53,4.41,3.88,4.90,1.45,2.91,0.68,-0.22,0.49,0.47,1.54,-0.44,1.06,-0.66,1.75,0.94,0 --1.52,1.50,1.18,1.98,3.18,5.18,4.56,4.42,4.68,4.65,0.31,1.11,1.05,0.11,0.72,1.49,1.03,0.73,-0.14,0.65,-0.12,0 --0.76,-1.26,0.82,-1.41,1.48,-0.62,-1.12,2.30,1.91,2.97,4.63,3.32,5.42,5.45,3.15,5.79,3.08,1.04,1.14,0.29,0.31,2 -0.75,0.05,2.84,0.30,3.75,2.37,5.99,6.53,1.92,2.73,2.57,2.61,1.87,0.63,2.58,2.25,1.25,2.55,0.17,-0.28,-0.53,0 --0.49,2.51,1.47,1.59,0.67,3.95,3.60,4.42,3.10,2.41,2.35,2.01,1.20,2.32,1.76,1.93,1.48,0.73,0.37,-0.30,-0.71,0 -0.74,0.36,2.29,3.75,3.56,2.72,4.86,3.39,1.69,3.75,2.88,0.76,0.54,1.14,1.96,1.96,2.27,0.75,1.37,-0.66,0.03,0 --0.08,-0.50,-0.65,-1.24,-0.83,1.32,1.85,1.11,2.85,3.85,5.31,4.49,3.89,2.97,6.19,1.29,1.65,3.18,2.77,1.29,-1.45,2 -0.51,-0.13,-0.71,-0.39,0.17,1.27,0.02,2.83,3.39,3.13,3.72,3.61,4.63,2.79,4.46,1.44,1.78,1.98,2.02,-1.42,-0.57,2 -0.51,-0.37,0.52,1.23,3.01,3.07,5.26,5.33,3.18,3.88,4.40,2.18,2.32,-0.15,0.71,1.19,0.62,1.54,1.59,-0.22,-0.10,1 --0.96,1.82,-0.20,-0.09,2.03,0.57,1.28,0.09,1.53,2.88,3.26,1.27,3.58,5.30,5.42,3.15,1.53,3.64,2.22,1.59,-0.58,0 --0.62,-1.45,-1.61,1.51,1.35,0.83,-1.52,0.28,2.98,4.78,4.74,3.84,2.54,3.80,5.10,2.10,3.13,1.28,-0.70,0.43,-1.00,2 --0.52,0.51,0.84,4.05,2.40,3.93,4.56,5.63,3.97,6.19,2.83,3.81,3.25,-0.52,0.55,0.24,-0.08,-0.53,-0.71,-1.58,-0.14,1 -1.02,-0.36,2.07,0.21,-0.39,0.66,1.65,3.79,3.52,4.05,4.16,4.84,4.86,4.01,2.31,1.74,1.24,3.67,0.87,-0.28,0.02,2 --0.14,-0.08,2.98,2.63,3.90,4.49,5.12,5.48,3.34,2.67,0.81,0.98,0.36,1.01,1.27,1.51,0.53,-1.00,0.16,0.56,-0.61,0 -1.24,1.19,1.21,2.38,1.49,2.48,3.60,4.62,2.94,4.05,3.78,2.49,-0.10,1.81,-0.76,0.31,-0.53,0.05,-0.63,-0.11,-0.47,1 -0.78,0.58,2.07,0.71,4.55,4.51,7.03,4.17,5.05,3.84,3.12,2.04,-0.53,0.24,-0.35,-0.28,0.83,-0.39,0.86,1.01,-0.39,1 -0.63,0.07,0.07,-1.61,-0.01,-0.05,1.73,1.35,2.52,2.85,3.61,2.90,4.57,6.78,3.88,3.60,1.78,3.42,0.31,0.84,-0.57,2 -0.10,1.22,0.20,-0.36,2.37,2.35,-0.26,1.36,-0.79,1.19,2.70,1.98,2.87,5.69,4.97,4.19,2.50,2.92,1.02,2.38,0.62,0 -0.53,1.45,1.16,2.52,4.46,3.68,3.58,2.41,2.08,1.19,1.63,1.12,1.95,0.74,2.48,1.84,1.78,0.66,0.84,1.52,0.26,0 --0.31,0.86,0.60,2.35,0.88,3.56,4.84,3.10,6.47,4.78,3.01,1.92,0.33,1.63,0.86,1.04,1.48,-0.28,0.38,-0.12,0.74,1 --1.32,-0.09,0.22,3.49,2.27,2.35,4.31,4.35,2.17,-0.51,1.98,0.66,3.01,1.24,2.69,1.33,1.09,2.16,0.58,0.19,-1.31,0 -0.58,0.65,0.22,0.17,0.93,1.43,1.77,3.73,4.42,3.39,5.09,4.27,3.41,2.62,1.39,0.09,0.80,1.48,1.18,0.56,-1.96,1 --1.10,-0.82,0.50,0.97,-0.26,1.07,-0.37,0.30,-0.70,0.84,2.41,2.31,3.38,5.26,4.82,4.58,1.99,3.73,1.87,0.14,-0.09,0 --0.59,0.88,1.11,0.01,-1.26,1.34,1.02,2.87,1.39,0.60,1.03,2.91,3.25,5.63,3.07,3.29,3.47,0.37,0.30,-0.87,-0.55,2 --1.68,0.15,-0.93,1.77,-0.59,1.10,2.81,2.13,2.67,2.20,4.60,5.21,5.00,3.06,3.33,4.72,0.57,0.07,0.83,0.27,-0.25,2 -0.42,-0.07,0.12,0.20,3.57,3.77,4.17,1.75,2.66,1.48,2.63,1.01,0.77,1.24,4.28,1.81,1.29,2.52,-1.06,0.73,0.61,0 --0.22,2.38,1.71,1.47,4.12,3.21,3.44,3.45,5.42,3.79,3.50,1.58,0.76,0.18,-0.68,0.05,-0.31,-0.53,1.46,0.02,0.46,1 -0.56,0.66,2.21,1.91,1.43,2.09,4.19,1.89,0.64,2.58,3.01,1.16,3.65,1.63,3.40,2.33,3.03,1.88,0.43,0.15,-1.32,0 --0.14,0.84,0.35,0.06,1.69,3.56,5.02,4.89,5.36,5.80,2.36,3.21,0.47,1.55,-0.03,0.68,-1.18,0.21,0.09,0.86,-0.60,1 -0.80,1.78,-0.78,-0.03,2.28,0.22,2.70,3.91,4.42,5.39,6.46,4.86,2.72,3.03,2.10,1.87,-0.96,-0.65,0.08,-0.07,0.56,1 -0.61,1.68,2.83,1.60,-0.29,3.06,1.85,1.94,3.77,4.00,6.38,5.62,4.52,3.10,3.10,2.58,-0.51,0.37,-3.50,1.06,0.10,1 -0.52,-0.75,-0.47,2.39,-0.37,0.97,-1.37,1.28,0.55,3.44,1.27,4.27,5.23,4.01,4.08,5.50,3.78,2.82,2.67,1.19,1.08,2 --0.21,-0.04,-0.73,0.32,1.47,0.81,-1.47,-1.90,0.29,0.76,0.96,1.57,4.23,4.40,4.42,5.48,2.05,3.86,3.71,1.32,0.67,0 --1.65,-0.66,1.05,-0.91,-0.29,-0.11,1.30,1.68,1.24,1.52,2.09,3.09,2.15,4.55,5.59,2.94,1.69,4.74,2.03,2.46,1.25,0 --0.38,-0.06,0.37,0.17,0.61,1.33,1.90,-0.45,1.52,3.30,2.54,2.50,3.68,3.53,3.72,2.86,2.39,2.50,1.35,0.15,-0.35,2 --0.19,0.34,0.14,1.88,1.44,0.55,0.41,1.21,2.06,0.36,0.84,1.32,1.98,5.23,5.88,3.60,4.64,4.36,1.07,-1.30,-0.52,0 --0.43,-0.47,0.28,-0.05,-1.08,1.38,0.34,1.11,0.55,2.23,3.18,1.31,4.12,6.28,7.42,3.25,2.70,0.32,2.55,0.78,0.27,2 -1.27,0.98,0.46,0.66,3.41,3.19,5.58,4.76,3.77,5.11,4.46,2.68,1.19,2.22,1.34,-0.21,-0.85,2.11,-0.89,-0.30,1.12,1 --0.20,-0.78,0.32,0.15,-1.30,-0.49,0.56,-0.64,1.12,1.74,2.43,2.40,3.37,4.70,5.70,3.07,2.52,2.13,1.69,-0.41,-0.09,2 -0.61,-0.19,1.59,2.52,2.39,3.38,2.52,2.58,0.85,1.86,2.99,2.34,1.78,2.53,2.95,3.97,2.36,0.51,1.39,0.72,-0.74,0 -0.39,1.19,0.48,-1.39,-0.14,1.66,-0.80,2.11,4.99,4.65,5.01,6.97,3.82,2.45,0.97,2.10,0.73,-2.22,-0.43,-0.16,0.60,1 -0.37,3.46,1.59,1.50,3.67,4.22,5.12,3.98,5.26,3.76,2.27,1.37,-0.11,1.33,0.64,1.38,1.20,1.24,1.11,-1.01,-0.94,0 -0.91,1.02,0.78,1.95,3.52,2.94,5.53,4.48,4.62,2.73,1.56,2.33,1.26,3.00,2.50,-0.17,0.55,1.10,-0.23,0.91,0.28,0 -0.40,-0.54,-0.07,0.09,1.89,0.10,3.72,3.66,3.45,4.74,5.82,4.22,3.31,3.41,0.64,0.61,0.35,0.69,0.52,-0.44,0.45,1 -1.20,0.50,2.18,3.45,1.69,4.31,4.35,4.26,2.82,4.15,3.06,3.01,1.55,1.15,-2.09,-1.37,2.84,0.44,-0.19,-1.22,0.07,1 -1.59,-0.19,0.84,2.14,3.34,6.04,5.39,5.14,4.45,2.67,1.90,2.02,-0.88,0.25,1.08,-0.69,0.27,0.52,-0.06,0.36,-0.29,0 -1.41,2.04,0.27,2.26,1.87,5.86,6.44,2.73,3.57,4.92,1.30,1.06,0.35,-0.11,0.97,-1.16,0.28,0.73,1.16,0.54,-0.87,0 -0.09,0.53,0.18,2.04,1.45,3.04,0.50,-0.40,0.01,0.98,2.80,1.15,5.16,3.16,3.66,3.38,3.49,1.63,2.00,0.28,-2.34,0 --1.09,-0.06,1.66,2.85,1.66,1.35,4.50,3.19,3.88,4.90,3.81,3.70,3.45,4.40,1.17,1.68,0.20,-2.58,-0.85,1.38,0.57,1 -0.25,0.92,0.18,-0.54,-0.12,0.32,1.79,-0.03,0.95,1.72,2.88,2.38,3.72,4.58,5.94,6.31,3.49,2.10,2.61,2.66,0.72,2 -0.34,-1.05,-0.80,-0.31,-1.05,0.97,1.51,1.17,-0.10,3.33,3.14,2.48,4.69,4.09,2.34,0.91,0.95,1.89,1.21,1.35,1.85,2 -0.20,1.74,3.71,1.65,3.20,2.90,6.29,6.43,3.59,2.64,1.83,1.64,-0.84,0.90,0.71,-0.32,-0.42,0.30,-1.04,0.71,0.13,1 --0.19,-1.21,-0.43,1.92,1.13,2.14,2.23,2.33,3.13,4.47,6.44,2.09,4.46,3.17,1.08,2.03,1.74,0.51,-2.56,0.85,0.76,1 --0.16,1.25,-0.82,0.14,0.65,0.95,-1.29,1.73,1.56,2.10,1.31,3.04,1.62,3.31,4.65,4.53,1.60,2.82,3.40,1.05,0.44,0 --0.05,0.12,1.88,1.36,1.21,4.63,3.53,3.68,3.67,4.06,4.28,4.23,3.37,0.79,1.56,0.08,-0.06,-0.29,0.21,-0.35,0.79,1 --0.14,-0.79,2.15,-0.30,-0.02,-1.31,-0.46,1.47,-0.46,2.49,3.63,2.97,4.17,5.11,5.54,4.41,3.15,3.81,0.49,1.39,0.26,2 --0.56,0.91,1.82,2.64,2.95,4.27,2.84,3.56,2.63,2.69,2.13,1.84,1.20,1.41,1.15,1.87,1.60,0.64,-0.05,-0.52,-0.10,0 --0.18,0.47,1.75,1.46,4.04,4.81,2.85,4.35,4.84,2.74,2.68,1.97,1.43,-0.31,-0.05,-0.30,-0.66,-0.78,-0.15,-0.80,-0.05,1 --0.95,-0.99,-1.77,-2.43,-0.55,0.94,1.68,2.84,4.89,4.75,5.02,5.88,4.06,2.01,3.28,1.04,-0.20,0.86,-0.01,0.75,-1.71,2 -0.68,-1.30,0.98,0.06,1.23,1.26,0.47,2.43,0.59,2.33,1.05,3.58,1.40,3.95,2.20,1.18,3.08,3.28,-0.29,0.15,-0.25,0 -1.04,1.30,2.55,3.43,2.72,4.75,6.21,3.75,3.37,3.14,4.17,1.41,1.62,-0.68,0.65,1.74,-0.51,0.28,-0.02,-0.06,0.61,1 -0.96,-0.02,1.62,0.91,1.27,2.15,4.29,1.19,2.76,3.13,2.33,5.39,2.79,2.94,2.74,0.58,-0.81,-0.76,0.16,1.44,-0.90,1 --0.26,0.10,-0.06,1.38,0.83,2.57,4.74,2.71,4.30,3.38,2.92,2.30,-0.01,2.37,2.51,1.98,0.87,2.09,-0.44,-0.69,-0.50,0 -3.17,2.13,1.96,2.11,2.19,5.38,5.36,4.43,4.14,1.33,2.66,1.32,0.22,-0.06,1.61,0.98,-1.77,0.56,1.02,0.65,1.76,0 -1.14,-0.28,-0.25,2.18,0.19,2.81,2.78,2.74,3.29,4.84,5.78,3.76,2.71,1.11,2.43,2.73,0.04,-0.19,-0.81,1.68,-0.42,1 -0.06,0.27,1.36,2.78,0.33,2.08,0.56,0.00,1.93,1.19,2.99,1.69,3.63,3.73,4.19,3.84,2.56,2.73,2.30,1.20,-0.11,0 --0.54,-2.05,-0.91,0.18,0.61,2.20,-0.96,3.27,0.16,1.08,3.43,3.84,4.40,5.30,4.02,2.10,2.39,3.02,2.45,1.89,1.14,2 -1.15,1.94,0.17,0.81,3.04,4.53,2.94,3.94,3.23,2.30,0.12,-0.49,-0.02,1.37,2.29,0.55,0.97,1.74,0.70,0.01,-0.67,0 -1.39,-0.39,0.37,-0.46,1.24,-0.75,1.28,2.33,-0.06,-0.39,1.60,3.50,0.85,4.40,6.13,4.41,2.41,2.87,1.86,-0.20,0.25,0 --0.65,1.73,2.92,2.83,3.88,3.84,3.49,1.08,-0.18,3.87,2.51,1.77,0.14,1.21,2.21,2.51,1.51,0.89,0.77,3.00,-0.46,0 --0.38,0.56,0.03,-0.89,1.84,-0.73,-0.55,-0.26,2.09,-1.76,0.85,0.96,4.87,2.61,7.24,4.50,3.71,2.82,0.89,2.95,0.34,0 --0.25,0.51,1.11,0.94,0.70,3.80,2.88,1.67,1.99,0.82,2.09,1.28,3.73,2.43,3.04,1.91,0.15,2.17,1.06,0.02,0.54,0 --0.77,-0.44,-0.92,1.06,0.44,-0.20,1.36,1.46,0.23,1.99,3.43,2.85,4.40,3.26,4.69,5.56,2.00,2.83,0.01,4.28,-0.06,2 --1.43,-1.25,-0.28,1.19,0.81,-0.74,-1.90,1.60,0.16,-1.15,1.28,3.27,3.27,4.31,6.94,6.60,3.46,2.12,1.05,1.01,-0.72,0 --1.11,1.01,-0.26,0.86,2.31,0.33,0.54,-0.64,-0.59,2.78,4.54,4.89,4.55,2.94,5.79,5.02,2.01,2.94,2.00,-0.63,-1.08,2 -1.36,0.11,1.87,1.12,-0.37,1.02,1.36,2.04,-0.25,0.27,2.20,4.05,4.36,3.42,3.89,4.98,4.28,1.81,0.18,0.53,0.01,0 --0.37,0.66,0.68,0.59,2.04,2.96,3.80,3.85,5.51,4.45,4.99,3.70,3.03,2.76,1.62,2.14,0.07,-0.31,0.78,-0.17,0.03,1 -0.23,0.51,0.06,-0.13,-0.99,0.40,-0.32,0.90,2.40,3.34,4.55,4.19,3.86,5.13,3.08,1.95,3.70,-0.61,-1.30,0.71,0.54,2 -0.40,0.76,1.53,1.99,1.72,3.05,1.49,2.19,0.85,2.40,1.85,2.52,2.91,2.72,4.55,4.23,2.65,0.25,2.29,0.29,-1.26,0 --0.49,-1.05,-1.62,0.45,0.84,1.06,1.91,0.65,1.54,4.58,4.69,5.56,2.90,1.42,4.14,1.95,-1.62,-0.93,2.91,-1.51,0.30,2 --0.57,0.70,0.25,1.20,1.98,-0.88,1.16,0.92,1.80,1.64,1.48,4.50,2.16,5.73,5.56,4.27,5.18,1.35,0.63,1.39,0.81,2 --0.41,3.20,1.82,1.99,3.67,5.36,6.37,4.04,4.36,3.69,2.12,2.08,0.61,-0.17,0.14,1.67,-0.34,-0.03,-0.10,0.79,-0.69,0 -0.70,-0.35,1.38,1.12,1.66,2.60,1.99,2.52,1.80,2.22,3.64,2.99,4.38,4.60,5.96,5.72,3.96,2.23,1.62,-1.09,-0.55,0 -0.21,0.80,3.50,3.24,5.03,5.77,6.90,6.36,6.17,2.26,2.38,0.51,-0.14,-0.43,-0.35,0.74,0.34,-0.37,0.77,-1.31,-1.28,1 -1.23,-0.23,0.71,-1.41,1.34,-0.02,1.68,1.49,2.62,5.03,3.14,2.73,4.70,2.31,2.40,2.57,2.48,1.79,0.58,0.00,-0.13,2 -1.57,-0.34,1.53,-1.49,1.44,-0.58,2.52,2.20,0.02,2.05,0.34,2.29,3.64,5.36,4.92,6.49,2.52,3.09,2.29,-0.51,0.98,0 --0.42,0.83,-0.84,2.13,-0.19,3.89,2.85,4.46,6.01,5.92,3.60,3.77,2.76,1.20,1.51,1.18,-0.54,0.46,-0.16,-1.33,-1.44,1 --1.77,-0.54,2.28,0.62,0.53,5.66,5.24,3.83,4.00,4.18,4.13,3.96,1.35,-1.17,-0.67,0.91,-0.35,-0.48,-0.80,-0.60,0.05,1 -0.24,-1.49,-0.87,1.24,0.33,0.78,1.93,0.83,2.47,3.00,4.75,3.78,4.99,2.29,4.67,4.68,0.75,2.09,-0.98,0.09,1.05,2 --0.56,0.26,1.26,1.63,1.67,1.86,3.86,0.52,3.31,2.23,0.92,1.99,4.14,3.04,2.44,3.94,1.85,1.62,2.15,1.18,0.32,0 -0.60,1.43,0.04,-0.05,2.20,1.96,4.74,4.36,4.66,2.88,3.19,3.62,1.74,1.07,2.94,1.02,0.42,0.69,2.13,0.17,0.04,1 --0.71,0.05,0.74,-0.25,0.64,0.08,0.53,3.41,3.71,4.95,5.15,5.04,4.23,4.03,1.04,0.68,0.89,1.42,-0.19,0.02,-1.25,2 --1.12,0.68,0.14,-1.04,0.49,-0.00,2.44,2.79,4.83,3.09,5.61,5.08,4.61,2.94,1.19,2.62,0.97,0.09,0.10,0.42,-1.46,2 --0.08,-0.81,-0.48,-0.50,-1.94,0.04,1.99,-0.40,-0.62,1.04,2.55,2.10,5.10,6.14,6.41,4.86,3.54,1.05,3.14,2.30,-1.22,0 --1.07,0.02,-0.99,2.19,1.97,2.25,4.05,4.26,2.53,2.51,1.49,1.40,2.96,2.34,1.85,1.81,2.46,2.14,0.61,0.99,-0.43,0 --1.32,1.59,0.05,3.17,3.42,3.29,4.27,1.51,2.60,1.43,-0.08,2.73,2.12,2.79,1.88,0.95,1.18,1.27,1.51,-1.84,0.01,0 --1.34,-0.73,-0.75,1.07,-0.72,-0.60,0.02,0.05,1.69,0.57,2.49,2.18,3.23,6.05,5.65,3.84,5.01,0.92,1.35,0.73,0.42,0 -0.36,1.37,3.94,2.58,6.50,3.78,7.40,5.69,1.71,2.22,1.87,1.49,0.29,1.02,-0.54,0.24,-2.05,1.04,1.68,-1.97,-0.12,0 --0.02,-0.67,0.38,1.82,0.99,3.82,2.05,3.72,5.01,3.09,3.86,2.98,1.42,2.87,2.40,-0.39,0.02,1.49,0.28,-3.06,0.22,1 --1.31,0.57,1.29,0.69,-1.83,1.24,-0.48,-1.30,0.34,1.13,4.27,4.36,3.59,6.06,2.67,3.77,2.70,1.84,1.11,1.26,0.32,2 --0.45,0.72,0.07,1.00,3.03,3.76,4.10,4.81,3.67,4.41,1.15,1.47,0.57,1.67,-0.36,-0.77,0.45,0.80,-0.46,-0.47,-0.16,1 -0.28,0.40,1.87,2.81,3.50,6.03,5.37,3.98,2.57,4.74,2.53,0.75,-0.26,-0.42,-0.28,-0.46,0.64,2.19,1.05,-0.24,-0.72,0 --0.31,0.34,-0.16,-0.99,0.35,0.29,0.36,3.13,2.04,3.36,3.84,3.06,3.26,5.34,3.66,3.57,2.09,2.60,1.10,1.44,-0.26,2 --1.14,-0.07,-0.30,1.01,1.14,0.11,1.56,0.57,1.65,4.17,3.33,6.88,3.89,5.26,4.72,3.72,2.42,0.73,2.25,0.94,0.19,2 -0.85,1.47,1.99,3.90,4.22,4.66,6.20,4.72,5.45,2.17,2.41,1.05,0.15,-0.07,-0.14,-0.56,-1.19,-1.52,-0.02,-0.30,-0.61,0 --0.62,-0.75,2.30,1.20,1.06,5.33,5.36,4.38,2.49,5.02,2.24,3.62,0.47,0.44,0.57,1.23,-2.14,-1.00,0.00,1.03,-0.48,1 -0.54,-0.35,0.53,2.68,0.46,2.88,3.76,3.01,2.69,4.28,3.27,1.35,1.13,-0.34,0.91,0.45,0.82,0.52,0.98,1.06,0.28,1 -1.14,1.32,1.69,1.85,2.20,4.16,5.99,2.16,3.46,5.78,2.59,3.53,1.74,1.34,0.85,-2.41,2.10,0.95,0.18,-1.29,-1.21,1 --2.81,-0.43,1.16,1.68,0.21,-0.49,0.46,0.88,1.05,0.64,3.90,4.34,2.14,4.69,3.23,0.77,0.63,2.42,0.70,1.24,0.11,2 -0.45,-1.48,-0.36,-1.93,-0.80,-0.77,0.94,3.93,2.97,4.51,5.68,5.33,3.30,3.32,2.19,-0.13,-0.61,-0.32,1.61,-0.54,-2.83,2 -0.36,1.28,0.42,-0.25,0.14,0.20,0.47,-0.42,0.78,-1.79,1.51,2.31,3.28,6.12,5.75,3.60,3.90,3.35,2.00,0.02,0.44,0 --0.72,1.72,0.42,1.91,3.17,3.64,5.03,2.77,2.70,4.67,4.08,3.85,2.70,2.09,2.65,-0.10,-1.46,-1.21,1.04,-0.18,0.32,1 --0.13,-0.39,0.06,2.01,-1.37,0.03,3.47,3.31,3.19,3.12,3.40,5.95,3.88,5.31,2.80,2.26,1.73,-0.67,1.32,0.68,-0.49,2 -1.78,0.25,0.68,0.91,-0.53,-0.38,1.52,1.57,4.59,5.14,5.21,4.90,3.03,3.37,1.22,3.46,1.22,2.42,-1.31,1.48,-0.52,2 --0.31,-0.10,0.73,-1.02,4.00,1.40,2.76,5.28,4.35,3.63,5.86,4.62,2.72,2.55,2.37,1.79,-1.63,0.40,0.49,-1.62,0.31,1 -0.78,1.61,-0.08,0.93,1.41,2.65,1.51,0.54,0.42,0.93,2.71,2.84,1.91,3.19,4.35,3.24,4.65,1.13,2.40,2.24,-1.51,0 --0.04,2.03,2.39,1.00,3.20,2.95,4.56,3.74,2.93,2.57,1.75,0.31,3.08,1.20,1.42,0.69,1.65,0.80,-0.07,1.56,0.88,0 -0.82,1.51,0.29,-0.11,0.39,-0.81,-0.12,-0.34,-0.40,0.62,2.26,2.91,5.04,3.92,5.16,5.59,3.96,3.84,1.26,2.20,-0.18,2 --0.17,-0.52,0.86,1.92,-0.50,1.27,1.98,2.37,4.77,4.00,7.58,5.29,4.56,2.01,1.73,-0.60,0.51,1.23,1.07,-1.08,0.01,2 -0.38,0.55,0.08,-0.60,-0.68,1.38,0.27,0.61,-0.02,1.95,1.42,3.99,4.44,6.56,2.93,4.24,2.33,2.38,1.53,-0.13,0.95,2 -1.08,-1.31,0.48,0.83,-0.02,0.21,0.25,0.47,1.24,0.25,2.34,2.36,3.02,4.22,6.00,4.79,2.53,3.80,2.51,2.11,-0.32,0 -0.25,2.36,2.60,2.68,3.26,3.73,5.88,5.42,4.59,2.78,1.85,2.51,-0.23,-0.12,-0.39,0.79,1.19,0.95,-2.09,1.54,-0.48,0 -1.47,0.21,0.31,3.30,0.21,2.43,2.97,2.03,3.37,5.37,4.68,4.63,3.16,2.50,2.27,2.29,0.21,0.42,1.76,-0.16,-1.51,1 -1.26,-1.23,-1.88,1.96,0.33,-0.54,0.64,1.07,1.15,1.35,2.40,3.96,4.02,5.87,6.16,4.86,3.64,0.38,0.72,0.99,-1.48,0 --0.63,0.45,0.41,-0.46,0.78,1.77,0.80,2.84,2.61,4.86,5.92,3.43,5.04,1.17,4.26,1.81,2.00,0.36,1.49,-0.42,-0.32,2 --0.59,-0.49,0.46,2.48,4.99,4.16,5.27,3.96,3.50,3.39,3.88,3.86,0.82,-0.03,0.96,1.76,-0.53,-1.11,-0.16,0.72,-0.51,1 -0.33,0.33,-1.50,-1.64,-0.33,2.39,-0.16,3.25,0.55,1.41,4.08,3.89,4.27,3.85,4.03,3.54,3.35,0.85,1.09,-3.25,-1.36,2 -0.77,-0.47,0.12,1.61,1.53,0.45,2.20,0.68,2.34,1.02,1.88,2.70,3.92,1.93,2.26,2.59,3.47,4.50,0.98,0.51,-0.35,0 --0.45,0.26,1.33,2.77,3.47,4.29,5.65,5.28,3.81,3.97,4.01,3.17,1.85,0.69,0.55,-0.39,0.20,0.89,-0.01,2.07,-0.64,1 -0.40,-1.17,-1.51,0.88,-1.66,0.94,0.28,2.01,5.91,5.37,6.41,4.01,3.89,1.24,3.36,2.06,0.81,-1.05,0.85,1.24,0.87,2 --1.29,0.09,-0.44,0.00,0.23,0.88,1.12,3.28,4.25,5.82,4.74,5.84,4.89,3.00,2.26,0.05,-0.81,0.58,-0.14,0.50,-1.01,2 -1.24,0.46,0.29,2.44,2.45,3.21,4.33,4.16,3.45,4.19,3.13,3.92,1.74,2.04,1.80,1.23,-0.77,-0.45,0.49,-0.13,-0.70,1 --0.58,0.64,0.54,2.29,3.35,2.97,4.31,3.89,3.32,5.97,5.31,1.43,1.45,1.14,1.72,-0.88,-0.97,2.02,0.55,0.57,-0.50,1 --0.48,1.03,0.91,1.40,4.80,3.06,4.80,3.54,2.44,2.57,2.50,2.75,2.43,2.63,0.18,1.04,0.75,0.58,-0.61,0.16,-1.44,0 -1.01,1.44,0.33,1.88,3.22,2.73,5.70,2.77,2.47,3.01,2.68,1.02,-0.20,2.87,3.86,2.34,2.23,2.51,0.14,0.72,-0.60,0 -0.43,-0.49,1.14,1.40,2.77,2.76,2.54,3.47,3.17,3.96,4.21,2.58,2.90,2.82,0.49,-1.37,1.44,1.08,-0.21,0.94,0.12,1 -0.77,1.74,1.37,3.30,2.83,5.65,6.22,5.05,2.05,2.08,3.19,1.22,-0.02,1.06,0.66,0.04,-0.74,-0.81,-0.39,-1.24,-1.06,1 --1.18,1.72,0.21,-1.54,1.11,-0.61,0.29,3.15,3.26,4.27,5.59,5.65,1.68,1.52,2.60,1.24,-1.30,1.09,-0.91,-2.04,1.07,1 -0.66,-0.86,0.48,0.29,-1.02,0.64,1.84,1.74,3.85,2.06,5.77,3.96,3.70,3.07,2.84,3.15,0.91,1.38,0.82,0.26,-1.27,2 --0.90,1.58,-0.12,2.17,4.32,5.56,6.41,5.12,3.81,4.18,2.88,2.12,1.12,-0.60,-0.09,1.40,-1.42,0.53,-1.46,-1.01,-1.73,1 --1.68,0.78,-0.21,-1.30,-0.40,1.07,0.55,4.11,4.69,4.96,5.50,6.31,5.10,5.80,2.64,1.96,-1.93,-0.30,1.04,-0.32,0.49,2 --1.48,-1.06,-0.61,-0.77,-0.23,1.95,0.54,4.53,2.88,7.17,4.07,4.49,4.33,3.02,1.01,1.77,-2.60,-1.14,-0.54,0.31,-1.11,2 -0.41,-1.24,-0.68,0.76,3.25,2.70,5.10,2.61,1.89,1.74,-0.26,3.16,2.96,1.34,3.54,1.62,2.13,1.86,0.97,0.53,-0.77,0 -0.78,-0.27,1.71,2.78,4.77,5.00,5.14,5.42,3.90,3.92,3.98,1.97,0.56,0.85,-0.44,-0.38,-0.64,-1.59,-0.35,-1.94,-0.44,1 -1.17,0.30,0.04,2.05,1.62,4.09,2.57,2.40,4.69,6.32,6.24,4.66,3.82,3.03,2.44,0.68,-0.29,-0.29,0.61,1.27,0.14,1 -0.72,-1.19,-1.81,-0.87,-0.58,0.52,1.50,1.76,1.21,3.20,2.97,4.73,3.46,3.00,5.17,1.64,2.57,3.19,0.69,1.41,0.37,2 -0.02,1.01,2.70,1.23,2.24,0.86,3.24,0.86,2.17,2.98,2.59,2.06,1.54,2.67,2.06,1.49,2.35,2.62,-0.20,0.38,-0.79,0 --0.23,0.52,0.81,-0.40,-0.41,-1.17,1.06,0.31,0.58,0.21,2.82,3.07,4.29,5.34,6.19,3.94,2.76,2.33,0.41,0.78,-0.15,2 -0.42,-0.48,0.26,0.18,-1.54,0.35,1.67,1.72,3.59,4.33,4.64,5.19,2.39,3.74,4.75,1.82,1.57,0.53,-0.07,-0.90,0.11,2 --1.04,0.39,1.41,1.33,3.05,3.02,4.17,2.67,0.19,1.71,2.31,3.05,0.77,2.57,3.17,1.84,3.08,4.13,2.05,-1.10,-0.09,0 -0.58,0.24,1.38,0.26,0.56,2.96,3.60,5.74,3.79,5.80,4.72,3.68,2.99,3.51,1.56,0.77,1.25,-0.03,-0.86,0.50,1.64,1 --0.82,0.42,-0.59,0.94,0.58,-0.89,0.05,0.00,0.70,0.06,2.35,1.41,4.68,3.55,5.57,4.96,2.82,3.89,3.38,2.12,-0.98,0 -1.63,-0.13,0.50,1.51,2.87,6.09,3.63,4.76,2.28,4.12,2.92,2.55,0.42,1.16,-0.18,1.11,1.22,0.71,-0.39,1.70,-0.57,1 -0.84,-0.28,1.13,-0.72,0.31,-0.75,0.36,0.18,-1.10,0.58,1.56,1.59,3.78,4.02,7.24,5.32,5.58,2.41,-0.54,1.74,-0.58,0 --0.38,-1.55,1.70,1.70,3.02,3.47,3.69,3.79,3.01,5.25,4.01,1.12,-0.26,0.99,-1.62,1.38,-0.16,0.58,1.43,0.79,1.21,1 --0.54,0.93,-0.45,1.09,1.34,0.09,-0.33,2.57,1.71,3.28,3.15,3.10,2.50,3.97,3.12,3.91,2.90,2.92,-1.14,2.70,-0.01,2 -0.53,-0.48,-0.18,-0.35,0.03,1.53,2.67,2.20,2.84,3.13,6.13,4.04,3.65,2.25,3.02,1.21,-1.01,-0.07,1.78,-1.82,0.46,2 --0.15,-0.47,-0.92,-0.19,-0.65,1.78,-1.09,1.23,-0.12,1.24,2.47,2.88,4.71,4.44,4.63,5.58,2.76,2.99,1.64,0.33,0.45,2 -0.62,1.10,0.47,1.64,1.65,1.11,0.49,0.73,-0.51,0.81,1.47,2.15,2.54,3.29,4.46,4.28,2.78,1.40,1.49,-0.53,0.70,0 --0.84,0.68,0.08,1.26,0.59,2.44,1.96,1.44,-0.80,1.89,2.43,1.81,3.98,3.61,3.80,3.64,2.14,2.78,0.81,0.04,-0.66,0 -0.90,-0.68,-2.37,0.06,-0.99,1.62,2.54,4.04,4.23,3.84,5.06,4.60,5.54,3.70,3.13,0.90,1.02,0.16,0.31,0.94,-1.06,2 -1.31,-0.19,-0.12,0.44,-0.84,-1.04,0.38,1.26,3.26,1.13,3.83,2.46,3.74,3.64,4.60,3.88,4.24,3.72,-0.39,0.15,-1.89,2 -2.52,-0.46,-1.14,1.02,0.34,1.36,-1.65,1.70,1.05,2.02,2.95,4.44,3.46,4.08,4.91,6.57,3.12,0.41,0.93,-2.20,-0.11,2 -1.43,0.51,-0.53,-1.46,-0.34,0.90,1.03,2.83,4.00,4.07,3.99,3.74,2.48,2.94,3.12,0.99,0.24,1.82,-0.31,0.18,-0.60,2 -2.00,-0.56,-0.10,0.12,0.60,0.99,-1.16,1.36,2.02,2.19,2.92,6.95,3.48,4.10,2.33,0.97,2.58,2.71,1.51,2.27,-0.32,2 --0.47,0.41,0.91,0.67,-0.15,2.69,4.20,2.60,0.93,0.99,2.84,2.73,0.35,2.94,3.26,2.51,2.99,1.61,0.54,0.46,-0.28,0 --0.50,0.71,-0.54,0.43,0.43,0.67,2.14,2.96,4.10,2.93,3.15,3.69,4.57,4.73,3.51,2.31,0.34,-0.29,-0.46,-1.46,0.01,2 --1.16,1.26,-1.17,0.99,1.16,-0.00,1.94,1.94,0.36,2.36,2.83,3.19,3.42,4.62,5.45,5.17,5.36,1.43,1.27,0.93,-0.94,2 --0.00,3.32,2.55,2.47,3.61,6.72,6.71,5.43,2.75,4.40,0.90,0.55,-0.21,-0.10,1.54,0.38,0.21,-0.61,-0.05,-0.89,0.23,1 -0.31,2.57,3.70,1.04,4.63,3.92,4.57,4.91,4.96,1.95,2.06,2.88,0.65,1.70,1.04,-0.72,1.27,0.59,-0.05,1.08,1.25,1 --0.90,-1.68,-0.07,-0.81,-1.59,0.88,-0.76,-0.55,1.98,2.21,3.92,4.92,5.42,4.75,6.19,4.76,3.98,1.59,1.03,0.74,1.39,2 --0.42,1.87,2.14,2.79,3.31,5.07,6.96,4.21,3.48,3.93,4.18,-0.05,-0.78,0.96,0.16,0.03,0.95,1.43,2.46,1.34,-0.98,0 --0.94,-0.18,-1.21,-0.46,-1.28,0.11,2.02,2.95,3.03,3.65,4.87,6.30,4.38,3.68,1.39,0.51,0.21,-0.88,0.23,0.17,1.83,2 --0.67,0.98,1.07,3.48,4.63,3.36,6.70,4.75,4.64,1.82,3.12,1.72,1.12,-1.40,0.26,-0.31,-0.82,-0.90,0.09,-0.71,-1.64,1 -0.49,0.28,2.29,-1.40,1.96,1.29,2.49,3.14,3.72,5.39,6.19,5.94,3.09,3.25,3.30,0.95,0.64,-0.52,0.62,-1.06,0.84,2 -0.71,1.68,-0.84,2.60,-1.38,2.50,0.39,2.19,1.57,1.14,1.18,3.90,2.34,5.15,2.10,4.35,2.28,0.48,1.99,0.99,1.08,0 -0.79,-1.56,-1.34,-0.30,-0.21,1.58,1.01,1.77,3.35,1.58,4.70,3.97,4.88,2.76,4.67,4.40,4.41,-0.60,-0.15,1.24,-0.65,2 --1.10,-0.40,1.19,0.32,-0.18,1.68,2.72,3.20,4.29,3.74,3.73,3.92,1.65,1.83,2.01,1.55,0.24,0.68,2.10,1.89,0.21,1 -1.17,-1.14,-1.29,-0.30,-0.66,2.14,1.13,3.33,5.38,3.76,3.05,6.43,3.41,1.02,2.36,1.23,-0.11,0.44,-1.52,1.03,0.14,1 -0.08,-0.08,2.46,3.69,3.84,4.20,5.44,3.95,4.61,2.37,3.29,1.09,0.88,0.13,0.19,0.07,-0.51,0.25,-1.34,0.26,0.16,1 --0.37,-0.14,-0.33,0.35,-1.26,0.89,1.73,2.11,2.69,5.41,4.48,5.53,4.08,2.51,3.34,2.08,0.22,-0.82,0.04,0.17,-0.56,2 -0.67,-0.11,1.43,0.49,0.30,2.33,2.24,1.35,0.38,3.37,2.43,1.19,4.11,3.39,5.28,3.32,2.42,0.54,0.24,-0.52,-1.80,0 --0.34,-0.39,1.21,1.52,2.26,4.00,3.45,3.48,3.25,2.25,2.14,2.96,1.94,1.85,3.18,2.71,0.46,1.57,0.52,1.09,-2.04,0 -2.20,2.51,-0.31,1.17,0.65,3.63,4.69,3.76,3.86,4.63,3.93,3.75,2.60,1.36,2.02,0.91,-1.16,-0.50,0.50,-1.18,2.58,1 -0.49,0.77,3.19,0.55,1.95,4.34,5.24,4.47,1.66,1.99,4.02,2.83,1.83,2.31,2.40,4.12,1.67,0.15,-0.17,-0.59,-0.46,0 --0.16,0.88,2.08,1.90,1.67,3.46,0.97,2.58,2.37,1.18,2.66,2.98,0.71,1.73,4.57,1.10,2.00,0.51,0.77,-0.73,1.07,0 --0.57,0.28,-1.27,1.59,0.26,0.21,-0.73,-0.34,0.95,-0.05,2.59,1.97,2.77,4.85,6.08,6.06,3.78,3.24,3.88,0.08,-0.28,0 -1.02,0.95,0.21,2.38,1.29,1.54,2.17,2.96,2.69,3.71,4.00,3.77,1.57,2.36,0.53,0.03,0.29,-0.65,-0.57,-1.29,1.49,1 --0.34,0.41,-0.24,-0.97,1.02,0.34,0.42,2.38,-0.21,0.48,4.50,4.21,3.69,4.79,3.94,3.74,3.81,3.09,1.60,1.07,2.39,2 -0.58,1.63,1.57,1.32,5.27,5.29,4.69,3.86,3.48,2.37,1.20,2.49,1.45,0.65,2.10,0.19,-0.49,0.46,0.69,1.06,-0.79,1 -0.14,-1.03,-0.11,2.07,1.38,-0.32,2.53,4.59,4.56,4.50,4.17,4.20,5.85,2.37,0.50,-0.57,-1.69,-1.67,1.44,0.49,-0.68,1 -0.99,-0.05,1.49,0.16,0.42,0.05,1.57,1.18,1.82,1.31,1.71,4.02,2.14,4.96,3.03,4.61,4.26,6.20,-0.05,1.35,0.63,0 -0.68,-0.93,-0.10,-0.83,-1.50,2.06,0.09,1.42,1.76,3.38,4.60,3.59,4.36,5.56,3.23,4.42,3.00,1.39,-0.05,0.58,0.78,2 -0.96,0.03,0.60,0.82,3.24,0.97,2.70,1.62,1.70,1.79,2.72,3.32,3.24,3.75,3.89,3.37,3.00,2.29,0.38,-0.58,-0.76,0 -0.74,2.06,3.39,2.21,2.06,3.96,4.70,2.42,2.29,1.65,-0.38,1.38,2.09,1.61,2.47,1.72,0.20,1.20,-0.81,-0.43,0.18,0 -0.48,1.15,1.81,2.93,4.20,3.65,3.21,3.16,2.51,2.88,1.86,2.37,-0.66,1.60,3.02,1.24,0.35,-0.40,0.40,1.89,-0.76,0 --1.41,0.68,-0.83,1.94,1.92,1.62,3.55,3.03,4.13,4.45,3.52,1.93,2.82,-1.26,0.05,2.04,0.23,-1.00,-0.45,0.01,0.71,1 --0.98,-0.51,0.73,-0.01,2.21,2.96,2.80,3.35,6.05,3.44,5.39,6.10,3.17,2.54,1.58,1.30,0.75,0.34,-0.07,-1.28,0.96,1 -0.11,2.74,1.33,3.13,3.04,5.72,6.56,6.11,3.88,2.51,3.38,0.59,0.30,-0.36,2.60,1.15,-0.11,-0.07,0.36,-0.84,-1.58,1 -1.59,0.18,0.10,-0.35,0.19,0.78,2.51,3.07,2.57,1.71,4.70,3.43,4.20,2.54,3.12,2.92,1.41,1.23,1.40,0.52,1.04,2 --0.61,-0.26,1.49,-0.30,-0.38,2.01,1.62,1.71,2.70,3.24,1.57,1.74,3.60,2.47,4.01,2.66,-0.43,2.90,0.60,1.82,0.21,0 -1.07,0.26,0.27,-0.79,2.24,1.63,0.39,-0.71,0.92,1.02,1.39,2.51,3.76,4.28,5.89,5.37,4.91,2.54,1.91,0.00,-1.61,0 -0.45,-0.64,1.77,1.59,3.25,1.86,4.36,2.67,2.29,2.46,-0.08,2.35,2.47,2.51,-0.28,0.37,1.51,0.24,1.78,0.27,0.20,0 -0.42,0.17,0.95,1.99,0.56,0.29,2.31,1.26,3.75,5.12,5.46,2.86,4.70,3.77,1.03,2.52,1.14,0.43,-0.10,-0.06,0.53,2 -0.09,1.21,-0.42,2.72,2.33,0.88,1.50,1.23,0.42,1.08,0.73,2.42,4.51,3.05,1.64,3.01,3.67,3.26,1.82,0.11,-0.32,0 --0.58,0.20,0.18,1.68,0.61,-0.16,0.47,0.69,-0.28,2.00,3.86,2.70,5.10,5.43,5.16,6.29,4.92,3.33,1.91,-0.02,0.85,2 -1.56,1.80,0.10,2.59,4.38,4.16,5.55,5.45,3.19,3.30,2.49,2.09,1.48,1.00,-0.64,1.17,2.35,-0.93,0.05,0.12,-0.94,1 --0.44,0.27,1.04,-0.28,-0.03,1.61,2.30,2.27,0.40,1.03,2.17,2.93,3.34,4.33,4.26,2.85,2.85,2.85,0.95,0.03,-0.81,0 --0.37,0.24,-1.53,1.12,2.49,0.97,0.33,1.97,2.73,3.09,3.73,6.15,2.97,3.13,2.21,2.03,1.86,0.89,2.01,-1.57,0.33,2 -0.15,1.69,2.68,3.19,4.62,3.38,3.42,4.04,1.88,2.14,0.87,1.48,0.90,0.43,-0.67,-0.14,1.23,2.03,-0.10,0.96,-1.99,0 -1.64,0.37,-0.21,1.23,1.69,0.24,2.25,0.10,0.83,3.29,3.27,3.36,3.17,6.46,4.91,5.08,2.78,1.19,1.09,-1.11,-0.41,2 --1.42,0.59,-0.83,1.26,1.33,0.75,2.27,1.87,3.53,1.81,3.94,4.36,2.95,3.19,3.58,2.78,2.27,0.09,1.74,2.66,-1.19,2 -1.76,-0.77,0.67,-0.02,1.20,0.25,2.02,0.94,4.10,1.33,3.71,3.47,5.05,4.49,4.37,3.73,1.95,1.93,0.16,0.69,0.40,2 -1.52,1.45,-0.29,3.76,3.56,4.80,3.83,4.54,3.07,2.90,1.95,0.74,1.62,1.78,1.80,-0.07,1.69,0.14,-1.18,-1.49,-0.40,1 -0.70,-0.64,0.21,0.90,-0.36,-0.48,2.53,-0.01,2.87,0.44,5.15,3.95,4.61,4.20,2.01,1.89,2.01,2.19,2.64,1.19,-1.81,2 -0.27,-0.09,1.03,2.27,0.35,2.03,2.79,3.51,4.43,4.94,6.22,5.53,4.77,4.17,0.65,0.92,-1.94,-0.94,1.66,0.89,0.37,1 -1.17,1.92,2.42,0.90,2.78,0.23,2.66,1.69,2.09,1.72,2.89,1.05,2.19,3.40,4.04,3.58,4.82,2.27,1.62,0.70,0.49,0 --1.11,1.40,1.18,1.48,2.18,1.56,2.73,3.71,1.14,1.89,1.94,0.47,-0.15,4.38,2.18,1.71,2.45,1.55,2.15,1.01,1.85,0 -0.62,1.32,0.95,1.08,3.82,0.55,0.87,2.77,1.07,1.28,0.42,1.38,1.42,3.85,3.12,1.32,2.49,1.56,1.67,0.04,-0.81,0 -0.85,0.73,-1.01,0.22,2.54,1.78,1.03,2.18,1.86,4.53,4.06,2.64,3.83,4.13,2.12,0.76,0.41,1.01,1.33,1.16,-0.61,2 -0.38,0.75,-0.37,-0.10,0.57,0.50,2.44,2.22,4.63,2.26,4.33,3.98,6.00,6.41,4.06,2.31,1.90,0.30,0.96,0.38,-0.53,2 --0.05,0.14,1.94,3.23,3.16,2.27,4.97,4.49,4.57,4.09,2.98,1.04,-0.61,0.58,1.46,0.70,0.63,0.35,-1.12,-1.11,-2.00,1 --0.23,1.89,0.40,1.77,2.09,5.07,6.47,2.89,2.70,2.08,2.65,1.67,2.91,1.62,1.84,1.46,1.32,-0.14,0.47,-2.01,-0.88,0 -0.07,1.38,-0.35,1.60,2.06,2.53,1.76,2.98,2.80,2.42,1.80,2.25,3.77,1.52,4.27,3.75,4.05,3.34,2.10,0.85,-0.79,0 --0.51,1.95,0.39,1.03,2.71,4.95,4.83,5.54,5.99,6.01,2.07,3.23,-0.28,0.48,-0.03,1.28,0.13,-0.76,-0.21,1.39,-1.17,1 -1.78,2.00,-0.01,1.08,2.20,3.19,3.22,3.36,1.67,2.38,1.91,1.99,1.99,-0.22,1.16,0.97,1.93,-0.23,1.22,-0.04,-1.33,0 -0.65,-1.44,0.37,0.14,0.09,0.59,0.93,2.94,1.61,1.79,3.75,5.76,4.55,4.22,4.38,2.69,2.19,0.40,1.74,1.07,0.91,2 -0.05,1.26,1.15,3.12,3.17,3.74,3.00,7.84,3.33,3.93,4.03,2.48,-0.58,0.38,0.96,0.62,0.52,0.47,1.83,1.26,1.63,1 -0.58,0.59,2.24,2.00,4.39,3.36,4.63,3.86,4.92,2.18,3.51,0.90,-0.47,0.19,-1.23,-0.72,1.37,0.56,-1.48,0.40,0.17,1 -2.18,0.89,-0.72,2.11,1.96,0.09,-0.64,-1.10,1.10,2.70,2.31,2.94,4.26,4.45,5.09,4.28,3.85,3.22,2.09,1.62,-1.07,0 -0.14,0.77,1.83,0.31,1.25,2.08,1.84,-0.33,1.45,0.85,3.94,1.52,4.16,4.19,2.38,2.53,4.85,1.17,1.43,2.21,0.27,0 -1.40,0.30,-0.37,0.49,2.04,1.16,2.61,0.92,3.29,0.54,3.09,4.00,2.82,3.61,6.35,3.49,4.48,1.82,-1.50,-1.27,0.92,0 --0.29,-0.79,-1.03,0.18,-0.94,1.28,2.75,2.90,2.75,4.26,4.23,4.40,4.67,2.57,1.17,2.11,-0.40,-1.72,0.60,0.88,0.13,2 --2.24,0.55,1.11,3.84,0.46,4.55,5.89,4.96,1.88,5.04,3.44,3.41,0.43,-0.28,2.43,-1.35,0.10,0.49,-0.83,0.63,0.15,1 -0.19,-1.68,0.78,1.11,2.04,1.23,2.04,2.78,-0.30,1.63,2.19,3.73,2.53,4.32,4.26,2.97,2.00,-0.16,1.51,-0.13,0.93,0 --0.41,0.77,2.59,1.74,3.57,3.39,5.17,3.76,3.85,2.60,2.66,1.93,-0.16,-1.09,1.31,0.54,-0.07,0.47,1.10,0.16,-0.78,0 -0.71,0.58,2.03,0.48,1.89,4.70,2.66,1.97,1.98,1.55,0.95,1.82,1.58,2.13,2.44,4.98,0.51,1.74,2.14,0.51,1.16,0 -0.94,-0.43,1.65,-0.22,-0.48,0.66,0.60,2.49,3.22,4.26,3.77,4.89,3.45,2.82,1.99,2.06,2.04,1.31,0.27,1.59,0.07,2 -1.01,1.44,2.43,0.30,1.89,2.40,1.40,2.69,1.44,2.93,0.83,3.71,2.32,5.09,4.92,3.39,3.02,2.76,0.33,1.57,0.96,0 -2.48,0.49,-0.19,-0.56,-0.25,-1.18,-0.27,1.34,0.11,1.68,2.88,3.20,5.76,6.06,5.66,4.66,3.23,2.40,2.00,-0.15,-0.86,0 -0.63,-0.31,2.53,3.05,1.52,3.85,3.43,1.87,1.98,2.10,1.30,2.31,1.17,1.93,3.32,-0.18,0.50,0.76,1.84,1.19,-0.38,0 -0.30,1.69,0.20,0.18,0.36,-0.56,1.27,1.44,2.17,0.91,2.56,4.54,5.66,4.24,3.84,4.02,2.70,1.31,1.99,1.08,-0.11,2 -1.23,0.72,-2.04,0.99,1.18,0.31,2.03,2.76,3.38,6.31,5.62,2.73,5.77,3.92,2.56,-0.29,-0.03,1.30,-0.16,1.10,-0.02,2 -0.87,0.45,0.24,0.97,0.15,0.17,1.44,0.02,0.98,0.96,3.78,2.16,4.42,3.54,4.85,1.72,2.52,2.36,-0.24,2.73,-1.15,2 --0.40,0.42,0.08,-1.14,-0.14,0.12,-0.02,1.87,0.49,1.52,2.99,4.00,3.89,4.65,5.29,4.74,2.43,3.07,2.91,0.60,-0.75,2 -0.36,0.51,1.92,0.95,3.39,3.70,5.07,4.50,3.35,3.41,2.02,1.97,1.93,0.60,1.16,1.48,0.68,1.64,-0.23,0.08,0.46,0 -0.01,0.54,1.35,1.90,1.37,2.34,4.00,4.71,4.98,2.46,4.37,1.63,1.71,2.38,-0.21,0.75,-0.49,-0.01,-0.05,1.10,-1.83,1 --1.86,1.30,0.18,0.74,1.63,0.81,2.19,1.28,1.44,0.98,1.94,1.00,2.44,4.51,2.38,3.57,2.51,1.70,-0.35,-0.41,-0.62,0 --0.56,1.21,1.24,1.04,2.43,0.92,2.24,3.88,1.39,1.82,0.06,2.00,1.32,2.91,1.86,2.65,0.63,0.57,1.53,0.12,-1.65,0 -0.32,-0.71,0.75,0.54,1.30,-0.17,-0.04,0.22,-0.04,2.56,1.98,3.63,4.73,4.88,5.70,5.02,1.95,2.62,1.77,0.05,-1.11,2 --0.19,0.33,-0.23,1.42,-0.88,1.98,-0.00,1.88,0.51,1.86,-0.05,3.18,4.20,4.35,7.73,6.37,2.97,2.41,0.24,1.85,-0.90,0 --0.62,2.21,2.10,1.36,4.20,5.95,5.88,5.27,4.15,5.66,4.11,0.50,1.50,0.22,0.37,0.80,0.94,-1.31,0.76,0.56,0.68,1 --0.25,0.91,-0.64,0.93,-2.13,0.19,1.87,2.22,3.84,4.96,7.00,4.87,3.19,2.18,2.94,0.07,-0.61,-0.11,-0.04,-1.27,0.10,2 -0.47,-1.57,-0.50,0.41,0.87,-0.35,1.90,1.89,-0.63,2.54,2.74,3.20,4.73,5.70,3.74,4.14,3.43,3.73,3.39,0.44,-0.57,2 -0.97,3.05,1.68,3.03,2.06,4.52,4.46,1.62,1.96,3.42,1.80,2.04,1.92,1.94,2.56,2.37,1.91,-0.45,-1.11,1.90,1.44,0 --0.15,-0.19,3.05,3.17,3.02,5.72,5.51,3.36,4.32,2.87,2.45,2.03,-0.16,-1.23,0.53,1.82,-0.01,0.99,-0.10,0.48,1.55,0 -0.27,0.99,-0.43,-0.48,-0.31,0.67,1.43,2.23,3.23,4.83,3.33,4.47,4.69,2.00,1.85,1.48,1.08,1.33,0.56,-0.08,0.19,2 -1.44,-0.44,-0.05,0.24,-0.90,1.20,0.67,0.16,1.09,1.75,2.91,3.44,4.42,5.77,5.72,3.72,2.45,0.40,2.10,1.72,1.44,2 -1.54,1.97,0.81,3.05,3.55,1.70,2.09,6.13,3.09,4.78,3.30,3.67,1.83,1.48,2.31,0.76,0.24,-0.06,0.25,0.45,0.59,1 -0.28,-0.16,1.42,1.35,2.14,3.70,4.56,3.75,3.43,3.39,3.98,2.14,-0.33,-0.97,1.26,2.60,-0.07,1.31,0.42,-2.29,0.37,0 --0.02,1.76,1.56,2.00,2.74,1.75,6.77,5.10,4.02,4.19,2.90,3.38,1.56,0.74,-0.04,0.01,-2.13,-0.16,-0.07,0.16,1.07,1 -0.04,1.92,0.97,3.44,3.75,3.53,7.18,6.20,4.96,2.65,1.87,1.73,1.32,0.43,0.02,-1.32,-0.12,0.54,0.49,-1.14,-1.02,1 -0.14,-0.41,1.85,3.83,5.36,6.21,5.03,6.59,4.33,1.78,3.18,0.48,0.78,-0.99,0.24,-0.34,-2.07,1.26,-1.23,0.21,0.14,1 --0.91,0.41,1.04,1.20,1.79,3.32,3.37,3.18,2.27,3.81,3.29,2.47,2.39,0.99,1.31,0.19,0.76,-1.42,-0.34,-1.13,-0.96,1 --1.34,2.16,-0.75,0.75,-0.17,1.33,1.70,2.47,0.71,1.86,2.92,3.20,3.96,6.50,6.12,4.58,2.55,2.79,2.17,2.34,-0.24,2 --0.37,0.95,2.37,1.35,3.70,3.65,3.08,4.03,3.20,3.70,0.40,1.26,1.48,1.01,2.59,0.95,1.34,1.50,0.28,-0.24,-0.75,0 -2.15,2.18,0.61,-0.01,3.51,2.58,2.86,2.32,4.14,2.13,3.55,1.10,2.31,3.94,2.38,1.33,1.70,2.67,-0.24,0.17,0.28,0 --0.28,1.77,-0.68,0.02,1.65,0.44,3.26,2.88,4.60,5.26,5.60,3.03,3.33,1.85,-0.18,2.21,0.49,1.57,0.06,0.47,0.30,1 -1.55,-0.15,1.75,2.38,2.35,3.04,2.68,3.61,1.55,2.59,2.32,1.02,2.16,2.80,2.70,3.50,2.30,1.46,2.12,2.21,-0.24,0 --1.11,0.52,0.37,0.57,3.62,1.69,2.79,3.12,2.27,5.78,3.43,3.01,2.54,2.16,1.46,-0.26,-0.05,1.27,0.53,-0.24,-0.10,1 --1.73,0.94,0.61,0.60,1.82,2.98,4.87,4.43,4.60,3.42,1.57,2.22,1.93,1.24,0.86,0.13,0.78,-1.01,0.65,0.16,1.93,1 -0.24,1.32,1.01,2.15,2.79,3.82,4.59,4.35,4.77,2.70,4.60,2.82,1.47,2.66,-0.54,-1.08,-0.15,-0.55,1.21,0.59,-0.03,1 --1.65,0.04,-1.30,-0.19,-0.29,0.22,0.16,1.83,1.12,4.28,3.44,4.08,3.10,3.17,2.05,3.46,0.07,-1.67,0.25,0.36,0.18,2 -2.01,-1.71,0.97,0.26,1.03,1.09,2.44,0.42,3.04,3.18,4.07,3.87,6.16,2.53,3.41,2.27,2.34,2.53,0.57,-1.79,1.91,2 -0.24,-0.17,0.58,1.96,3.10,5.85,2.83,3.53,2.93,4.99,4.06,2.40,1.81,2.73,2.09,1.37,-0.09,-0.07,1.06,-0.65,-1.06,1 --0.44,-0.05,-0.66,2.10,1.54,3.30,4.36,6.11,3.93,2.42,5.26,4.31,3.80,3.65,0.38,1.39,-1.82,1.78,1.11,0.33,1.71,1 -1.00,1.27,0.85,0.00,1.18,1.49,3.84,3.88,3.51,3.25,6.86,6.58,4.24,2.02,2.55,1.35,-1.83,-0.05,-0.54,-0.79,0.14,1 --0.27,-2.11,0.43,1.38,1.43,0.08,1.75,-0.22,-0.21,0.80,2.36,2.20,3.13,4.34,4.15,5.08,3.43,3.15,0.46,-0.31,-0.22,0 --0.18,-0.46,1.14,-1.79,0.20,1.13,1.32,1.90,2.90,3.82,4.87,2.78,4.30,4.32,2.37,2.18,-1.45,1.71,0.30,0.60,0.75,2 -0.17,2.30,2.06,3.43,2.79,3.88,7.08,3.28,5.19,0.67,0.99,0.31,0.89,0.36,-0.93,-0.63,2.22,-0.97,-0.19,-0.02,1.17,0 -0.40,1.95,-0.82,0.47,0.02,-0.27,-0.40,-0.18,0.51,0.18,1.23,2.28,3.06,6.23,7.62,5.10,3.22,2.05,3.67,0.20,0.12,0 -0.60,-0.30,0.92,0.73,-1.31,1.01,0.56,2.24,2.80,4.24,4.40,3.65,4.23,3.47,2.80,2.27,0.60,0.49,1.84,0.32,-0.08,2 -0.88,-0.58,4.72,0.62,2.27,4.34,5.98,3.51,3.94,4.33,1.59,0.42,2.09,1.61,1.18,2.52,0.23,0.66,0.89,0.73,-0.29,0 --0.90,-1.19,-0.36,0.23,0.34,0.36,-0.28,1.80,2.21,2.74,3.24,5.89,3.37,6.09,2.89,1.56,3.33,2.07,1.07,-0.07,1.67,2 -1.72,-1.31,0.10,1.31,1.47,1.35,2.16,0.11,2.38,0.58,1.61,3.14,1.52,4.55,4.70,3.31,3.00,2.26,0.53,0.41,0.36,0 -1.13,-0.26,1.00,0.80,0.42,0.90,1.32,0.08,1.36,1.11,4.20,5.08,4.40,2.33,4.77,5.61,3.41,2.35,2.90,0.11,-0.57,2 -0.21,0.71,1.12,3.30,2.83,5.60,5.25,3.45,3.64,3.45,0.69,-1.05,1.75,0.93,-0.89,-0.72,-0.30,0.52,-1.29,1.36,0.04,0 --1.33,1.04,1.42,-0.66,0.62,2.51,4.41,2.20,5.02,6.09,3.58,5.33,3.96,0.74,1.77,1.57,0.89,-0.26,1.54,2.54,2.87,1 -0.72,1.93,0.93,1.05,0.88,0.83,1.18,2.13,-0.84,2.26,2.46,0.94,4.45,4.68,3.67,3.19,4.64,4.78,0.88,0.75,-1.99,0 --0.16,-1.19,0.68,2.36,2.41,2.46,1.89,1.34,2.68,3.31,2.77,3.53,3.47,4.25,2.03,2.51,2.95,1.67,0.12,0.17,0.27,0 --1.21,1.26,0.99,0.61,1.16,-0.08,-0.27,1.00,1.67,2.13,3.50,3.52,2.93,3.52,5.34,3.54,1.62,1.42,2.62,1.39,-1.90,2 -2.23,-0.28,-0.51,-0.46,0.88,1.36,1.36,3.12,3.09,4.13,5.14,4.15,4.34,5.47,2.93,2.58,1.99,1.96,1.31,1.03,1.04,2 --0.07,1.93,-0.13,0.23,-0.35,1.50,2.56,4.58,3.19,6.40,6.76,5.21,2.61,2.22,1.51,1.47,0.72,-0.39,-0.42,-0.80,0.42,1 --1.40,2.03,0.60,2.86,3.01,4.82,5.09,4.89,1.82,3.24,1.30,2.67,0.51,-0.67,0.92,-0.86,-0.83,-0.10,-1.82,-0.35,0.84,1 -1.99,-1.44,0.00,-3.05,-0.07,-0.45,2.42,1.03,1.76,2.03,4.14,6.39,3.44,2.51,2.84,4.29,1.21,1.40,-0.16,-0.56,-2.06,2 --0.80,1.30,0.42,1.58,1.29,5.25,4.24,3.30,4.76,3.03,1.58,0.15,1.01,-0.59,1.42,1.05,3.19,1.28,0.05,-0.04,0.90,0 -0.28,-0.41,-1.05,-1.90,1.26,-0.13,0.66,-0.67,0.45,2.42,3.06,1.39,5.17,4.53,5.75,2.03,3.94,1.45,2.77,1.05,0.04,2 --0.66,-1.48,0.99,1.75,2.39,3.85,2.12,4.15,5.13,3.67,4.50,3.01,4.73,-0.34,0.67,-0.55,0.32,0.76,0.39,0.15,-0.09,1 -0.53,-0.41,-0.11,1.44,0.81,2.10,1.52,4.37,0.49,2.22,0.60,3.48,2.40,4.30,4.05,3.31,2.19,3.89,2.52,2.58,-1.19,0 -0.46,-0.30,1.35,0.73,-0.34,-0.52,0.40,1.78,3.74,3.39,3.42,2.83,4.06,4.95,5.18,1.82,0.44,1.99,0.55,-0.48,-1.00,2 -0.34,1.18,1.05,1.60,0.28,-0.36,0.27,-0.11,2.19,1.24,1.38,4.85,4.66,3.44,4.72,2.55,1.87,2.12,1.71,-0.23,1.08,2 --1.60,0.79,-0.81,-0.45,-0.79,2.78,1.33,3.17,3.36,5.05,3.77,3.95,5.28,4.57,4.10,3.03,1.90,1.38,-0.18,-1.07,1.48,2 --0.26,1.96,0.82,1.54,-0.54,1.60,2.16,4.59,5.59,5.29,3.23,5.31,4.32,2.54,1.77,1.58,-1.30,-0.16,-0.11,-1.53,0.06,1 --0.45,-0.05,1.40,0.40,0.46,-0.60,1.80,0.67,1.62,4.88,6.51,2.99,4.49,3.54,1.60,1.19,-0.62,0.85,1.82,0.59,0.27,2 --0.30,1.15,0.85,0.61,-0.34,0.06,0.97,2.14,2.20,5.81,2.64,5.08,2.67,3.50,3.28,2.39,1.05,-1.46,-0.65,0.95,1.28,2 --0.24,0.51,0.00,0.93,1.10,3.39,4.06,3.60,4.16,4.40,6.21,4.43,2.45,1.30,1.83,0.60,0.58,1.18,-1.00,-1.33,-0.66,1 -0.44,-0.11,0.76,0.58,1.21,3.20,6.05,4.11,4.70,3.29,1.72,2.85,1.42,1.00,-1.00,0.13,0.37,-1.44,1.83,-0.61,0.41,1 --1.32,3.21,1.53,3.51,1.67,4.54,4.15,3.83,2.40,1.22,0.11,-0.65,2.03,-0.23,0.12,0.46,-0.32,1.24,-0.75,0.73,-0.46,0 --0.67,-1.36,0.51,1.78,1.54,0.57,2.82,1.51,6.05,3.90,5.36,3.46,2.15,3.03,2.37,1.11,-0.74,0.65,-0.75,0.76,-1.02,1 --0.49,1.91,2.01,4.33,4.40,4.68,5.54,5.54,4.40,2.44,1.76,1.68,1.98,1.33,-1.50,-0.10,0.16,-0.59,1.38,0.32,-1.81,1 -0.18,-0.52,-1.28,0.92,0.41,2.87,2.52,3.93,3.98,3.12,2.21,3.27,5.35,2.20,1.08,-0.23,-2.31,-1.22,-0.11,-0.13,0.62,1 -1.08,0.71,-0.29,2.30,1.81,3.35,3.19,2.64,4.46,5.34,2.85,3.46,3.28,1.39,1.54,1.58,1.53,-0.56,-0.22,-0.29,-0.46,1 -0.49,-0.74,1.35,0.73,1.72,1.78,1.71,1.37,1.31,1.00,2.59,0.30,3.90,3.97,3.60,5.32,3.11,3.39,2.27,-0.43,0.82,0 --0.38,2.10,-1.44,-0.31,0.88,0.01,0.58,3.01,1.93,6.18,3.41,5.09,3.35,3.21,2.33,2.02,1.38,1.43,1.63,-0.34,0.46,2 --1.63,1.82,1.04,-0.94,-2.14,-2.06,0.63,0.93,0.94,-0.32,1.96,2.60,4.01,1.94,4.91,4.71,2.88,2.73,1.49,1.58,-1.26,2 --0.43,-0.60,-1.05,0.42,-0.24,3.01,2.42,3.96,3.53,4.47,6.03,5.23,3.78,2.31,2.18,2.41,-1.12,-0.22,-0.47,-0.03,0.82,1 --1.23,1.62,2.93,1.36,2.31,2.22,3.38,5.37,3.07,2.37,1.29,1.37,1.66,0.79,0.54,1.44,3.29,1.08,0.69,0.16,-0.05,0 --0.86,-0.31,2.49,2.92,3.81,5.27,5.37,6.23,2.01,5.24,2.97,0.59,1.20,0.77,1.04,1.45,-0.62,-0.04,-1.77,-2.45,-0.27,0 -0.33,1.05,1.03,-1.16,-2.53,0.25,0.56,1.71,2.20,2.11,4.35,3.02,4.11,5.45,3.54,2.93,1.70,2.98,0.64,2.28,0.67,2 --0.40,1.25,1.64,0.17,4.09,4.98,1.99,4.17,3.48,4.96,4.76,1.47,1.89,0.57,1.01,0.58,2.17,-2.22,0.04,1.08,-0.45,1 -1.04,0.99,0.78,0.39,-0.05,0.59,0.58,0.57,-0.01,1.37,3.05,3.03,2.63,5.95,5.76,3.32,3.85,2.78,3.48,-0.13,0.90,2 --0.50,1.47,1.58,1.21,3.86,4.26,5.67,5.19,3.22,2.40,2.03,2.88,-0.09,0.88,-0.46,-0.77,-0.41,-1.06,-0.87,1.05,0.31,1 -0.62,0.88,-0.73,-0.66,-0.57,0.85,0.71,1.63,1.62,4.80,3.54,3.67,3.92,3.66,2.81,3.33,2.98,0.61,-0.91,0.44,0.54,2 -0.06,0.25,1.58,0.00,1.12,-0.36,2.14,0.10,0.70,2.99,2.42,3.30,3.73,5.65,5.23,2.60,2.48,3.17,1.43,-0.29,-0.11,2 --0.85,-1.09,0.83,-0.79,2.69,1.95,2.66,3.95,6.15,5.48,7.60,3.29,4.30,0.95,1.32,0.66,-0.03,0.15,0.47,-0.16,2.35,1 -0.24,-1.05,1.95,3.08,4.33,3.29,4.55,4.10,4.34,3.59,4.20,1.81,1.79,2.41,0.34,-0.42,-0.26,0.15,-0.30,-1.15,-1.28,1 --0.07,-0.03,-0.10,-0.41,-0.98,1.70,1.14,2.40,0.48,2.58,1.76,3.49,4.04,3.48,5.48,3.01,2.88,2.09,-0.78,-0.13,0.98,2 -0.97,2.23,1.33,-0.86,0.69,-1.34,3.86,-0.01,1.02,0.61,2.94,1.67,2.22,2.69,3.31,3.23,4.02,2.96,1.22,0.70,0.10,0 --1.12,0.37,0.68,-2.31,-1.23,-0.35,-0.69,2.54,1.74,3.53,1.91,5.86,3.34,3.52,3.39,4.13,2.29,1.67,0.93,0.47,0.60,2 --0.95,-1.27,-0.85,0.44,-0.35,-0.74,1.69,0.48,2.19,1.49,3.05,3.45,5.02,6.11,4.88,4.88,3.37,2.01,1.62,0.02,-0.58,2 --0.68,0.75,0.10,1.57,-0.25,0.52,1.84,2.25,3.60,7.36,5.50,5.79,3.95,1.32,2.59,1.23,0.53,-0.50,-0.37,1.22,0.63,1 -1.36,-0.46,-0.99,1.09,0.90,1.85,2.93,3.00,3.42,4.71,4.13,4.21,2.25,2.79,-0.47,-0.64,-0.37,0.65,0.38,1.45,-0.17,1 -1.13,-0.68,-1.94,-1.15,1.70,1.25,0.28,0.28,0.28,1.85,2.02,5.21,4.26,3.83,6.97,3.81,1.73,3.52,0.86,0.94,-1.21,2 --1.89,0.10,0.91,3.03,4.14,3.46,5.46,4.74,3.79,2.67,4.23,1.22,-0.73,-0.46,1.22,-1.31,2.50,-2.07,-1.62,0.94,-0.37,1 -2.82,0.77,1.96,2.67,2.79,4.23,6.40,5.11,4.79,1.95,1.43,0.94,-0.09,1.63,0.77,1.76,-0.55,-0.09,-0.25,-1.06,-1.17,1 -0.57,-1.42,-0.47,-0.91,-0.68,0.67,-0.08,1.22,1.73,3.62,5.09,3.11,4.12,4.08,2.98,2.73,3.08,-0.70,0.70,1.69,1.32,2 -0.82,-0.76,2.06,0.83,1.09,1.68,3.63,3.94,3.55,4.59,5.79,3.82,3.79,2.41,-0.50,0.53,-1.03,-0.28,0.02,1.54,-0.19,1 -0.72,-0.04,0.66,-0.07,0.57,1.60,-0.45,-0.61,0.77,0.90,1.81,3.20,4.61,4.03,5.08,5.30,2.65,3.04,2.85,0.08,0.21,0 --0.14,-0.04,1.37,3.77,0.32,2.68,4.60,2.88,4.91,3.12,2.87,1.89,-0.40,0.38,-1.33,0.77,0.62,-1.03,-0.13,-1.86,0.26,1 --0.27,1.91,2.46,1.61,3.41,2.46,3.90,5.28,4.55,3.79,1.54,-0.38,0.29,-1.38,0.06,1.80,1.73,-0.18,-0.27,0.91,-0.57,1 -1.05,0.27,0.64,-0.04,1.06,0.93,-0.64,-0.16,0.84,1.33,3.39,3.93,4.16,3.58,6.60,2.85,6.48,3.20,2.72,2.08,0.03,0 --1.22,1.52,-0.01,0.47,2.98,2.44,3.55,2.55,5.29,3.53,4.99,3.58,1.11,2.01,1.11,-0.06,-0.27,0.37,1.45,0.73,-1.23,1 --0.84,-0.24,0.05,1.03,0.13,-0.75,0.98,0.73,0.81,1.39,1.61,3.70,3.85,4.10,5.14,3.19,4.32,1.82,3.20,-0.43,-1.23,0 -1.34,0.30,1.85,2.94,4.29,4.43,3.18,5.07,3.10,3.24,3.22,0.57,1.09,0.02,1.60,0.92,0.70,-1.15,0.80,0.63,-0.55,1 --1.60,0.38,2.45,2.55,3.31,4.85,5.38,1.38,0.84,2.57,2.16,2.36,1.14,2.70,1.22,1.85,2.17,-0.01,0.69,0.23,1.09,0 -0.02,2.42,0.54,-1.00,-0.70,-0.14,2.18,0.72,3.22,2.06,4.99,2.21,2.94,4.55,3.36,3.13,0.56,1.67,0.43,-0.92,-1.56,2 --1.85,-0.24,1.73,2.33,3.03,3.88,5.69,5.34,4.80,2.36,2.12,1.88,2.19,-0.67,0.21,0.46,-0.20,-0.84,0.95,-1.14,0.99,1 --0.37,-1.05,0.05,-0.33,1.77,-0.49,1.30,-0.21,0.77,0.48,2.03,2.11,4.35,5.53,4.66,4.93,4.01,4.46,2.12,0.22,0.12,2 --1.17,1.17,2.63,3.37,2.25,5.93,8.76,4.35,5.17,2.87,2.07,1.11,0.94,-2.37,-0.65,-0.30,-2.17,-1.21,-0.82,-1.47,1.39,1 --0.28,0.65,0.75,0.31,0.96,0.89,2.78,1.94,3.86,5.09,4.91,4.07,4.12,1.67,3.76,1.84,3.74,2.73,1.05,-0.52,-1.41,2 --0.96,1.15,0.22,-0.86,1.19,2.10,3.33,0.61,0.60,3.72,3.15,2.68,5.27,5.39,4.11,3.68,2.32,2.24,0.66,1.22,-1.19,2 --0.24,0.34,0.30,2.75,1.47,3.92,5.68,3.86,3.73,4.15,3.25,2.10,3.47,3.65,1.77,-0.20,-1.18,-0.27,-0.27,0.70,0.55,1 -1.32,1.01,2.40,0.69,1.99,2.49,2.38,3.55,3.18,1.73,1.29,2.07,1.22,-0.13,2.21,2.41,4.23,2.70,2.02,1.01,0.76,0 --0.12,0.16,0.77,3.21,3.82,4.29,3.74,4.26,2.50,2.44,2.29,1.55,-0.59,-0.37,0.66,1.28,0.10,-0.54,-0.17,-1.87,-1.71,0 -2.33,1.05,-0.47,1.45,-0.35,1.69,1.20,-0.13,1.91,1.53,2.19,4.30,3.90,3.73,5.79,3.66,3.28,3.01,3.66,1.23,1.50,0 -1.52,-1.62,2.50,1.23,-0.25,3.27,2.87,0.01,0.03,1.30,1.43,1.81,2.85,2.54,3.16,3.70,2.15,2.19,2.66,0.00,0.48,0 -0.44,0.67,3.62,3.16,1.32,1.99,2.73,1.36,1.88,3.29,1.48,1.57,3.28,1.92,1.05,1.75,4.75,0.71,1.55,1.81,0.87,0 -0.18,-0.81,2.51,-0.58,-1.05,1.82,3.76,3.59,4.34,3.34,6.65,5.66,4.30,4.07,1.59,1.98,-1.01,-0.53,0.85,0.11,-0.93,2 -1.39,2.50,1.69,2.67,2.28,4.09,2.59,4.89,2.01,6.32,4.50,3.12,0.96,1.32,1.26,0.63,0.41,-1.22,-0.79,1.06,0.16,1 --0.81,-0.13,-0.99,2.20,0.11,0.12,0.24,1.11,1.15,2.35,3.40,5.65,2.87,4.08,3.07,4.49,1.71,1.75,0.91,0.45,1.65,2 -0.91,0.99,0.28,0.63,-1.34,1.30,2.41,2.16,3.98,3.78,5.12,4.62,3.75,3.86,2.90,2.14,-1.67,-1.43,-0.52,0.01,-0.39,2 -0.41,-0.26,0.15,-1.27,0.01,-1.12,0.97,3.62,1.52,2.40,5.26,4.49,3.54,3.48,4.25,3.06,0.99,0.26,0.19,1.76,-0.62,2 -1.14,-0.04,-0.89,0.27,-0.86,0.97,-0.31,1.08,1.74,0.70,4.43,3.95,4.87,4.07,5.52,1.41,2.30,2.52,2.72,0.07,-1.41,2 -0.38,0.59,1.10,0.11,-0.56,0.76,0.46,1.29,2.96,4.55,6.59,3.97,3.93,3.18,2.93,1.00,0.64,2.44,0.39,0.59,-0.30,2 --1.02,-0.36,0.15,1.34,0.05,0.58,1.68,3.63,2.71,3.67,7.17,4.16,4.05,3.20,1.81,2.14,0.02,-0.54,-0.22,-0.02,-3.46,2 --1.33,1.02,0.16,1.34,2.39,1.75,5.03,4.75,2.81,4.70,3.57,4.99,1.04,2.15,-1.45,-0.29,0.26,1.94,1.01,-1.99,-0.65,1 --1.08,0.97,1.57,0.65,3.14,2.39,4.60,0.93,-0.12,0.23,1.22,2.41,1.72,2.09,4.65,1.64,1.46,3.34,1.34,-0.23,-1.13,0 -0.37,-0.71,-2.12,-1.25,0.82,3.37,0.63,-0.75,-0.72,0.20,0.45,3.45,2.38,4.63,4.90,3.54,4.07,2.36,0.59,0.87,0.22,0 --0.50,0.79,-1.39,0.19,-0.40,1.15,2.01,2.37,5.03,3.72,2.92,2.28,4.66,3.76,2.37,2.57,1.52,1.46,1.45,-0.02,0.53,2 --3.00,0.14,-0.46,0.47,1.75,2.27,1.00,0.44,0.03,1.55,2.55,2.99,3.23,3.66,3.42,1.90,2.09,0.64,0.81,1.25,0.94,0 -1.90,1.65,0.26,2.16,0.43,1.87,1.45,4.78,4.55,4.70,4.52,1.61,4.20,3.91,1.90,0.15,-0.86,-0.01,-0.07,0.73,0.77,1 --0.33,-0.21,0.71,1.92,1.83,2.83,3.46,3.30,2.19,0.98,-0.22,2.06,1.84,2.62,3.15,0.33,-0.19,-1.29,0.87,-0.94,-0.72,0 --0.30,0.73,0.38,1.85,-1.04,1.45,3.02,4.57,4.83,5.82,4.86,4.94,2.04,1.68,1.66,-0.61,1.17,0.84,0.09,-0.93,-1.35,1 --1.27,2.07,1.27,3.37,4.09,4.58,4.99,4.82,2.39,2.24,0.65,0.60,-1.27,1.30,0.24,-0.08,-1.15,-1.23,1.53,1.50,-0.53,0 -0.83,1.97,1.69,1.16,1.86,3.92,5.38,3.10,3.56,3.92,3.47,0.55,2.17,2.63,3.34,0.86,1.85,1.74,-0.13,-1.56,0.90,0 --1.63,-1.72,2.15,2.16,2.19,1.55,3.41,4.90,3.04,4.40,3.54,3.16,2.31,1.85,0.40,1.18,-0.67,-0.40,-0.92,0.10,-0.46,1 --0.24,0.38,-0.65,1.21,0.98,3.19,3.13,5.49,2.94,5.69,4.12,3.95,1.73,1.81,2.74,0.04,0.37,-0.66,0.95,1.06,-0.54,1 --0.52,0.67,1.53,1.92,0.94,1.82,4.45,3.81,2.83,1.76,1.90,2.74,1.32,3.93,2.94,4.49,1.87,1.47,-0.90,0.87,0.03,0 --0.38,2.07,0.36,4.67,2.98,5.34,4.59,3.74,2.43,1.55,2.95,0.28,0.83,0.46,0.26,1.15,-2.07,-1.61,0.77,1.15,-0.48,0 -0.57,0.46,0.87,-0.74,-0.17,2.45,1.53,0.82,5.10,4.61,5.09,4.73,4.30,4.56,3.05,1.83,-0.52,0.96,-0.67,-1.36,0.92,2 -0.61,1.22,0.50,2.48,0.01,2.08,0.17,2.59,0.24,3.52,5.57,5.10,3.66,4.46,2.14,3.90,2.30,0.56,0.42,3.50,0.75,2 -0.81,1.21,1.21,2.68,3.60,4.17,6.51,4.81,3.15,2.79,3.33,1.44,2.22,-1.31,-0.31,1.42,-0.14,-0.49,-0.26,1.42,1.33,1 -0.27,1.61,0.66,1.22,1.82,4.35,4.42,3.84,3.19,4.57,5.10,3.07,1.33,2.89,1.28,0.28,1.95,0.29,0.35,-0.08,1.02,1 -0.92,1.07,0.46,-0.88,-0.55,-0.20,0.14,-0.02,1.75,2.25,2.46,3.68,3.53,3.05,6.19,3.63,3.70,2.94,2.83,0.52,0.71,2 -1.57,-0.18,3.76,1.32,2.94,3.70,4.52,4.64,3.79,2.70,3.65,1.70,0.33,2.01,-0.42,2.05,1.03,0.78,1.22,0.75,-0.89,1 -1.08,0.42,1.22,0.80,0.07,1.51,-0.97,-1.88,0.08,0.74,2.48,2.33,4.12,4.43,5.35,4.87,5.67,3.15,1.50,1.33,0.10,2 -0.80,-0.15,1.36,1.43,1.21,1.65,-0.61,2.42,0.89,-0.24,2.70,1.93,3.01,4.47,5.12,3.46,2.43,3.61,0.15,2.12,-1.19,0 -0.78,1.14,0.25,-0.24,0.06,1.08,-0.87,2.77,2.85,4.20,3.06,2.45,3.82,3.28,3.29,1.30,0.61,2.09,-1.28,0.30,-1.23,2 --0.33,0.75,-0.73,-0.70,-0.79,-0.40,0.61,1.60,1.39,2.89,4.09,2.94,4.40,4.64,5.04,2.79,2.36,2.41,3.42,-0.41,-1.57,2 --1.20,1.99,-0.16,-0.63,0.92,-1.03,1.74,2.71,1.37,2.37,2.77,2.03,3.39,2.42,4.18,3.57,1.88,2.57,1.88,-0.12,-0.73,2 --0.25,-1.72,0.84,-0.54,-0.68,-1.26,1.89,2.96,1.48,4.35,3.25,3.67,4.22,3.32,4.79,3.42,1.04,2.27,0.07,1.84,-0.08,2 -1.03,1.72,0.92,2.77,5.86,5.12,5.07,4.90,3.39,0.98,1.96,1.95,-1.96,-1.77,2.05,1.25,1.15,1.46,0.85,-0.58,0.03,0 -0.82,0.65,-1.28,2.35,2.43,5.21,3.69,5.47,6.13,4.11,2.75,2.80,1.28,1.16,0.02,1.27,-0.92,-1.04,-0.90,-1.86,-0.99,1 --0.34,0.49,-2.24,-0.12,-1.11,0.26,0.63,0.30,-0.56,1.63,2.66,5.39,3.09,4.36,5.77,2.26,3.56,1.09,0.19,-0.01,0.31,2 -0.09,1.64,-0.24,-0.41,0.31,2.01,0.65,3.65,2.75,4.38,6.59,4.57,4.90,2.21,2.45,1.42,0.70,0.94,-1.26,-0.73,2.16,1 --0.59,-0.44,-0.01,2.22,1.34,1.96,3.03,4.05,3.33,4.56,5.07,4.34,2.02,3.73,0.66,1.57,0.41,-0.87,-0.45,0.44,-0.57,1 --0.13,0.35,3.14,3.06,1.95,4.23,4.85,4.81,2.23,2.58,2.17,2.08,1.84,2.95,2.01,-0.05,2.02,0.86,-0.09,1.23,-0.44,0 -1.14,2.30,0.87,-0.84,-0.46,4.36,1.10,-0.13,3.68,3.60,4.98,3.36,3.93,4.36,4.39,3.22,0.13,-1.04,0.24,0.22,-0.71,2 --0.40,1.19,-0.22,-1.33,-0.16,0.26,0.04,-0.18,1.28,1.10,2.27,1.48,5.87,4.49,3.56,2.89,2.81,2.31,0.89,0.44,0.32,2 --0.43,-0.73,1.40,2.07,2.64,2.99,2.50,4.72,2.49,2.64,3.16,1.66,-0.16,2.57,2.89,2.59,1.16,2.93,1.75,0.95,0.50,0 -1.43,1.81,1.60,1.75,2.16,3.57,2.66,3.22,1.98,0.45,2.01,1.20,1.43,1.71,2.39,3.76,2.84,-0.75,-0.01,1.39,0.67,0 --0.97,2.01,0.13,1.61,1.44,2.75,4.59,2.19,2.66,4.68,3.60,3.74,2.50,1.25,1.59,1.14,-0.31,0.78,0.61,0.55,-0.13,1 --2.29,1.03,1.95,0.74,3.37,4.35,5.73,4.31,4.08,3.86,1.45,1.54,-0.05,0.64,1.22,-0.78,-0.76,-0.65,0.45,0.83,-0.87,1 --2.75,-0.18,1.13,2.79,2.24,6.62,5.43,6.26,3.07,4.42,2.94,1.76,-0.28,0.32,0.09,-1.84,-0.82,0.82,-0.79,0.01,1.45,1 --1.63,1.83,1.83,1.47,2.13,2.25,3.96,2.71,5.59,4.51,5.22,4.00,3.27,2.22,1.62,1.59,1.16,-0.88,0.94,-1.57,-0.52,1 --0.90,-0.08,1.93,2.95,1.30,1.58,6.34,3.83,2.50,2.82,3.17,3.57,0.39,2.59,1.30,0.87,-1.21,-0.16,1.82,1.43,-0.35,1 --1.59,0.39,0.46,-0.07,2.07,-0.74,-0.69,1.38,1.57,4.76,3.44,4.12,3.53,3.92,3.66,2.41,1.08,2.46,3.79,0.10,-0.04,2 -1.82,-1.24,2.53,1.04,-0.40,0.91,1.50,2.44,4.00,4.93,4.01,4.47,4.31,3.12,3.17,0.70,0.67,-0.74,-0.12,-1.46,0.83,2 --0.40,0.66,-0.04,0.32,0.70,0.77,2.08,2.00,3.29,5.21,3.95,5.54,3.99,3.14,1.84,1.32,-0.36,-1.16,-0.51,-0.47,-1.21,1 -1.41,-1.11,2.30,0.13,2.16,1.21,1.03,2.08,1.85,2.48,4.73,4.13,1.82,5.23,4.41,4.47,0.70,2.69,1.44,0.62,0.06,2 --0.42,1.63,0.49,1.82,4.64,4.12,5.32,3.42,5.23,3.94,2.14,2.70,0.90,0.90,-1.61,1.11,-0.36,-0.76,0.21,-0.80,-0.06,1 -0.63,0.33,0.63,1.51,0.31,1.65,1.45,3.16,1.82,3.56,5.11,3.35,2.86,4.91,5.08,1.45,3.53,1.88,0.17,-0.52,0.18,2 --1.12,-0.21,1.05,1.72,0.60,-0.33,2.41,1.17,-0.62,0.01,-0.01,2.34,2.94,3.52,4.16,5.36,3.38,3.50,0.39,1.44,0.98,0 --0.47,0.58,0.56,0.80,-1.08,0.85,1.96,0.38,1.41,2.02,3.08,3.77,3.96,3.74,3.78,4.08,2.96,1.89,1.04,1.42,0.08,2 -0.19,-1.00,-0.11,-0.40,0.58,0.35,2.90,1.05,2.61,3.92,5.86,6.49,2.59,3.16,4.94,1.07,-0.18,0.10,1.66,2.35,1.13,2 --0.04,0.05,2.80,1.65,1.91,2.18,3.54,3.87,3.93,3.38,4.48,3.07,2.78,2.36,0.94,0.07,0.70,0.78,-0.03,0.64,1.67,1 -1.54,1.26,1.42,1.11,0.81,2.51,2.85,2.73,4.49,5.37,4.41,2.49,2.67,0.71,-0.36,0.38,-0.53,0.44,0.29,-0.50,0.87,1 -0.33,-0.36,1.06,0.29,-0.82,0.17,2.09,3.92,2.91,4.03,4.63,5.08,5.86,3.47,4.16,2.84,2.24,0.09,0.47,0.06,-0.34,2 -0.69,-0.31,0.93,1.14,0.16,-0.19,3.01,0.69,0.87,0.85,-0.06,4.53,2.40,2.82,3.21,4.23,2.06,2.87,0.85,-0.27,1.18,0 --0.07,-0.51,0.33,-0.90,0.39,0.78,0.06,2.89,3.11,4.22,7.29,3.54,5.66,3.82,1.42,2.34,0.79,-0.79,1.12,-0.54,0.38,1 --0.70,-0.06,0.43,0.12,1.54,2.15,2.83,5.38,1.52,1.66,3.35,2.22,1.82,1.48,4.68,4.30,3.65,1.58,-0.25,0.71,0.38,0 -1.43,0.41,0.83,0.08,1.22,-0.12,1.31,0.91,1.57,1.55,3.45,4.79,5.73,5.03,5.47,3.38,3.34,1.77,2.12,-0.30,0.20,2 --0.74,-1.54,2.32,2.25,0.39,3.15,2.17,2.05,0.93,1.50,2.78,3.83,0.19,2.39,3.46,1.70,1.99,1.60,0.52,1.05,0.13,0 -0.27,-0.17,2.76,2.42,3.91,4.63,6.07,2.97,2.92,2.80,2.92,0.87,1.26,0.61,-0.47,-0.68,-2.42,-0.86,-0.08,-0.33,0.05,1 --1.01,1.20,2.99,1.48,3.71,3.78,3.82,3.73,3.22,1.61,2.01,3.13,0.94,0.81,1.60,-0.03,0.13,-0.04,0.23,0.86,-0.21,1 --1.82,2.26,1.73,0.52,3.04,1.27,3.03,3.92,2.53,2.98,4.48,4.22,3.22,1.38,1.15,0.80,-0.30,0.61,-1.02,1.28,-1.16,1 -1.36,1.16,-1.12,-1.26,-0.58,2.13,1.04,0.75,2.38,2.87,2.93,1.36,3.51,5.07,4.21,3.49,2.87,0.67,-0.26,-0.81,0.00,2 --1.72,-1.13,-1.14,-0.24,-0.51,0.63,0.22,0.03,-2.17,1.20,2.58,4.21,2.25,4.48,5.33,5.42,4.71,2.43,1.90,-0.01,0.74,2 --0.88,0.20,2.54,2.92,2.99,3.12,5.05,1.88,3.55,0.94,1.73,0.28,-0.55,0.99,0.93,1.05,1.39,-1.75,-0.26,1.05,1.18,0 -0.23,0.54,1.95,1.61,2.65,4.60,4.91,6.12,3.32,4.70,3.96,-0.35,-0.38,1.51,1.02,-0.83,0.11,0.75,-2.04,0.39,-2.45,0 --0.38,-0.52,-0.67,-0.40,-0.09,0.66,1.77,2.57,4.74,6.58,3.88,5.47,2.26,4.04,0.72,0.12,1.98,0.09,-0.63,-0.91,-0.24,1 --0.41,-0.39,0.39,1.81,1.23,1.32,2.76,1.73,0.19,2.56,2.52,2.92,2.16,3.27,4.05,4.79,4.96,4.04,2.05,0.03,-1.23,0 -0.25,-0.47,2.16,3.33,2.42,4.58,5.80,6.97,3.30,4.32,3.17,2.54,-0.23,1.17,-1.04,-0.62,-0.62,-0.62,1.15,0.18,-1.55,1 --0.26,0.39,3.34,3.15,4.42,5.69,4.11,3.35,5.85,3.80,1.96,1.86,1.05,1.96,1.00,-0.70,1.17,-2.50,0.54,0.00,0.02,1 --1.63,0.85,2.24,1.17,3.06,2.36,4.81,2.08,0.56,2.68,2.71,4.39,-0.63,4.85,2.18,0.87,2.78,3.02,0.12,0.64,-1.43,0 --1.18,1.40,-2.03,-0.10,-2.03,0.60,0.10,-0.45,1.12,-0.23,3.02,3.88,3.22,4.20,6.73,4.16,1.82,5.36,2.30,1.55,-0.15,0 -0.09,1.59,-0.81,-1.17,-1.84,0.19,2.53,1.27,1.41,1.65,3.50,2.26,3.28,3.24,4.81,4.91,3.02,1.99,1.60,1.73,0.13,2 -1.06,0.02,0.63,2.76,1.74,1.03,3.44,1.09,1.39,1.40,4.07,3.42,1.48,0.90,2.81,1.11,2.21,0.99,0.95,-1.04,-1.03,0 -1.28,-0.08,-0.84,-0.16,0.15,1.11,2.52,3.00,4.74,4.88,6.88,5.01,4.75,2.45,0.92,2.48,1.23,0.27,-0.18,0.43,-0.08,1 -0.46,0.00,1.20,0.33,0.64,1.74,0.01,3.81,2.69,5.09,7.44,4.49,3.55,3.10,1.41,1.15,-0.59,-0.92,-0.78,0.70,1.56,1 --0.10,-0.76,2.19,1.44,1.73,0.84,2.08,4.13,4.80,3.91,3.71,3.54,2.31,2.03,2.99,-0.86,-1.23,-0.46,-0.71,-0.76,0.83,1 -0.41,-0.65,-0.83,-0.67,0.38,1.84,1.07,1.10,4.10,6.20,6.17,4.30,4.55,2.67,0.56,0.03,0.87,0.28,0.17,-0.40,-0.95,2 --1.98,1.49,1.49,1.84,3.16,1.68,3.93,1.78,1.30,1.69,2.91,2.29,2.15,2.87,3.97,3.85,2.06,0.86,0.22,0.51,-0.05,0 -0.20,0.86,0.70,-1.48,1.48,1.18,2.85,1.28,4.38,5.11,5.75,6.36,2.25,2.29,1.49,0.46,0.53,0.20,1.43,0.13,-1.29,1 -3.17,0.53,-0.60,2.20,0.33,2.03,3.84,4.75,3.94,5.99,5.03,5.37,4.27,2.54,1.20,1.59,0.20,-1.21,-1.81,0.44,1.13,1 --0.01,1.36,-0.63,2.73,3.01,4.73,2.24,2.10,0.25,2.70,1.93,2.09,1.81,1.74,2.27,1.91,0.90,-0.06,-1.38,1.28,0.54,0 -1.43,1.52,1.58,2.13,2.84,3.57,5.99,5.59,3.54,2.61,2.23,2.32,0.56,0.24,1.58,1.16,0.43,1.44,0.32,0.74,1.04,0 -0.33,1.03,-0.22,0.01,1.69,2.27,1.57,4.32,4.95,7.25,5.12,5.14,3.36,4.26,1.32,-0.13,-0.37,0.34,0.40,1.33,0.24,1 -1.00,-0.06,0.43,0.84,0.67,1.28,1.43,1.15,2.17,2.43,4.12,4.46,5.05,4.15,2.93,3.70,0.62,1.16,0.24,0.64,1.09,2 -1.61,1.01,-1.42,-0.57,0.92,0.20,2.64,3.16,2.01,3.09,4.73,3.27,4.33,2.18,2.16,3.02,0.74,0.81,-0.39,-1.07,-0.29,2 --0.73,1.30,1.91,0.22,1.98,1.86,2.05,2.84,0.28,1.96,1.09,-0.85,3.87,1.92,3.02,3.44,4.18,1.12,1.96,0.17,-1.53,0 --0.68,0.18,0.45,-0.64,0.36,3.39,3.66,4.51,1.95,2.30,7.01,4.13,2.07,4.84,1.53,1.08,0.29,0.39,1.28,0.27,0.14,1 -0.50,1.69,1.93,2.98,2.48,5.43,5.65,4.71,3.87,2.11,1.74,0.29,-0.61,-0.85,-0.35,1.09,-0.55,0.97,1.52,-0.51,-0.11,1 --0.55,-0.47,-0.72,-0.17,0.12,2.18,3.69,2.61,3.19,5.42,5.30,3.39,1.65,3.34,1.78,0.71,1.57,-1.17,-0.63,2.48,0.28,1 -1.50,-1.09,0.20,-0.23,1.89,2.62,1.88,3.02,5.09,6.08,4.81,5.19,2.86,4.20,2.98,1.79,-0.82,-0.81,1.58,-0.98,0.05,1 -0.46,-0.36,0.79,2.72,3.62,4.17,5.19,5.83,4.14,3.22,1.02,0.97,2.32,0.31,-1.49,1.07,0.35,0.77,-0.04,-0.31,-1.14,1 -1.92,-0.78,-0.93,1.03,1.45,1.84,3.28,3.99,4.70,4.09,4.70,5.84,3.02,1.89,2.23,1.90,0.71,-0.26,0.30,0.95,0.94,1 --0.00,-0.11,-1.10,-1.84,-0.98,0.75,1.92,1.03,4.46,5.89,4.74,3.76,2.53,2.67,3.10,4.33,2.98,2.61,-0.73,-0.14,-1.03,2 --0.23,0.25,0.64,1.96,1.27,1.69,2.06,-0.36,1.47,1.72,0.83,2.47,2.61,2.94,4.12,2.56,2.85,1.36,1.13,-0.27,1.28,0 --1.93,0.12,-0.51,-0.57,1.42,0.24,1.87,-0.05,0.44,3.14,3.60,4.35,3.80,1.85,2.05,4.32,0.22,0.25,1.58,2.00,0.87,2 --0.58,0.68,-0.05,3.07,4.68,2.52,6.17,4.33,4.53,2.42,1.58,3.80,1.32,1.61,0.47,1.46,-1.31,0.76,-0.89,-1.34,-0.26,1 --1.49,-1.62,0.97,0.14,0.37,1.33,1.53,2.55,3.68,3.92,6.05,3.77,1.78,3.35,3.91,1.61,0.95,0.56,-0.55,2.32,-0.37,2 --1.18,1.40,0.27,-0.10,1.35,0.94,1.23,1.04,1.56,1.41,2.00,3.89,4.27,5.04,6.17,3.41,4.11,2.22,2.23,2.04,2.33,2 -0.21,1.14,0.14,0.54,-1.10,0.03,-0.21,0.09,-0.76,0.83,0.66,3.09,5.28,4.47,5.47,3.10,2.25,3.08,2.23,1.50,0.19,2 --0.61,1.18,2.32,1.91,4.01,3.65,5.74,5.42,1.29,2.93,2.02,2.01,-1.03,-0.61,1.27,2.00,0.74,1.03,-0.04,-2.15,0.24,0 -1.51,-0.36,0.45,0.33,3.80,3.67,5.77,3.59,4.25,4.47,3.00,3.54,1.92,5.09,0.77,-0.14,0.72,-1.79,-0.36,-0.72,0.42,1 --0.54,-1.60,0.78,-0.10,1.83,2.12,2.42,4.16,5.90,3.89,6.07,3.72,1.37,2.31,1.10,-0.47,-0.47,-0.51,0.05,-0.02,1.19,1 --0.28,0.14,-1.84,-0.77,0.43,1.41,1.78,0.97,0.77,2.46,5.67,5.14,5.05,3.38,1.97,2.24,2.80,1.93,1.09,-0.74,-0.81,2 -2.26,-0.40,0.39,0.94,-0.41,0.36,0.83,0.82,1.52,4.16,4.76,5.04,3.42,1.97,3.48,4.70,1.95,2.43,1.15,0.74,-0.86,2 --0.83,1.48,1.37,-0.44,2.31,2.60,2.06,3.49,2.89,4.13,3.93,2.87,1.06,1.05,2.15,2.24,0.90,-0.42,0.15,-0.87,0.29,0 --0.09,1.62,0.50,4.06,2.56,2.73,2.32,4.01,3.70,2.80,3.18,3.49,1.21,1.04,0.77,0.92,-0.70,-0.00,1.54,-0.76,1.01,1 -0.15,0.58,1.90,3.36,2.77,4.38,5.11,6.16,3.04,4.44,2.41,0.59,-0.41,0.45,-0.17,1.14,-0.97,0.23,0.55,-0.42,0.92,1 --0.54,-0.37,3.53,4.45,1.63,4.46,5.26,3.11,3.30,4.58,2.52,2.84,0.41,0.96,1.43,1.73,2.24,2.63,0.36,-0.60,-0.53,1 -1.26,1.65,3.06,2.05,4.09,3.70,5.81,4.17,4.48,0.76,2.06,1.13,-1.21,1.09,1.00,1.77,-0.86,0.34,2.03,0.27,-1.10,0 --0.95,-0.32,-0.22,1.11,1.77,-0.13,1.94,1.98,2.98,5.77,7.27,4.76,4.05,2.31,1.33,1.76,1.51,0.96,1.25,-1.38,0.54,2 --0.68,1.23,0.76,1.58,1.70,0.89,4.00,1.78,1.41,1.16,2.63,2.27,3.87,3.78,3.89,3.04,3.08,2.23,2.20,1.98,-1.74,0 --0.07,0.86,0.99,1.80,1.10,3.76,4.31,4.29,2.95,3.17,4.43,3.49,1.78,1.13,0.27,-2.36,-1.08,-1.09,0.73,-3.21,0.27,1 --0.16,0.33,1.86,2.46,3.39,4.88,4.90,5.76,4.12,5.43,2.92,1.14,0.57,-1.47,0.81,0.96,-0.38,0.03,1.81,-0.03,-0.63,1 -0.58,1.10,1.48,1.11,2.96,3.99,5.32,5.22,5.97,3.01,4.14,1.34,0.63,1.41,0.97,-0.75,-0.35,-0.06,1.10,0.26,-1.00,1 -0.99,0.08,1.37,-0.34,-0.16,0.68,2.60,2.20,3.41,2.84,5.12,3.70,3.26,4.26,2.37,2.35,-0.50,2.02,-1.48,-0.39,0.99,2 -0.17,0.55,0.79,-0.87,1.09,0.47,-0.12,1.68,3.62,2.61,4.75,5.98,2.98,3.85,3.90,1.65,2.03,0.10,-0.34,0.03,-1.68,2 --1.32,1.13,-0.16,1.33,-0.79,0.80,-0.04,-1.91,0.44,1.95,3.91,3.68,3.48,6.65,3.92,4.87,2.23,2.19,1.12,0.03,-1.72,2 --0.57,-0.11,1.23,1.45,1.05,0.30,2.07,1.98,2.91,4.91,5.71,4.23,4.09,1.30,1.72,0.98,-0.78,-1.54,0.03,0.04,0.59,1 --0.83,-0.19,-1.79,1.17,-0.45,-0.98,0.96,0.26,0.15,1.68,3.54,3.20,4.66,3.70,6.81,5.39,4.34,2.62,1.24,0.13,-0.15,2 -0.28,2.04,0.96,2.30,3.97,3.87,5.04,4.25,5.28,3.24,1.73,1.72,0.23,-0.87,0.90,-0.75,-0.29,-0.05,0.44,-0.10,-0.44,0 --1.27,1.10,-0.09,2.01,3.18,2.90,5.65,5.27,0.66,3.76,2.47,0.96,2.06,1.25,1.03,1.27,-0.93,1.31,0.30,0.55,0.92,0 --0.64,-0.49,0.41,-2.64,-0.83,-0.60,2.07,-0.14,1.92,1.11,3.63,1.60,2.72,4.11,6.82,4.08,2.71,2.71,1.44,1.76,0.87,2 -0.27,1.05,0.38,-0.23,1.42,3.20,2.72,3.02,2.81,2.83,2.44,4.78,1.54,4.58,-1.15,2.07,0.39,-0.05,0.77,-1.49,-0.47,1 --0.60,-0.13,2.78,1.06,1.17,0.87,2.94,4.26,2.27,3.41,5.58,3.24,3.44,2.29,0.65,0.47,-0.29,0.92,-1.11,-0.05,0.21,1 -0.50,0.86,2.55,1.25,3.06,4.53,4.19,2.98,2.33,3.58,2.20,1.85,1.69,1.55,1.14,2.93,2.85,1.20,1.18,-1.05,0.47,0 --1.08,-0.67,0.92,2.47,1.95,2.99,2.13,0.38,0.82,2.27,1.98,3.61,2.04,2.99,3.94,3.54,2.07,0.78,0.42,2.40,0.44,0 --1.00,1.32,1.72,2.53,4.09,4.45,4.52,4.35,4.60,3.64,4.89,3.82,1.90,2.08,1.23,0.05,0.09,-0.64,-0.68,0.01,0.56,1 --1.27,-0.24,1.40,-0.62,0.88,0.98,0.97,2.24,-0.22,2.32,1.73,2.96,3.65,4.25,5.59,3.74,3.54,3.23,1.31,0.41,0.22,0 -0.55,1.25,1.99,2.21,2.08,2.90,4.40,4.05,3.49,1.32,1.66,2.16,0.86,2.15,2.47,2.01,1.44,0.93,1.33,2.99,-0.93,0 -0.93,0.32,1.47,0.57,0.54,-0.61,-1.01,-0.59,1.20,0.99,2.10,4.52,3.45,6.10,5.78,4.37,2.37,3.28,1.13,0.07,0.28,2 --0.51,0.75,1.92,3.56,4.61,6.10,4.00,4.95,6.00,3.90,2.64,1.45,0.76,0.64,0.82,-0.75,-1.94,1.25,1.55,-0.84,0.42,1 -0.99,0.41,1.60,2.39,4.36,4.74,3.87,5.03,4.35,2.38,3.20,0.30,1.61,1.36,0.10,-0.56,0.69,-0.35,-1.04,-2.49,0.78,1 --1.29,-0.20,1.29,0.05,0.06,-0.52,0.36,-1.27,1.26,-0.37,0.58,1.40,3.26,5.58,4.47,3.93,3.10,2.68,2.55,-0.64,-1.04,0 -0.43,1.89,1.24,2.38,3.23,3.15,4.91,4.29,3.72,1.20,3.06,2.86,1.55,0.86,-0.44,-0.30,-0.36,0.24,0.80,-0.63,-0.59,1 --0.45,0.12,2.43,2.33,3.85,4.06,5.50,5.33,3.53,2.45,0.84,0.16,-1.59,1.46,-2.56,-0.84,-1.64,-0.66,0.07,0.94,-2.37,0 --2.07,1.65,1.50,1.31,1.56,1.60,1.23,2.34,0.39,0.11,1.97,2.54,4.18,4.15,4.28,3.58,3.06,1.51,0.89,0.42,0.16,0 -1.35,-0.29,0.20,-0.65,-1.13,2.36,2.32,0.38,2.04,0.98,4.05,3.94,4.11,3.59,5.90,3.17,2.88,2.78,1.36,0.22,0.78,2 --1.25,0.69,1.88,0.69,4.46,4.49,5.32,3.10,4.34,2.11,2.11,1.09,0.88,-0.14,0.38,1.13,0.98,0.71,1.13,1.13,-0.27,0 --0.47,1.06,0.68,2.96,4.17,4.74,5.04,5.58,5.92,2.99,3.58,1.74,1.76,1.12,1.25,0.79,-0.10,1.92,1.28,0.54,-0.39,1 --0.32,2.13,3.85,0.32,3.64,3.86,3.21,3.97,1.90,5.05,3.28,3.20,-0.29,0.17,0.76,-0.18,-1.56,1.12,-0.76,0.05,-1.82,1 --1.22,0.65,-0.02,-1.17,-0.29,0.86,0.29,0.34,3.11,4.55,4.64,4.50,3.62,2.59,3.19,4.33,0.16,3.29,-0.18,1.20,0.48,2 --0.65,-2.80,0.11,1.36,3.88,3.37,4.38,4.57,3.15,2.22,4.27,3.44,0.77,1.45,2.18,0.88,-1.07,-1.68,-0.22,-0.02,0.70,1 -0.24,0.62,-0.55,0.75,1.77,1.31,2.51,2.66,3.67,1.84,2.63,3.11,3.03,3.71,4.25,1.00,2.00,1.97,2.31,0.71,-0.29,0 --0.98,-0.34,0.67,0.50,1.39,0.20,3.10,1.28,3.52,1.72,4.97,5.05,3.99,2.84,2.92,1.75,-0.57,-0.48,-0.58,0.92,0.64,2 -1.01,-0.43,0.39,0.01,1.49,2.15,0.52,-0.33,0.07,0.88,1.19,2.68,3.79,4.89,4.88,5.34,5.16,3.88,1.49,1.89,-1.02,0 --0.69,0.58,0.40,0.87,-0.40,-0.39,-0.69,1.28,0.45,0.04,0.09,3.82,3.88,3.53,6.36,5.75,2.94,2.38,2.01,0.47,1.24,0 --1.83,0.09,0.16,0.83,2.56,2.60,4.39,2.84,4.40,1.49,3.22,1.92,0.68,0.72,1.27,0.56,1.55,0.75,-0.45,-0.09,0.48,1 --2.55,0.44,2.30,-0.63,-2.00,-1.31,0.46,2.29,1.40,3.21,3.84,3.22,4.75,2.79,3.02,4.23,-0.18,0.33,-0.78,1.17,0.05,2 --0.14,0.75,2.31,3.06,4.75,5.57,6.28,3.20,4.94,4.05,2.37,2.29,-0.24,1.72,0.20,-1.85,-1.29,-0.85,-0.93,0.16,-0.30,1 -0.51,1.82,0.35,0.33,0.35,-0.37,1.77,0.70,-0.63,0.00,2.92,1.65,4.75,3.97,6.96,6.22,2.73,0.55,2.62,2.05,-1.09,0 --0.61,0.35,4.39,1.71,3.52,5.27,5.18,5.21,2.77,1.63,-0.15,1.35,-0.03,1.02,0.73,0.27,0.50,0.23,0.31,0.15,-0.68,0 --0.41,-0.08,-1.83,-1.34,-1.20,1.38,-0.58,0.55,1.03,1.53,2.26,2.80,3.20,5.21,5.26,3.90,2.66,4.62,1.85,2.10,-1.38,0 -1.00,-1.11,-0.56,1.13,0.26,-0.47,0.92,0.62,1.49,2.50,1.37,2.60,2.22,4.11,6.47,4.11,2.58,2.08,0.92,1.07,0.82,0 --0.94,0.26,1.38,-0.45,0.10,1.35,1.99,2.80,4.83,4.80,3.51,3.75,3.60,1.87,1.69,-0.52,-2.16,-0.16,-1.07,1.04,0.15,1 --0.60,1.05,1.86,1.85,4.33,2.09,4.46,4.97,3.38,1.91,2.93,1.45,1.39,1.40,0.92,1.29,0.62,0.94,0.33,0.10,1.50,0 --1.52,2.49,1.46,0.59,2.67,2.76,2.99,2.69,3.92,3.08,2.12,2.22,0.48,2.25,0.50,-0.21,1.99,-0.57,0.55,-0.05,-0.42,1 -0.34,-2.33,1.46,-0.32,2.10,-0.77,0.23,-0.01,0.19,1.10,0.75,3.92,3.96,2.57,4.80,3.28,3.56,1.96,1.49,1.22,-0.60,2 -1.57,1.51,0.45,0.97,0.52,4.43,3.37,2.81,2.58,3.30,2.10,2.17,1.58,0.68,-0.40,1.27,1.49,-1.11,1.86,2.30,0.04,0 --0.82,1.43,0.17,0.20,-2.04,0.40,1.43,3.53,3.62,3.51,5.46,3.47,4.28,2.57,4.07,3.00,1.06,1.41,-0.05,-0.55,-1.06,2 --0.02,0.24,1.39,1.65,1.24,3.85,3.02,3.77,2.03,2.30,1.87,1.04,0.92,0.44,2.56,1.50,0.07,1.46,-0.10,2.25,-1.08,0 -0.05,1.59,-0.96,-0.63,-0.25,0.22,1.17,0.93,3.38,2.01,2.91,4.89,2.98,1.79,2.80,3.18,1.94,0.11,-0.78,0.02,-0.11,2 -1.09,-0.80,0.91,2.22,0.98,1.36,4.06,4.51,5.59,5.22,4.12,2.78,2.52,2.56,2.03,0.38,0.65,-1.44,-0.75,0.47,-0.76,1 --1.27,-1.50,-0.07,-0.47,0.15,1.11,0.21,0.52,-2.05,1.49,3.43,2.81,3.57,4.38,3.81,4.62,3.11,0.68,2.47,1.90,0.81,2 --0.94,1.57,1.09,2.05,3.88,3.98,3.59,5.75,1.79,1.17,2.32,0.94,1.94,0.55,1.47,0.77,1.75,1.38,0.10,0.90,0.04,0 --0.48,-0.47,1.75,2.14,3.46,2.46,5.20,4.34,4.68,2.78,3.25,1.56,0.47,0.33,-0.21,0.41,0.07,1.19,0.52,-1.46,0.88,1 -0.86,0.79,0.52,2.14,-0.32,0.95,3.26,2.83,3.57,3.61,3.79,3.66,2.61,0.59,0.93,2.97,1.29,-0.51,-0.05,0.12,-1.03,1 --0.56,1.13,0.86,-0.19,2.11,-0.68,0.33,1.94,-1.01,3.44,4.22,3.83,3.66,4.96,4.63,3.89,2.26,1.63,0.66,0.84,1.73,2 -0.57,0.65,1.10,0.41,2.68,2.75,3.72,4.44,3.05,2.52,1.69,1.03,0.92,1.66,2.82,1.13,1.46,0.81,-0.48,-2.38,1.74,0 --0.65,-0.28,1.43,-1.78,-0.55,0.35,2.26,0.76,-0.16,2.02,3.63,1.85,4.04,2.82,5.01,4.12,4.30,3.68,1.26,0.28,0.82,2 --0.25,0.35,2.72,3.31,5.19,5.08,7.83,4.03,3.62,1.74,1.92,2.04,1.35,-1.92,1.12,2.02,-0.20,-0.28,0.13,2.49,0.33,0 --2.21,0.31,-0.25,-0.45,-0.30,-0.80,1.23,1.84,4.68,5.76,6.16,4.43,3.91,4.22,4.01,1.74,1.31,0.34,2.00,2.45,-0.59,2 --0.91,-0.95,1.63,-1.67,1.75,0.73,1.33,2.86,3.09,3.64,5.38,6.27,5.39,4.32,1.78,1.36,0.55,0.05,0.27,-0.15,1.28,2 -1.13,0.51,0.60,1.35,2.65,3.23,4.32,5.24,4.19,2.39,3.03,2.19,1.21,0.56,0.09,0.08,-0.02,-0.26,1.70,-0.23,0.47,1 --0.06,0.59,-0.18,2.24,-1.77,-1.88,-0.01,1.23,2.37,3.04,4.51,4.70,5.86,3.14,3.48,3.45,1.08,1.23,-0.54,-0.05,-0.13,2 --0.49,0.09,-0.86,1.60,2.26,-0.25,-1.93,-0.53,2.03,1.06,2.92,3.02,3.39,5.02,6.35,4.19,4.02,2.57,0.75,1.72,-0.08,2 --1.07,0.38,-0.04,0.83,0.07,1.18,-1.80,0.02,-0.10,2.55,1.24,3.36,4.00,4.40,5.58,6.61,1.79,3.24,1.79,2.60,1.52,2 --2.04,0.96,-0.24,1.01,0.44,-0.10,2.87,1.31,4.51,7.21,4.49,2.92,4.61,1.34,1.60,1.89,-0.38,1.31,0.16,-0.65,-0.25,2 --2.43,0.54,1.16,2.39,2.88,2.95,5.58,5.27,4.16,3.00,1.47,1.43,0.37,1.67,1.21,1.30,-0.40,0.04,3.25,-1.28,1.10,0 --0.04,-0.19,-0.03,-0.16,-0.07,2.31,2.41,1.89,2.28,4.16,4.99,4.76,3.61,3.46,2.10,3.81,0.44,1.94,0.52,-0.21,1.97,2 --2.47,-1.18,1.30,1.56,-0.99,0.32,1.54,0.08,1.50,0.05,1.85,3.26,3.66,2.97,4.40,4.55,3.45,3.19,0.82,2.00,1.40,0 --0.08,0.44,-0.52,-0.45,0.44,0.35,-0.35,-1.03,0.20,1.59,1.43,1.72,4.55,4.61,4.28,5.53,2.42,2.41,1.50,1.29,-1.76,0 -1.80,0.94,1.42,0.95,2.33,1.18,1.90,3.32,2.85,2.72,1.42,1.78,2.73,2.18,2.99,0.08,2.03,0.76,0.11,0.70,0.87,0 --0.72,-0.28,1.94,2.05,3.84,5.76,6.01,5.11,3.39,4.07,0.68,2.37,-1.01,0.88,-0.33,0.08,0.82,-1.71,-1.19,0.70,-0.62,1 -0.53,0.41,3.19,2.15,4.44,5.57,5.84,2.32,1.83,1.22,3.00,2.27,2.81,0.88,1.71,-0.38,0.68,-0.44,-0.53,-0.19,0.00,0 -0.19,1.57,0.67,-0.96,-0.47,1.12,2.57,-0.13,0.64,3.88,3.86,5.52,3.58,3.98,4.91,2.36,0.92,1.23,1.34,1.26,-0.80,2 -1.09,-0.10,-0.81,-0.56,2.33,2.93,1.24,1.46,4.17,4.05,3.85,6.56,6.07,4.59,3.13,1.54,0.26,-2.01,-0.54,1.45,0.38,2 -1.34,0.88,0.30,2.11,1.12,2.64,3.58,1.21,0.02,1.87,3.10,2.42,3.03,3.26,5.12,3.13,2.61,-0.31,1.77,1.34,0.37,0 --0.48,0.55,-1.08,-2.39,1.31,1.06,0.97,4.26,3.59,3.52,5.63,4.78,4.27,3.20,2.53,0.01,-1.47,1.46,0.45,1.28,-0.78,2 --0.15,1.20,3.05,3.71,2.35,6.15,6.31,3.39,3.58,3.00,3.97,1.84,0.14,0.97,-0.98,-0.08,0.58,-0.14,1.14,0.17,-1.29,0 --0.33,0.95,1.68,1.82,4.53,4.61,4.58,5.19,5.02,3.81,4.09,2.81,2.43,-1.19,-0.14,-0.89,-0.78,0.31,0.16,1.15,-0.33,1 -0.80,-0.63,1.89,0.07,-0.42,0.72,1.89,3.88,3.67,4.23,5.64,6.64,3.16,3.04,2.08,0.68,-0.54,1.10,-1.15,1.46,-1.27,1 -0.71,-2.03,0.55,-0.82,1.16,1.90,-0.30,1.39,1.79,2.66,3.64,1.83,1.87,5.72,5.30,2.18,2.30,1.46,1.27,0.29,0.53,2 --1.29,1.74,-0.87,1.64,-0.89,1.27,1.02,3.02,3.17,2.53,2.93,4.11,4.97,3.65,3.24,4.50,0.43,1.34,1.26,-0.68,-0.62,2 -1.01,2.30,2.32,0.98,0.33,3.03,2.25,3.75,4.68,2.98,3.63,3.34,1.39,-0.26,2.16,0.80,0.24,1.30,-0.56,-0.78,-0.00,1 -1.40,-0.90,-0.87,-0.33,0.46,1.64,0.55,0.43,2.10,1.94,4.05,2.30,3.32,3.40,3.41,3.07,0.60,2.97,1.33,-0.67,-0.75,2 --1.23,2.03,3.22,3.06,4.69,3.45,4.71,5.19,3.18,3.33,1.79,1.20,1.05,0.83,1.69,0.12,0.63,2.48,1.16,0.81,-0.97,0 --1.30,0.20,1.01,0.11,-0.34,2.57,2.57,2.83,2.44,6.62,5.11,4.63,5.88,3.42,4.72,2.33,-0.44,0.63,2.69,-0.06,-1.39,2 --1.47,0.48,1.77,2.16,1.62,0.49,4.42,3.27,2.21,1.15,2.30,0.50,1.62,0.75,1.80,1.62,2.41,0.81,1.10,-0.67,0.27,0 --0.07,0.58,1.90,0.40,0.42,1.73,3.35,3.84,3.42,4.39,6.44,4.54,3.28,1.80,1.20,0.72,-0.04,0.66,0.59,-1.32,0.05,1 -0.34,-0.98,1.28,2.32,3.59,2.43,4.72,4.06,3.11,4.54,4.01,2.26,1.64,2.11,0.40,-1.44,0.43,-1.72,0.41,-1.44,0.38,1 --1.20,1.09,-0.28,-0.78,0.71,0.75,0.78,0.74,1.26,2.82,2.58,2.78,5.52,3.08,3.84,2.99,1.18,0.89,2.78,0.11,1.14,2 --1.07,0.68,0.44,-0.75,0.92,1.41,3.59,1.86,5.45,3.13,5.02,4.73,2.69,1.18,0.75,1.06,0.19,-2.65,2.34,0.37,0.76,1 --1.68,1.99,-0.55,0.94,1.00,1.16,3.62,0.69,2.21,3.12,2.87,5.36,3.62,4.96,3.06,3.49,3.35,1.76,0.03,0.76,-0.80,2 --0.94,-0.64,0.54,1.34,1.70,-0.26,-0.64,1.24,-1.12,0.64,1.60,2.33,1.67,3.49,4.80,4.52,4.59,1.26,1.46,0.86,-0.67,0 -1.00,-0.08,-0.29,2.96,0.61,1.17,3.86,2.97,4.39,1.67,3.56,2.26,0.96,1.41,2.87,0.57,1.63,1.10,0.22,2.00,0.20,0 -0.66,1.32,-0.76,0.42,0.75,2.33,1.92,2.17,2.55,4.64,5.27,4.91,4.27,3.82,1.36,1.31,-0.72,-2.02,0.31,-0.60,0.88,1 -1.52,0.35,1.49,1.05,1.12,1.70,0.84,2.72,3.12,2.31,1.23,2.97,1.92,1.75,3.52,3.87,2.99,3.34,2.19,0.20,1.67,0 -1.75,0.64,-1.75,-0.42,2.03,2.08,4.18,3.25,5.37,3.19,4.53,3.41,4.45,1.19,2.64,1.25,0.25,-1.22,2.13,-0.72,0.96,1 -1.08,0.57,0.31,2.70,4.39,2.94,3.80,4.25,1.79,3.07,1.34,1.72,0.04,-0.67,0.36,0.56,-0.11,-1.10,-0.53,0.41,-1.11,1 -0.61,-0.59,0.36,0.49,-0.79,-0.17,0.82,2.01,3.43,6.51,4.70,4.07,5.22,3.79,2.49,1.36,0.37,3.28,0.28,0.46,0.26,2 -0.84,1.25,1.81,4.87,6.50,4.64,4.97,4.42,5.69,1.59,2.61,2.05,0.76,1.04,1.34,0.10,-1.10,0.78,2.03,0.46,-0.27,1 --0.27,-0.47,0.41,-0.66,-0.54,-0.99,0.26,2.62,2.60,3.38,4.32,5.32,5.11,5.19,3.26,0.75,1.23,1.80,2.31,0.56,-0.41,2 -0.59,-1.74,0.77,-0.96,-0.37,-0.99,2.35,3.38,1.08,3.43,2.26,3.26,5.97,3.36,4.50,3.30,1.62,2.27,0.57,2.45,-0.69,2 --0.49,-1.42,1.30,1.40,-0.07,0.35,1.96,1.85,1.47,3.37,2.27,3.01,3.13,4.72,5.43,4.52,2.40,2.03,0.43,-0.75,-0.14,0 -0.57,1.09,-0.54,1.35,-0.18,1.26,1.06,2.18,4.33,4.52,5.55,5.16,4.56,4.99,4.56,3.21,1.49,-0.47,1.35,1.07,-1.09,2 -2.26,0.25,2.39,-0.06,-1.16,1.43,2.43,3.08,5.01,3.53,4.92,5.60,3.67,2.87,1.79,1.57,-0.07,1.90,-0.22,-0.03,-0.43,2 -2.08,-1.37,-0.13,1.61,2.25,0.88,-0.05,3.09,2.83,1.15,2.44,2.55,1.97,2.48,2.33,3.11,1.66,1.69,0.60,1.00,1.02,0 -0.59,0.45,1.80,0.29,-1.49,-0.24,1.72,0.91,2.26,2.49,4.67,5.20,5.17,4.38,3.78,2.12,1.63,1.59,-0.51,0.04,0.40,2 --1.36,-0.18,0.89,-0.44,1.33,-1.62,-1.61,-0.26,1.68,2.06,2.52,4.83,3.79,4.67,4.97,4.90,3.57,4.48,3.28,0.98,1.95,2 -1.83,0.54,1.88,0.38,-0.91,1.28,2.19,4.83,3.13,4.49,4.82,4.45,2.99,1.35,1.31,1.89,-1.31,-0.24,1.70,-1.16,0.88,1 --0.45,0.59,0.76,3.71,3.22,3.73,4.64,4.37,4.23,2.82,1.85,2.45,2.29,-0.31,2.33,0.79,0.95,2.30,-1.05,-0.77,1.28,0 -0.53,0.90,2.37,1.38,-0.51,-0.83,3.05,0.87,2.29,1.27,6.22,3.63,3.93,4.85,3.66,3.06,0.38,2.97,1.41,0.28,-0.32,2 --0.36,1.66,1.34,2.45,4.26,5.14,7.08,4.76,5.78,3.11,0.93,1.24,0.29,0.89,1.94,-0.32,-1.45,0.39,-1.19,-0.11,1.50,1 -0.50,2.82,-0.98,2.28,1.37,1.25,2.53,2.93,5.23,3.45,2.55,4.91,1.09,2.85,1.43,-1.43,0.91,-1.46,-0.45,0.62,1.27,1 -0.34,0.82,-0.22,0.61,2.61,1.44,1.51,0.98,-1.72,0.04,2.38,1.74,3.74,5.26,6.69,3.63,3.37,2.36,1.42,-0.71,0.78,0 -0.27,0.12,-0.70,-1.56,1.01,1.21,1.47,2.25,1.79,3.99,5.83,3.84,3.69,3.30,3.77,2.15,1.27,2.79,0.61,0.32,0.95,2 --1.82,0.94,1.31,0.43,0.96,2.22,1.02,0.84,-0.37,1.35,1.14,3.87,2.36,4.01,3.65,3.29,2.72,2.77,1.92,1.01,-1.46,0 --0.10,0.26,-0.30,3.66,2.73,4.33,5.71,4.57,4.22,4.58,1.42,2.37,1.15,-0.23,1.77,1.02,0.65,0.97,-1.38,1.11,0.16,1 --1.59,-0.45,1.61,-0.76,1.61,0.54,0.85,1.72,1.62,1.61,3.27,4.00,2.96,4.82,5.20,5.44,2.46,1.52,0.50,3.27,2.35,2 -0.11,-0.00,-0.32,1.09,0.92,3.59,4.21,2.63,1.50,3.42,2.15,2.24,0.83,2.31,3.35,3.25,1.62,2.27,1.11,1.79,1.92,0 -1.45,-0.15,-1.52,-0.35,0.26,-0.62,1.01,-0.82,0.66,3.52,3.30,1.28,2.23,3.40,3.71,4.09,2.40,2.98,1.94,0.53,0.00,2 -0.80,1.31,1.01,2.91,3.01,5.81,7.09,4.86,5.23,2.89,1.78,2.17,1.74,-0.95,0.35,-1.58,0.72,-1.93,0.83,-1.14,1.12,0 -1.60,0.20,-1.04,-0.98,0.14,-1.67,2.44,3.48,4.32,3.27,6.19,4.89,4.04,1.57,1.47,1.82,-0.34,1.06,-0.56,-2.13,-0.41,1 --0.41,0.68,2.30,1.40,-0.76,2.72,1.78,2.36,-0.73,2.64,1.44,2.28,2.79,3.77,2.24,3.26,-0.07,2.57,1.96,0.51,0.78,0 --1.00,1.56,-0.21,-0.71,0.08,2.92,2.72,1.41,3.57,1.03,3.52,3.50,4.67,3.81,4.50,1.76,2.13,3.13,1.02,1.66,0.24,2 -0.75,2.43,1.42,2.39,5.11,5.43,5.51,4.44,5.78,3.34,2.74,2.36,-0.09,1.13,0.67,-1.92,0.32,1.26,-1.67,-1.51,1.37,1 -0.78,3.07,-0.02,2.44,2.49,4.70,5.29,2.39,2.91,3.29,4.75,2.03,0.94,1.82,-0.47,1.72,-1.37,1.47,0.53,0.77,-0.17,1 -0.52,-0.22,2.16,3.45,2.20,2.41,3.87,7.03,4.57,3.30,3.66,0.95,1.27,1.56,-1.47,-0.02,-0.08,0.54,-0.84,-1.24,-1.24,1 -1.02,-2.76,-1.17,1.29,-0.07,-2.71,-0.60,0.14,-1.36,-0.81,2.48,2.83,4.19,4.62,5.74,4.20,3.03,2.30,3.16,1.72,1.09,2 -0.32,0.83,1.80,1.94,2.36,4.05,5.85,3.82,2.97,2.93,3.36,2.74,1.48,0.49,1.36,1.08,-1.01,1.54,-0.86,-0.78,-1.83,1 -1.04,0.63,1.50,2.57,5.19,3.64,5.75,4.82,3.67,5.25,0.89,0.75,1.34,-0.07,-0.84,-1.62,-1.58,1.16,0.73,-0.09,0.17,0 --0.37,0.51,-0.26,-0.92,0.62,0.55,1.84,2.68,4.16,4.08,5.98,5.51,3.37,2.72,2.38,0.06,0.42,2.35,-0.26,-0.37,-0.35,1 -1.51,-1.64,0.52,1.38,2.15,-0.28,-0.63,-0.28,1.95,1.67,-0.66,3.56,2.71,5.20,4.80,4.10,1.94,2.69,1.07,3.08,-0.08,0 -1.77,0.12,1.29,3.85,2.94,5.11,4.76,3.87,2.75,3.37,0.80,2.29,0.93,2.35,1.88,1.18,-0.75,1.72,-0.55,0.91,-0.37,0 -1.14,-0.98,-0.36,-1.21,-1.13,0.88,0.08,2.04,0.71,3.89,5.51,5.58,3.34,4.54,3.30,2.74,0.44,0.41,-0.80,-0.59,0.93,2 -0.45,-1.79,0.12,-0.60,-0.79,1.19,3.23,1.62,5.43,5.53,7.14,3.60,4.72,4.39,2.33,1.25,0.34,-0.55,-0.68,0.63,2.17,2 --0.92,0.27,1.03,-1.28,1.75,1.24,3.78,4.41,5.20,6.20,5.57,4.89,4.70,1.43,0.70,1.49,0.62,1.04,-0.85,-0.50,0.96,1 -1.65,-0.20,0.55,1.23,-0.42,2.63,1.85,4.75,3.77,5.41,6.12,3.14,3.38,3.69,2.21,0.50,-0.32,-0.75,-1.45,0.32,-0.50,1 --0.49,-1.63,0.17,-1.31,0.40,0.32,2.45,2.50,2.67,6.20,3.57,5.06,3.60,1.33,0.68,-1.53,-1.88,-0.86,0.68,2.09,0.16,1 --0.30,1.03,1.10,4.06,4.56,4.20,5.86,3.90,3.93,2.80,2.43,1.39,1.43,0.44,-1.52,-0.07,0.95,0.25,1.02,-1.23,1.23,1 -0.58,1.80,2.34,4.16,5.18,4.54,4.32,4.19,2.28,3.72,3.15,1.59,0.53,-0.98,-0.93,0.22,-1.38,-1.10,-0.34,-0.50,-0.56,1 -1.45,-0.28,-0.32,1.41,1.65,0.96,1.87,3.56,2.91,5.05,5.31,6.09,3.51,0.76,0.51,-0.37,0.16,-1.39,-0.31,1.46,-0.91,1 -0.24,1.07,-0.34,-1.19,1.03,-1.38,-0.08,0.60,1.34,1.53,1.72,4.19,4.36,3.11,4.22,4.12,4.26,2.63,0.82,2.08,-1.90,2 -1.44,0.79,-0.48,1.33,1.88,4.77,3.65,5.71,4.13,3.73,3.23,2.02,3.00,0.09,2.55,0.87,-1.56,-0.94,1.60,-0.46,1.23,1 --0.75,0.66,1.79,1.09,0.58,4.49,3.94,2.04,3.08,4.46,7.05,3.57,3.62,3.97,1.59,0.77,-0.77,0.33,1.56,-0.91,-0.45,1 -0.08,-2.03,0.26,0.84,0.17,-1.02,-0.06,-0.44,2.32,1.04,3.63,3.77,4.15,1.33,5.02,4.39,3.25,2.96,2.07,-1.23,-0.49,2 -1.36,1.75,-0.50,-0.11,-0.27,1.68,4.51,3.94,3.56,5.59,4.85,4.63,2.48,3.67,-0.64,0.72,1.19,0.67,0.63,-0.66,-0.61,1 --0.85,-0.93,1.64,1.29,0.95,1.28,2.60,1.93,1.07,1.34,3.79,3.01,2.57,2.31,3.68,2.91,2.48,2.18,0.69,0.68,-0.46,0 --1.43,-0.46,0.36,-0.30,0.53,0.65,1.21,0.84,0.07,1.75,0.95,1.73,4.52,4.65,6.27,5.42,4.28,1.12,2.06,-0.16,-0.57,0 -2.72,-0.77,1.78,0.35,-0.22,-0.27,-1.17,2.13,1.82,4.33,4.30,4.87,5.82,3.69,2.40,3.64,1.78,1.90,1.04,0.10,-2.19,2 -1.25,-0.61,0.02,4.15,2.56,3.43,4.69,2.71,3.31,3.58,1.95,2.42,0.66,-0.54,1.56,0.68,0.79,0.57,0.34,1.83,-1.01,1 --2.03,0.88,-0.71,0.05,-1.13,2.01,1.21,0.84,2.54,2.53,4.10,2.82,3.69,4.98,3.55,4.28,4.68,1.47,0.78,1.63,0.80,2 -0.10,0.24,2.92,2.41,3.57,2.99,4.64,4.26,3.46,3.82,3.11,2.81,-0.28,1.42,1.44,0.38,-0.04,2.13,-0.23,0.81,-1.63,0 -0.46,-0.34,1.85,0.97,-0.53,1.64,1.58,2.17,1.78,2.37,3.21,4.64,3.39,3.08,3.12,-0.77,0.50,0.92,1.15,0.42,0.94,2 -0.86,2.46,0.72,0.78,0.80,2.42,2.94,4.44,3.18,3.36,5.31,3.82,2.74,2.76,2.64,0.36,-1.16,0.41,1.10,-0.12,0.28,1 --0.73,1.99,-0.03,2.17,3.47,3.78,4.88,3.01,2.56,2.23,2.89,2.38,-0.19,0.21,1.85,0.58,2.25,1.83,1.40,0.37,-0.48,0 --0.15,-0.87,-0.35,0.46,0.02,0.54,2.70,1.93,1.38,2.96,3.70,4.59,5.63,4.23,4.45,4.24,1.75,1.48,-0.17,1.78,0.54,2 --0.31,1.29,0.40,0.15,0.28,3.39,1.48,2.29,1.22,1.89,3.46,2.17,4.40,4.33,4.13,6.24,2.93,2.87,2.97,0.61,-0.89,0 -0.10,0.07,1.53,0.39,0.77,1.33,0.96,-0.14,-0.24,1.64,2.06,3.32,5.43,4.04,4.99,4.70,3.51,4.91,2.42,0.35,1.20,2 -0.48,1.03,-0.62,1.04,3.63,4.93,5.42,3.26,4.35,3.18,2.04,2.12,1.65,0.24,2.36,1.54,0.05,-0.92,0.29,0.69,0.86,0 --0.62,0.41,-0.93,-1.23,0.61,-0.19,0.77,2.11,1.07,3.36,4.55,3.95,2.89,5.55,4.60,4.71,2.74,2.04,2.32,0.31,0.14,2 -0.33,1.02,0.06,1.95,3.03,2.26,2.85,4.21,3.33,4.92,3.78,2.34,3.14,2.76,1.92,0.67,-0.02,1.05,1.43,-0.40,-1.21,1 --1.45,0.62,-2.01,-1.37,-1.01,1.22,2.60,2.81,3.95,6.31,5.90,5.80,4.68,1.62,2.42,1.53,-0.30,-1.41,-0.16,0.08,-2.26,2 --1.71,1.09,0.18,0.55,1.04,3.45,4.08,3.50,2.38,3.30,6.08,2.71,2.42,-0.12,2.62,-0.26,0.72,0.48,-1.74,-0.64,-1.20,1 --0.89,0.26,1.81,1.18,-0.26,1.63,1.91,1.63,3.36,0.77,2.53,0.41,1.38,3.89,3.66,2.94,0.79,2.38,0.12,0.90,0.19,0 --0.08,0.81,2.95,3.80,4.78,5.53,4.35,4.01,3.34,3.91,2.83,1.54,0.66,0.17,-1.15,-1.70,0.73,-2.22,0.13,1.41,2.93,1 -0.41,1.52,-0.45,-0.26,2.11,2.12,2.88,3.31,3.31,5.40,4.33,2.69,2.13,1.47,2.85,-0.12,0.14,-1.43,0.08,0.63,-0.88,1 -0.55,1.03,0.50,1.19,0.33,0.99,0.54,1.44,2.81,2.96,5.05,3.18,5.15,3.90,5.15,2.49,2.07,3.42,1.39,3.61,0.21,2 -1.52,-1.04,1.49,2.94,1.12,0.46,1.67,2.26,-0.05,1.43,2.42,2.38,4.60,4.84,5.68,3.37,3.60,1.13,0.89,0.98,0.45,0 -0.90,0.98,-0.56,-1.07,2.87,1.88,5.25,1.46,1.59,1.85,1.78,3.66,3.09,2.07,2.53,1.58,2.02,-0.16,1.03,-0.74,-1.24,0 --0.18,0.05,1.53,0.76,3.00,5.35,5.02,5.90,4.88,4.60,4.00,1.76,0.97,0.16,1.21,0.05,-0.56,0.50,-0.27,-0.84,-0.45,1 -0.46,-0.22,-0.54,0.47,0.19,1.00,3.22,5.75,3.79,4.76,5.78,5.73,5.37,2.49,2.46,-0.24,-0.38,0.57,0.46,0.35,-0.32,1 --1.48,-0.10,1.45,2.51,1.65,2.46,3.70,2.77,1.92,4.26,2.74,1.81,2.51,3.96,2.58,2.75,1.90,2.40,1.25,-0.92,0.82,0 --1.45,-0.67,-0.37,0.79,0.66,2.95,3.19,3.12,3.88,3.04,8.48,4.33,3.59,2.57,1.05,0.44,1.38,1.14,-0.26,-0.21,1.07,2 -0.36,-0.35,-0.15,0.45,0.26,0.06,1.96,1.47,1.82,3.12,2.65,4.91,3.32,4.28,2.85,2.29,1.32,1.95,-0.40,-0.76,-0.19,2 -0.69,-1.60,-0.80,0.44,2.22,1.01,0.48,0.18,0.43,2.11,3.26,2.75,1.99,5.62,7.34,2.63,5.50,1.86,-0.33,1.26,0.01,2 -0.09,-1.11,0.74,0.07,2.05,2.36,4.48,4.13,3.77,4.25,3.65,4.54,3.31,1.70,1.83,-1.02,-1.20,-0.22,1.52,-0.67,-0.49,1 -2.60,2.11,1.32,-0.15,2.41,1.94,5.24,5.21,4.21,2.35,3.90,3.50,2.21,1.27,0.39,-1.19,1.08,0.38,-1.29,-1.19,0.01,1 --0.49,2.85,0.03,3.79,2.15,4.53,4.60,3.88,3.71,3.59,2.49,1.41,3.26,2.37,2.41,1.42,-0.02,0.18,-1.02,-0.59,-1.34,1 -1.22,0.61,1.99,-0.76,-1.54,-0.00,1.74,2.19,0.95,0.67,4.59,2.21,4.38,5.40,2.60,3.04,0.99,1.37,2.32,-0.05,0.89,2 --2.16,0.74,1.36,1.92,2.03,2.48,4.14,3.83,0.50,0.85,2.47,2.01,2.87,3.63,3.64,2.54,1.92,1.45,-0.11,1.72,0.39,0 --0.08,0.01,0.99,-1.51,-0.55,0.55,2.66,2.86,5.42,5.75,6.34,5.07,0.38,4.33,1.84,1.20,-0.62,-0.34,-1.51,0.61,-0.55,2 --0.24,1.31,0.03,0.20,0.95,1.08,1.25,0.53,0.38,2.50,1.52,0.51,2.54,4.09,4.87,3.09,1.97,2.13,1.85,0.11,0.81,0 --2.06,1.22,-0.60,1.51,0.96,-0.14,0.13,1.38,0.50,3.29,4.22,3.72,4.01,4.09,3.37,4.74,2.32,2.26,0.25,2.86,0.92,2 --1.75,-1.06,0.92,0.81,0.67,1.95,3.08,3.18,3.49,5.20,5.88,5.16,3.99,1.96,2.53,2.52,-1.37,1.36,0.16,0.16,0.42,1 --0.65,0.53,1.05,1.90,2.94,2.03,3.30,3.39,1.49,2.54,-0.29,0.71,2.27,2.58,1.71,3.46,2.06,0.72,0.98,0.25,0.51,0 --0.38,0.18,2.10,3.37,1.20,2.71,4.10,5.88,4.24,2.74,2.34,0.58,3.61,1.58,0.41,0.94,0.54,-0.58,0.03,-0.77,-0.88,1 --0.64,-1.11,-1.83,-1.06,-1.55,-0.64,0.48,-0.99,-0.08,0.63,0.94,3.02,2.57,4.97,7.66,7.55,5.24,4.51,1.88,1.89,0.68,2 --0.47,1.41,1.36,0.72,1.44,0.37,3.22,4.29,4.90,5.42,6.73,2.97,1.64,1.22,1.93,0.58,1.21,-0.53,-1.38,0.11,0.47,1 --0.40,-1.82,0.80,-0.66,-0.67,0.65,3.80,4.65,2.69,4.92,5.65,4.50,4.13,2.74,1.10,2.27,-0.18,-0.36,-0.31,-0.17,0.96,1 --1.54,-2.91,-0.58,-0.38,0.02,0.06,1.18,1.31,0.20,4.01,2.56,2.40,6.34,3.99,7.17,3.79,2.63,4.10,2.64,2.08,-0.94,2 -0.76,0.01,-0.39,-0.71,1.29,1.65,2.99,2.68,3.52,5.75,7.09,3.59,4.92,3.02,2.56,0.51,1.15,-2.12,0.66,-1.71,0.25,2 --0.61,-2.38,0.07,0.66,1.30,1.65,1.23,-0.13,0.06,0.85,1.15,1.60,3.18,4.99,6.09,3.58,3.31,1.00,3.27,0.04,0.65,0 -1.39,0.91,1.58,2.50,4.35,2.71,6.25,3.90,5.45,2.91,3.31,1.19,0.14,0.49,-0.01,0.63,1.13,0.31,-0.92,1.26,0.28,0 --0.82,-0.56,0.07,-0.32,-0.72,0.56,3.30,3.39,1.99,3.11,4.22,4.27,5.14,1.79,2.72,2.55,1.72,0.07,1.63,-1.23,1.17,2 --0.94,0.31,2.95,2.12,0.43,1.80,4.21,4.50,3.56,4.96,2.69,4.55,1.92,2.34,0.68,1.23,0.67,-0.48,0.54,1.37,0.11,1 --0.83,1.57,1.71,0.23,2.19,1.50,3.51,4.92,4.47,3.53,5.62,2.90,1.85,0.38,0.69,0.49,1.25,-1.21,2.42,-0.43,1.46,1 -0.37,3.88,-0.14,-0.77,-0.98,0.61,-1.46,0.08,0.44,0.58,3.27,4.37,2.64,4.29,5.84,5.47,3.06,2.67,1.98,1.77,0.77,0 -1.50,0.25,0.02,1.12,4.07,4.47,4.17,4.65,3.84,2.57,2.08,2.17,0.34,-0.79,0.12,0.99,-0.05,1.74,2.35,-1.15,-0.36,0 -0.81,-0.58,2.02,3.89,4.02,2.93,4.79,5.41,4.69,2.42,2.60,1.97,-0.48,0.49,0.50,0.37,0.41,-0.72,0.91,0.36,0.27,0 --1.08,-0.09,-1.08,1.24,1.21,0.51,0.36,2.42,2.87,5.27,3.77,2.98,3.47,4.51,4.15,0.03,0.81,1.85,0.80,0.65,-0.45,2 --0.58,3.61,1.57,2.30,3.90,4.25,7.00,2.92,2.51,2.69,2.12,1.46,1.74,-0.61,1.08,-2.22,-1.10,0.25,-2.10,-2.55,-0.27,0 -0.77,0.74,-1.33,-0.21,-1.37,1.08,2.54,0.94,4.41,4.88,4.62,4.38,4.33,4.07,2.21,3.33,3.49,0.75,1.17,-0.93,-0.89,2 -0.44,-0.68,-1.59,0.56,0.82,0.01,0.25,0.82,3.81,1.30,3.31,4.21,3.14,5.01,5.16,4.72,2.14,2.99,1.90,-1.01,1.06,2 -0.64,0.72,0.26,0.89,-0.82,0.77,1.20,1.99,1.92,0.74,2.25,1.16,2.97,2.36,6.12,2.98,2.88,2.41,0.33,2.14,0.12,0 --0.66,-0.81,1.08,0.29,-0.27,-0.18,0.61,-1.14,0.46,0.06,3.13,2.42,4.07,4.64,5.17,4.80,3.61,1.91,0.54,2.92,0.99,0 -1.77,0.56,-0.04,1.28,-0.53,1.39,2.67,1.81,3.45,5.18,4.05,4.50,4.89,3.61,3.47,2.67,3.09,1.43,1.15,-0.50,0.32,2 -0.30,0.53,0.01,1.08,-1.10,0.07,-0.06,0.85,1.37,1.89,2.09,2.16,2.36,4.27,5.99,3.55,2.20,3.96,2.27,0.41,-2.07,2 --0.60,1.43,-0.42,1.97,0.46,2.12,3.44,0.83,2.71,1.75,4.38,4.01,0.88,2.47,5.23,3.45,4.59,2.07,-0.56,0.68,-0.61,0 --0.60,0.88,0.62,1.42,3.69,4.20,1.01,2.00,1.38,2.13,2.38,3.21,2.42,3.72,2.74,3.09,0.83,-0.34,-0.29,1.14,2.75,0 -0.86,2.08,-0.12,1.27,0.88,-0.39,0.25,1.35,-0.30,2.16,2.72,3.62,4.08,5.69,5.19,3.77,3.81,5.26,2.30,0.07,0.50,0 --0.95,0.39,2.68,2.62,1.32,3.31,4.34,5.10,4.48,2.56,2.97,2.43,2.73,1.08,-0.20,-2.49,-0.67,1.29,0.53,1.34,1.02,1 --0.97,-0.03,2.13,4.77,4.47,5.64,5.49,4.26,3.30,2.99,3.97,1.43,-0.56,-0.00,-0.25,0.89,-0.28,-0.67,1.08,-1.56,0.90,1 -0.21,0.12,-0.09,0.20,-0.36,1.60,0.58,0.72,2.91,1.66,3.95,3.19,4.67,5.47,4.06,3.58,4.22,1.58,1.17,1.86,0.34,2 --0.04,0.73,-0.11,0.01,-1.01,0.84,1.97,3.08,2.68,2.41,5.47,6.01,2.47,1.97,2.34,3.59,-0.65,-0.16,-0.38,1.12,0.55,1 -0.75,1.40,1.88,1.47,0.74,3.79,3.72,4.12,3.99,2.49,1.62,3.81,-0.27,-0.44,0.50,1.44,0.59,-0.43,-1.08,0.11,-1.67,1 --2.40,1.17,0.26,-0.15,1.17,0.55,3.58,3.98,4.82,3.85,2.43,4.25,1.57,1.63,1.34,-1.20,-0.01,0.72,0.38,-0.25,-0.93,1 -1.71,-0.36,0.34,0.42,-0.59,1.06,-0.15,-0.01,1.60,4.63,3.72,3.23,2.48,3.39,3.79,4.74,1.43,2.24,2.63,1.66,0.31,2 -0.94,0.88,2.40,3.44,2.91,5.15,5.26,5.70,5.08,2.55,1.56,2.00,1.48,0.90,0.11,1.39,2.65,-0.97,0.14,-0.14,0.47,0 --1.29,1.22,1.83,-1.58,-0.19,0.90,1.69,2.73,2.95,3.53,5.45,6.18,2.79,4.04,1.64,1.46,1.49,-0.69,1.07,0.41,-0.84,2 -0.19,0.82,1.09,0.78,2.84,2.81,4.76,1.87,3.71,1.39,2.38,2.57,0.78,1.44,4.30,3.24,3.69,1.03,-1.01,-1.72,-0.01,0 --2.63,-0.99,0.92,-0.63,0.43,-0.67,-1.40,-0.26,0.89,2.27,1.60,3.80,4.88,5.13,4.72,7.15,3.37,0.90,1.77,-0.22,-1.40,2 --0.29,1.55,1.74,4.40,2.50,3.88,3.76,4.59,1.96,2.40,1.07,4.30,0.90,0.03,-0.45,0.30,0.43,-0.05,3.56,1.13,-1.12,0 -0.72,0.40,0.10,0.18,-0.52,1.27,1.89,1.92,2.75,1.91,5.37,1.86,3.45,6.09,5.84,3.05,1.96,2.24,0.30,-0.44,-0.25,2 -0.72,0.16,-1.22,1.15,1.14,2.88,-0.37,1.55,-0.96,0.94,3.43,3.77,4.69,6.46,6.04,4.60,3.39,2.97,2.48,2.09,-0.09,2 -1.35,-0.49,-0.92,0.57,-0.54,1.42,1.19,-1.69,0.14,0.11,2.22,1.92,3.15,2.74,6.69,3.99,5.30,-0.32,0.74,3.03,-1.78,0 -0.04,0.53,1.02,0.74,2.82,2.21,3.25,2.53,2.76,0.07,2.72,3.45,1.79,3.42,1.05,1.90,1.13,0.35,0.94,-1.96,0.42,0 --0.39,1.35,1.19,2.55,2.92,4.59,3.46,2.99,4.91,2.49,1.76,2.50,1.55,-0.37,0.92,-0.17,2.05,2.57,0.78,0.16,-1.59,0 -1.80,-3.25,-0.07,0.63,-1.02,0.42,0.59,1.23,1.88,3.62,5.72,4.90,5.72,2.94,1.99,3.33,1.40,0.88,2.59,2.16,0.22,2 --0.90,0.30,-0.44,0.42,0.22,1.76,1.10,1.60,6.00,6.14,8.00,5.54,2.22,3.82,2.66,0.15,-2.29,0.64,-1.60,-0.26,0.45,1 -0.32,0.61,1.86,2.30,2.91,2.04,2.05,2.36,0.51,1.70,2.76,2.66,2.83,2.30,2.42,3.95,1.82,2.74,1.19,1.24,1.52,0 --2.12,0.72,3.06,1.49,2.08,2.91,1.14,2.19,2.02,2.29,2.90,1.31,2.08,3.63,4.92,3.52,3.02,2.68,-0.60,-0.16,0.38,0 -0.80,0.51,1.67,1.79,1.08,0.44,3.61,1.53,0.73,2.27,2.57,2.20,3.52,2.92,2.80,3.32,2.85,0.13,1.24,0.08,0.86,0 -0.01,1.09,1.52,2.06,2.80,3.06,4.50,3.65,2.49,1.28,1.12,1.89,2.36,-0.70,-0.68,0.77,0.04,1.95,-0.14,-0.37,0.82,0 --0.25,-0.35,1.46,-2.44,0.60,0.33,1.31,4.02,0.56,3.96,3.73,3.21,3.59,4.11,3.70,2.37,2.53,0.98,0.62,2.02,-0.55,2 -0.35,-1.56,0.55,0.66,-0.61,1.26,1.94,2.10,2.58,5.19,7.58,4.11,3.14,3.55,3.17,0.83,0.05,0.99,-0.67,-1.57,0.80,2 -0.44,-0.24,0.66,0.69,0.81,3.74,2.72,3.40,4.43,3.61,3.65,3.41,3.36,3.53,3.11,-0.40,0.87,0.62,0.56,-0.88,-0.15,1 --0.57,0.79,-0.10,2.50,2.13,2.63,2.43,2.94,4.07,5.15,3.97,1.12,1.88,0.62,1.78,-0.22,0.32,-0.84,-0.13,-0.14,0.24,1 --1.09,1.10,-0.32,-1.63,1.75,1.53,0.84,3.19,4.28,4.99,6.25,4.32,2.16,3.50,2.38,1.62,0.48,-0.99,-0.38,-0.24,0.71,2 -0.44,0.39,1.04,0.90,1.42,3.33,2.89,5.62,2.69,4.98,5.84,4.00,1.12,3.47,0.46,-0.32,-0.09,0.52,-0.74,-0.09,-0.12,1 --0.60,-1.24,1.69,-1.45,-1.64,0.19,0.44,2.47,4.42,5.04,5.40,4.32,5.08,2.16,3.05,2.11,1.28,0.50,0.76,0.20,1.41,2 --2.06,-0.64,0.72,-0.80,-0.65,-0.34,2.08,0.69,1.08,3.18,3.40,2.84,3.27,2.55,3.55,4.59,1.30,1.02,1.04,0.18,-0.56,2 -1.75,0.73,-1.72,0.72,0.00,-0.12,3.16,1.28,4.28,3.37,4.96,4.24,4.84,3.47,2.20,2.94,1.04,1.46,0.54,0.25,0.31,2 -0.67,1.30,1.94,0.81,1.76,3.34,3.44,5.92,1.23,2.85,1.70,1.30,-0.23,1.56,1.52,0.86,1.03,1.55,1.26,0.49,0.48,0 --0.90,1.06,1.29,0.78,1.93,2.43,3.80,1.18,-0.19,2.63,1.40,2.76,2.71,4.26,4.33,3.89,2.29,2.54,1.59,-0.23,-0.65,0 --1.90,-0.37,-0.37,1.52,0.07,2.54,1.05,1.40,0.15,1.23,3.41,3.75,4.38,4.61,5.39,1.75,2.71,3.96,0.65,-0.45,0.68,2 --1.21,-0.76,-0.79,1.72,-0.25,1.74,0.07,0.90,0.01,2.34,1.18,4.27,4.09,5.88,5.33,3.76,4.72,3.06,2.23,1.40,-0.51,0 --0.71,-0.29,2.43,3.52,4.58,5.52,5.92,5.05,3.33,0.49,1.03,0.50,0.84,0.60,-0.76,0.36,1.52,0.74,0.03,0.76,0.44,0 -1.09,-0.32,0.01,0.78,0.50,3.28,4.71,4.14,4.00,4.83,3.59,3.18,3.37,1.52,0.53,1.50,0.16,-0.25,-1.55,-0.32,0.74,1 -0.45,-0.34,-0.14,0.20,-0.57,0.16,0.98,-0.21,1.62,4.11,4.90,5.40,4.01,5.67,3.33,4.96,3.74,0.97,1.70,1.35,0.56,2 --1.47,-0.40,-0.45,1.38,2.14,1.77,1.12,3.25,0.35,0.09,1.46,3.50,3.02,2.92,3.10,3.98,1.98,0.24,-0.37,0.36,0.76,0 -0.34,0.03,1.37,-1.51,0.37,2.06,1.40,2.51,5.36,4.24,8.02,4.06,4.60,3.10,1.42,2.48,0.90,0.29,1.45,1.58,-0.05,1 --0.46,0.14,-0.09,0.84,0.36,2.19,3.18,3.79,5.84,4.96,5.65,4.54,5.00,4.95,2.28,2.16,-0.10,0.67,0.62,0.76,1.84,1 -0.41,0.07,-1.62,-2.33,-0.90,1.53,0.92,2.72,3.83,4.85,2.24,4.24,5.59,3.58,2.06,1.60,2.62,1.22,1.48,2.05,0.35,2 -0.38,-0.21,-1.59,0.75,-0.53,0.63,1.19,2.49,4.31,4.84,5.55,4.23,2.50,2.61,1.04,1.83,0.54,0.89,-0.13,-0.11,-0.90,2 --1.01,-1.36,1.06,-0.35,-0.64,-0.40,-0.02,1.00,-0.39,-0.32,3.10,2.51,3.05,6.00,6.41,3.28,4.31,3.12,1.23,0.15,-0.42,2 -0.02,1.12,1.34,1.27,0.07,0.02,0.16,1.32,1.61,2.49,1.60,3.08,3.26,4.58,5.06,5.20,4.89,2.22,2.21,2.27,-1.17,0 -0.01,0.61,0.97,1.02,1.23,1.13,2.64,3.56,3.43,5.17,6.69,4.27,4.67,4.54,4.23,1.65,2.36,-2.91,-0.53,0.24,1.14,2 -1.11,0.69,2.24,-0.56,2.04,3.34,6.43,4.28,2.82,6.01,4.93,1.57,2.75,-0.22,1.64,0.80,-0.42,0.21,0.35,0.07,1.79,1 --0.31,-0.17,3.73,2.55,3.73,4.18,4.53,3.00,3.61,3.07,2.32,1.15,3.06,-0.03,0.56,2.02,1.41,0.93,-0.99,0.83,0.77,0 -0.85,1.45,1.59,-0.25,1.44,2.93,1.30,3.42,3.19,5.55,6.73,3.61,2.03,3.89,0.63,-0.93,-2.07,1.82,-0.12,0.38,-0.10,1 -0.70,0.67,0.59,-0.59,2.34,0.64,1.99,1.71,1.96,1.72,3.38,1.68,1.14,3.96,2.70,1.85,4.21,1.57,-0.69,-0.39,-1.17,0 -0.75,0.13,0.18,1.08,-0.43,0.89,3.95,4.28,6.17,4.27,4.33,3.09,1.82,1.28,0.57,1.45,-0.73,1.09,0.88,-2.51,-1.19,1 --0.84,1.25,0.23,1.54,1.64,1.61,5.05,4.11,5.47,2.80,3.25,2.33,1.39,0.24,2.10,0.91,-0.93,-1.02,1.16,0.44,0.04,1 -0.60,-1.36,0.05,0.94,0.19,2.84,-1.34,-0.13,0.60,0.17,3.37,3.08,2.01,3.30,5.60,4.48,3.07,2.98,-0.04,-0.31,-0.10,0 --1.18,2.21,0.89,1.93,0.21,3.93,2.95,2.76,4.69,5.50,3.64,2.75,2.70,2.55,0.94,0.54,0.03,0.25,-0.47,0.85,1.33,1 -1.54,0.08,-0.65,-0.50,-0.34,0.42,1.41,0.97,0.69,3.69,3.68,3.84,4.64,4.45,4.97,2.05,3.15,1.89,1.75,0.51,1.22,2 --1.43,0.85,0.55,3.07,1.46,2.14,4.80,5.04,3.13,4.19,4.75,2.49,1.13,-0.52,1.50,1.26,1.29,0.91,-1.54,1.30,-0.36,1 --0.99,-0.92,0.20,2.17,1.12,3.74,3.21,2.82,1.12,0.98,0.77,2.42,3.88,2.57,3.95,1.98,0.87,2.60,-0.26,0.43,-0.79,0 -1.61,0.54,0.29,-1.76,0.29,2.47,2.02,4.61,3.99,5.12,5.62,5.13,4.67,3.95,2.14,0.11,0.76,0.27,-1.65,1.49,-1.55,2 -1.05,-2.28,1.21,0.02,-0.33,-0.06,1.72,5.27,3.66,4.36,4.24,4.80,2.66,2.38,2.32,-1.51,-0.52,0.80,0.34,2.91,0.12,1 -0.75,-0.05,-1.11,-1.25,0.80,-0.14,-1.14,-1.90,0.91,0.81,0.87,4.69,3.01,3.24,5.56,3.70,5.33,2.39,1.94,0.47,-1.73,2 --0.78,0.96,0.14,1.26,0.26,4.33,0.74,4.05,4.58,3.10,4.39,4.44,3.40,4.07,1.88,1.21,0.68,-0.73,-0.66,0.55,-0.45,1 --0.37,1.00,0.30,0.74,1.49,2.65,4.01,4.79,4.14,3.45,4.81,5.27,4.39,0.53,0.44,-0.27,0.28,0.98,-0.45,-0.18,1.01,1 -1.51,1.69,-0.40,2.10,0.80,2.59,0.95,2.68,1.48,2.82,1.83,3.34,2.20,2.15,4.93,2.78,3.67,1.47,1.02,-0.19,0.06,0 -0.13,0.28,1.00,1.49,2.74,4.39,3.19,-0.09,-1.14,1.26,3.71,2.26,2.35,3.56,3.48,3.38,2.07,2.24,1.73,1.46,-0.48,0 --1.45,0.49,0.18,-0.36,0.99,0.90,2.41,2.15,-0.87,1.54,3.69,1.42,2.47,4.22,4.25,6.29,4.32,3.13,1.80,-0.52,-0.50,0 --0.11,0.63,1.87,1.03,1.39,4.39,4.47,2.54,4.31,4.36,3.77,2.69,1.96,0.00,-0.07,-1.84,-1.10,0.62,-0.29,1.83,0.92,1 --0.33,0.94,-1.13,-1.42,-0.27,0.24,0.63,0.79,3.90,4.19,5.40,5.65,4.92,4.62,4.44,2.88,1.96,0.04,-0.04,0.47,0.21,2 --1.37,0.97,0.73,-0.81,0.26,0.95,1.84,1.88,4.72,1.99,6.63,4.09,3.29,0.91,2.64,0.54,-1.29,0.50,1.20,1.69,-1.24,1 -1.10,-0.64,-0.12,2.00,1.15,2.22,2.78,2.52,1.46,0.12,4.05,3.37,4.44,4.54,5.88,5.79,2.47,2.82,3.08,0.32,1.92,0 -0.76,-1.83,-0.64,1.21,-0.21,-0.82,1.09,0.65,-1.81,1.56,1.16,4.73,5.08,5.86,4.90,5.82,4.37,5.01,2.55,1.95,-1.65,0 -0.05,0.61,0.36,0.64,-0.09,0.49,-1.17,0.53,-0.44,1.14,1.98,3.03,3.14,4.69,7.32,6.35,5.53,1.59,1.61,0.57,-0.62,2 -1.86,-0.84,1.30,0.36,-0.44,0.23,2.67,2.68,3.65,4.79,6.49,5.96,2.85,3.65,2.65,1.51,-0.81,-0.07,1.73,-0.11,-1.14,2 --1.92,-1.88,-0.90,0.41,0.96,-1.02,2.20,1.13,1.12,1.78,2.65,2.66,3.15,5.11,6.36,3.38,3.01,3.41,-0.56,0.84,0.69,2 -0.20,3.38,0.98,0.82,2.31,3.81,3.52,3.85,3.86,3.33,5.63,4.05,1.19,2.98,1.20,0.85,-1.07,0.34,-2.59,0.71,0.45,1 --1.47,0.60,1.39,1.71,0.22,0.63,-0.52,2.13,2.61,2.50,3.66,3.55,4.42,4.11,5.52,1.18,2.23,1.35,2.10,2.18,-0.39,2 --0.91,-0.13,-0.33,-0.28,2.77,4.11,4.44,3.25,1.30,1.33,1.30,2.49,1.39,1.86,0.89,1.05,2.96,1.52,0.29,0.25,0.70,0 --1.32,-0.61,1.66,-1.63,1.00,1.44,3.17,4.30,5.29,4.64,8.20,3.35,5.48,1.97,1.75,0.03,0.47,-0.19,0.61,-0.08,-0.15,1 --1.67,-0.05,1.53,-1.21,-0.82,1.06,2.30,1.70,4.36,5.55,4.62,5.64,3.62,4.31,1.91,1.86,0.76,0.67,-0.47,0.14,0.17,2 -0.57,0.20,-0.67,2.07,0.94,2.90,4.17,3.41,3.64,6.12,2.89,3.91,1.61,1.54,0.36,-0.23,0.69,-0.02,-1.10,-0.33,-0.09,1 --0.52,0.59,1.84,3.04,3.70,4.79,4.39,5.07,4.24,4.11,1.87,0.19,1.19,-0.82,-0.30,-0.31,0.88,1.37,-0.90,2.45,0.15,1 --0.27,-1.32,-1.21,0.46,-0.25,-2.41,0.19,-0.75,-0.71,0.68,1.85,2.64,5.16,3.26,6.32,5.07,3.46,3.50,3.38,1.61,-0.56,0 --2.77,1.64,0.65,2.81,3.49,5.33,4.35,3.98,4.12,3.32,2.54,1.60,1.12,0.26,0.94,-0.48,0.76,0.49,2.04,1.28,-1.74,1 --0.01,0.59,2.35,2.97,2.74,6.08,4.83,5.96,2.91,2.02,2.97,1.89,0.59,1.75,-0.94,0.32,-0.19,0.31,0.85,-0.36,0.52,0 -1.13,-1.17,1.60,-1.41,-0.04,2.02,1.25,5.25,2.87,4.84,6.23,6.42,7.50,3.07,1.42,1.46,0.61,0.63,-0.48,0.91,-0.70,1 -0.34,2.54,0.51,0.79,1.55,2.55,4.06,3.38,4.85,6.07,5.25,4.02,2.20,2.39,2.53,0.92,0.11,-0.04,-0.34,-0.80,2.29,1 --0.75,0.68,1.19,1.06,2.39,3.12,2.54,2.25,3.98,4.79,5.66,2.90,2.70,1.15,0.91,-0.05,0.25,1.43,-1.85,-1.08,-0.53,1 -0.29,-0.01,0.33,-0.69,2.45,0.43,-0.18,1.10,3.58,6.02,4.64,2.85,2.76,3.92,1.75,2.06,0.15,1.87,0.19,2.05,-0.50,2 -0.53,0.04,0.67,1.92,0.12,2.00,0.10,0.25,2.33,4.60,4.97,4.52,4.09,3.93,2.89,1.80,3.52,1.12,0.66,0.40,-0.09,2 -1.01,-0.65,-0.17,0.10,1.35,0.31,0.78,0.50,1.52,2.07,4.83,3.23,4.57,3.98,5.30,1.98,1.71,2.37,-0.57,0.23,-0.11,2 -2.49,-1.17,-0.14,2.61,2.61,6.65,3.99,3.74,4.59,3.02,2.95,1.49,1.38,-0.22,-0.74,-0.45,-1.13,0.36,-0.69,1.34,0.36,0 -1.16,0.12,-0.23,-1.99,-0.76,0.79,0.97,1.81,3.39,4.04,6.07,4.71,3.19,3.06,2.11,0.90,-0.32,-0.81,1.50,-0.48,-0.51,2 -0.04,0.32,2.82,3.26,2.59,2.56,4.36,2.73,0.18,2.38,2.64,2.80,1.83,2.26,1.56,1.68,4.33,2.23,1.73,-0.59,-0.68,0 -0.32,1.01,0.45,0.12,0.04,0.10,1.95,2.26,3.89,3.90,3.99,3.63,4.02,3.55,2.21,0.62,0.36,1.22,-0.41,1.71,1.26,2 -1.17,0.04,0.55,-0.56,-1.73,0.62,1.15,1.60,1.21,5.08,3.29,4.96,3.70,0.85,3.14,3.17,1.23,0.97,2.29,-0.47,-1.33,2 --0.05,0.93,-0.07,1.99,2.73,2.05,1.72,1.70,3.25,2.04,0.30,1.72,1.75,2.10,2.38,2.20,1.79,-0.35,0.62,1.30,-1.13,0 -0.60,-0.66,2.61,3.91,4.18,4.49,6.24,3.46,2.82,4.31,2.91,2.95,-1.49,-0.21,-0.47,-0.09,0.35,-0.87,-1.20,0.52,-0.14,0 --0.92,0.65,0.87,0.79,0.94,0.86,1.54,1.30,0.37,0.01,1.91,1.56,3.39,3.21,3.02,3.39,3.24,4.06,1.25,1.08,-1.13,0 --0.05,-0.54,0.71,2.07,-0.31,2.57,1.59,3.08,5.35,6.45,6.12,3.72,5.62,4.28,0.34,0.67,1.47,-1.95,1.54,-0.29,-0.01,1 --0.19,-0.14,0.41,-0.92,-0.41,0.83,0.68,2.03,5.86,4.23,5.21,4.79,2.49,5.10,2.81,0.93,-0.24,1.60,2.56,-0.01,-1.15,2 -0.54,-1.13,0.21,-0.09,-0.70,-0.20,0.73,-0.87,-0.16,3.05,1.87,1.44,3.80,4.61,7.38,5.61,3.01,3.22,2.58,1.23,2.64,2 --1.16,0.74,0.65,2.57,1.86,3.94,4.38,3.06,2.27,1.12,2.44,2.12,1.39,2.56,0.98,1.31,1.64,1.31,-1.07,1.40,0.39,0 --1.32,2.20,0.83,2.19,-0.98,2.25,3.54,2.55,4.89,3.93,3.97,4.62,1.33,3.00,-1.32,-1.89,-0.70,0.13,-0.65,0.35,0.48,1 --0.86,-0.05,2.04,2.76,2.77,6.34,3.80,3.99,3.79,2.53,2.72,3.16,0.32,2.41,1.15,0.49,0.09,0.67,0.18,0.35,-1.80,0 --0.17,-1.69,3.22,3.64,4.45,3.38,5.41,5.19,3.03,3.96,2.23,1.22,-0.24,-0.84,-0.13,-1.63,-1.62,0.84,0.76,-1.45,-0.24,1 --0.01,-0.47,-0.79,0.47,0.40,0.78,1.23,1.86,0.13,0.34,3.43,2.45,3.36,3.87,5.19,5.04,4.50,2.18,2.58,-1.05,-0.34,0 -2.84,-0.97,2.71,0.95,2.51,2.84,5.92,4.70,3.96,2.75,1.43,2.38,0.13,1.25,-0.41,1.85,1.22,-0.65,-0.53,0.57,0.95,0 -1.98,0.56,-1.15,0.54,0.28,-0.54,2.98,2.32,1.66,3.93,5.06,5.27,1.68,2.79,2.55,0.63,0.81,-0.39,-1.72,0.43,-0.71,2 -0.78,1.39,1.00,4.50,3.86,3.03,3.63,5.36,3.51,3.70,3.02,2.55,2.50,1.64,0.68,1.90,1.63,-0.61,0.18,-0.54,-0.74,1 -1.91,-0.64,-0.25,-0.58,0.06,0.54,0.72,-0.63,0.85,1.12,2.30,3.70,4.32,3.98,5.39,4.85,2.87,2.76,1.09,0.53,0.03,0 --0.32,-0.14,-0.26,0.77,1.59,2.82,1.90,2.09,1.52,3.31,2.54,3.00,2.78,4.49,2.23,2.06,3.91,3.67,2.39,0.36,0.08,0 --1.22,1.27,2.39,3.70,4.71,5.34,5.99,5.31,3.12,3.75,2.39,0.97,-0.03,-0.83,1.20,0.23,0.36,-0.19,-0.99,0.61,1.59,1 --0.32,1.26,1.57,0.59,1.02,4.03,5.22,3.62,4.89,4.81,4.33,1.94,1.56,1.76,1.14,0.02,-0.75,0.21,-1.09,-0.70,1.71,1 -0.67,0.43,-0.07,0.56,2.59,0.50,-0.35,1.56,0.55,3.36,3.35,2.95,2.04,3.55,3.47,3.65,2.89,3.87,3.09,1.62,0.44,0 -0.05,0.93,-0.93,-0.36,-1.28,1.21,1.09,0.24,0.32,0.65,2.86,3.82,5.15,2.55,5.05,4.27,1.55,3.61,0.40,1.21,0.88,0 --2.23,0.23,0.56,-0.73,0.21,0.95,2.55,3.13,2.83,4.11,6.09,3.70,2.22,1.13,0.22,-1.78,0.17,-0.12,1.10,-1.64,-1.53,1 --0.58,0.91,0.91,-0.32,1.41,4.08,1.44,3.44,1.71,2.58,2.75,-0.11,2.44,3.05,0.96,2.97,0.47,1.38,1.93,0.90,-1.46,0 --1.72,-0.77,2.50,3.46,3.32,4.63,6.06,5.32,2.45,3.44,3.30,1.99,0.83,1.70,-0.07,-0.63,0.16,-0.36,0.30,0.08,-0.17,1 --0.26,-0.51,1.87,-0.25,0.64,0.43,-0.24,0.26,1.63,4.54,4.61,4.62,5.07,2.98,3.78,2.12,3.85,1.57,1.93,1.46,-0.01,2 --0.64,-0.87,1.51,-0.84,0.43,2.82,1.77,2.75,3.54,3.60,5.90,3.89,4.92,2.85,3.83,-0.02,2.21,-0.41,1.59,-1.82,2.10,2 --0.12,-0.26,-0.32,0.73,-0.33,2.76,4.80,3.22,4.31,4.00,3.29,4.53,2.90,-0.03,0.49,0.10,0.40,1.42,-0.32,-0.47,0.58,1 -0.51,0.79,0.12,3.28,2.23,3.24,5.01,3.74,2.39,1.86,1.46,1.65,2.71,1.89,2.10,2.39,0.75,0.81,1.09,-0.99,0.23,0 --1.05,1.05,-1.80,1.24,0.97,-0.42,0.09,1.93,2.23,3.22,3.00,3.14,0.82,3.40,2.87,0.94,3.01,-0.40,2.92,-0.58,-0.82,2 --1.41,-1.22,0.16,-0.62,1.22,0.69,2.34,2.90,3.97,5.44,5.17,5.06,3.82,2.12,1.60,1.57,0.35,1.85,-0.66,-0.13,1.59,1 --0.82,-0.89,1.61,-0.00,1.62,1.42,1.69,0.78,1.55,1.23,1.74,1.29,2.64,3.29,5.53,4.54,4.28,2.58,2.49,0.43,0.66,0 -1.07,-0.94,-0.34,0.39,-0.62,1.49,2.85,2.77,3.53,5.80,5.25,4.54,4.74,3.35,1.38,1.58,-0.60,0.48,1.65,2.42,-0.30,2 -0.38,0.54,0.54,0.15,-0.56,0.39,1.61,0.79,1.49,2.28,2.59,1.53,5.11,5.57,5.18,2.15,2.35,1.56,1.74,1.02,-0.17,2 -1.65,-1.79,2.31,0.83,-0.34,2.55,1.52,1.59,4.62,5.12,2.62,4.11,3.76,2.62,0.80,0.18,0.48,0.35,0.48,-0.98,-0.62,1 -0.33,0.87,-0.49,1.23,0.12,0.06,1.22,0.75,0.07,3.48,1.91,2.54,4.51,4.31,6.06,4.14,2.87,3.90,2.25,3.21,-0.02,0 --0.88,-0.52,0.11,1.96,3.06,4.80,5.88,3.51,3.40,4.19,2.85,2.41,1.33,0.41,1.51,0.09,-0.91,-1.26,-0.71,1.44,0.64,1 -0.50,-0.53,0.48,0.95,0.86,-0.30,1.60,1.84,2.26,4.81,3.87,3.87,4.37,4.52,5.21,1.75,2.37,2.59,1.20,1.03,1.21,2 -0.12,-0.72,-1.17,1.56,2.62,1.49,4.84,3.33,4.78,4.18,4.25,2.58,1.67,2.05,1.19,1.47,-0.14,-0.42,-0.95,-0.95,-1.17,1 --0.81,1.27,2.44,-0.44,0.69,3.04,5.08,1.43,2.99,1.29,1.73,1.30,-0.00,1.10,3.09,1.70,1.99,-0.12,1.38,-0.33,-0.87,0 -0.22,-0.87,0.91,0.86,3.90,1.04,2.38,2.59,2.74,3.30,3.00,-0.22,-1.05,2.01,3.44,2.79,3.28,2.01,1.35,-0.38,-2.13,0 -1.51,1.82,-0.19,2.63,3.21,2.57,3.04,6.16,3.13,3.04,3.08,0.95,-0.11,0.80,1.51,-0.81,0.38,-0.08,0.45,0.20,0.35,1 -0.59,0.00,1.07,1.60,1.93,2.79,2.41,4.73,4.18,5.04,3.94,2.57,3.34,1.40,0.13,2.13,0.64,1.00,1.66,-1.40,-1.57,1 -0.17,0.88,1.69,-0.40,-0.85,-0.80,2.44,3.11,1.85,3.29,5.48,4.52,4.46,3.69,2.13,1.11,0.70,1.98,0.44,1.09,-0.56,2 -1.15,0.71,-0.19,1.07,0.21,2.34,1.97,1.89,3.97,6.25,5.60,5.43,4.89,3.95,1.67,0.95,0.33,0.22,3.61,0.03,-1.03,2 --1.16,0.69,0.72,-1.80,1.56,1.75,2.31,1.01,1.29,1.54,2.83,2.68,2.73,4.46,4.70,4.19,3.22,3.35,1.18,-0.18,-0.82,0 -0.76,0.62,0.72,0.12,1.33,2.03,1.54,-0.51,-0.38,1.84,2.72,2.29,2.29,2.21,3.70,3.38,3.57,2.73,1.46,0.97,-1.52,0 -0.32,0.79,-0.49,1.17,-0.33,1.60,3.05,4.67,4.65,6.05,5.52,3.73,4.70,3.37,0.85,0.12,-0.57,0.79,-0.51,-1.34,0.10,2 --0.19,-0.28,1.17,1.49,2.72,1.17,4.51,1.84,3.87,0.41,2.32,1.18,0.19,1.40,1.33,3.18,0.96,2.12,0.60,-0.32,0.67,0 -0.76,-1.93,-0.10,-0.28,-0.86,1.30,2.79,0.18,0.14,-0.95,1.92,4.29,2.40,5.57,5.09,4.96,3.70,2.02,1.27,1.63,-1.01,0 -0.52,0.83,1.96,-0.07,1.92,5.03,5.20,4.61,5.51,4.45,4.20,3.91,2.36,1.08,2.04,-0.80,0.68,0.41,-0.75,-0.63,-0.58,1 --1.47,-0.15,0.95,0.97,-1.77,0.24,1.84,0.78,4.21,5.34,5.93,5.54,4.00,5.10,3.28,1.94,-0.86,-1.18,-1.19,-2.06,-0.66,2 --0.72,2.37,3.09,2.49,2.73,4.64,5.87,4.11,3.43,4.21,3.56,2.05,0.24,-0.31,0.73,2.01,0.06,-0.05,-1.08,0.26,-1.81,0 -1.18,0.43,-0.47,0.86,2.38,2.58,3.13,2.22,2.77,4.43,4.41,2.68,2.49,0.38,2.66,0.46,-0.25,-0.62,-0.27,1.19,-0.58,1 -0.36,0.94,0.61,0.35,-0.54,-0.59,3.15,1.90,2.26,4.00,5.92,4.19,4.52,0.74,2.04,3.76,-0.64,0.12,0.26,0.05,-0.86,2 --0.26,0.70,0.28,-0.51,2.53,3.28,4.19,1.21,0.97,1.17,1.29,2.51,0.73,3.08,1.30,3.07,2.84,2.55,1.09,0.15,-0.08,0 --0.45,-1.82,-2.45,0.43,-2.36,-0.22,1.81,0.29,-0.52,0.93,1.40,3.02,2.15,3.60,5.39,2.94,3.51,1.30,1.49,1.48,-0.94,2 -0.42,1.19,-0.27,1.47,2.93,3.74,2.64,3.37,1.91,2.57,1.27,-0.02,1.99,1.53,4.39,0.23,1.10,1.73,-0.66,-0.67,-2.36,0 --0.56,-0.57,-0.22,-1.78,0.14,-0.62,0.86,0.27,2.68,3.48,1.51,3.65,3.61,3.25,1.94,2.79,2.08,0.20,2.01,1.64,-0.17,2 --0.07,-0.56,0.84,2.88,0.65,3.97,3.27,3.84,2.57,1.01,2.81,2.85,1.10,2.39,1.44,3.66,0.91,0.26,1.71,0.17,-0.08,0 --1.76,-0.71,0.13,0.05,0.77,-0.25,-0.05,-0.24,1.15,0.86,2.95,3.83,3.27,4.90,5.88,3.66,3.85,3.12,3.07,1.57,1.21,2 --1.29,-1.40,-4.05,0.57,1.11,-1.14,0.36,0.52,0.21,0.92,1.48,2.46,5.54,6.04,6.18,3.63,3.69,2.78,0.76,2.18,-1.26,0 --0.21,0.02,-0.27,-1.64,-0.19,0.59,-2.20,-0.11,0.34,0.85,3.11,4.61,3.29,6.57,6.31,5.63,4.18,1.97,2.12,1.30,1.84,2 -1.10,1.45,-0.43,0.55,-0.13,-0.63,2.64,1.61,2.49,4.76,7.05,3.99,4.42,5.61,3.94,0.07,1.79,0.95,1.66,0.26,-0.17,2 --1.14,0.85,1.73,0.23,2.38,2.54,3.02,1.45,0.63,2.46,1.89,4.21,2.30,1.08,3.84,3.48,3.18,1.22,0.72,0.13,1.16,0 --0.88,1.63,-0.45,3.00,4.77,4.67,5.35,3.52,2.73,2.82,1.69,-0.27,-0.22,-0.09,0.95,0.96,-0.91,1.19,-0.04,0.98,-0.70,0 --0.58,1.02,1.72,2.20,1.23,2.65,4.07,3.30,0.89,-0.39,1.80,2.64,2.80,0.74,2.93,2.42,2.30,2.46,-0.77,1.08,1.08,0 -1.04,1.69,0.56,2.06,4.39,5.22,4.78,6.32,3.90,4.13,1.63,2.86,-0.07,-0.40,-0.26,0.25,0.77,-0.46,-1.64,-1.39,0.26,0 --1.08,1.30,1.85,4.28,4.60,3.34,6.16,6.05,3.62,3.01,1.51,0.77,1.30,-1.64,0.04,-0.89,-1.96,-0.81,-0.16,-0.08,2.48,1 -0.39,-1.35,-0.31,-1.39,1.79,1.25,0.08,-0.53,-0.95,0.90,1.42,2.55,4.62,4.24,5.33,3.97,2.16,2.08,1.00,0.49,0.20,0 --1.33,-0.54,0.93,1.96,3.66,4.19,4.36,5.53,2.81,2.57,4.70,1.09,0.52,0.23,0.53,0.16,-0.36,-0.20,-1.02,-0.11,-0.41,1 --0.19,0.17,-0.14,-2.01,0.42,0.14,0.76,1.53,2.98,2.26,3.03,3.73,2.05,3.24,4.93,3.92,3.17,0.07,-0.33,0.44,0.75,2 --1.59,1.01,2.07,2.58,4.33,4.95,4.86,3.31,3.55,2.30,2.00,1.41,0.34,-0.70,1.12,0.02,-1.80,-1.71,0.68,-0.24,0.32,1 --1.48,0.34,1.24,0.65,1.95,3.68,2.89,2.40,5.69,5.14,6.76,5.31,3.39,2.52,1.63,0.12,-0.05,-0.26,0.28,1.41,1.23,1 --0.48,1.25,1.14,0.50,1.86,1.69,2.50,4.17,1.49,2.03,2.24,1.97,3.24,3.14,4.41,-0.08,-0.06,2.10,1.52,-0.30,-0.24,0 --1.11,0.12,2.38,1.25,1.20,0.84,4.49,1.28,1.64,2.23,1.69,1.88,2.92,1.19,1.14,2.79,1.90,0.28,0.26,3.05,-0.07,0 -0.41,0.71,1.01,1.45,5.23,5.02,5.30,4.39,0.57,3.71,3.13,0.96,0.71,-0.23,-1.29,1.85,0.15,-0.56,0.86,-0.83,-0.52,1 --1.14,0.90,-0.21,3.19,2.84,2.02,5.50,2.43,4.24,2.15,2.03,2.23,2.20,1.77,0.82,-1.52,-1.75,1.25,1.77,-1.53,-0.28,1 -2.08,1.17,0.79,0.26,1.44,1.72,1.51,0.65,4.39,5.85,5.37,2.74,4.01,0.98,1.83,-0.70,-1.82,0.49,1.03,-1.01,0.31,1 --1.30,0.76,-0.74,-0.37,0.07,0.53,2.47,2.38,5.05,5.55,6.98,4.05,5.03,2.32,5.45,2.55,-0.66,-0.88,0.06,-0.22,0.50,2 -0.22,-0.10,-0.14,-0.32,-1.06,1.41,0.42,2.96,3.36,4.03,3.28,5.24,3.42,6.19,3.81,2.01,0.19,-0.18,-1.41,0.05,1.44,2 --2.01,0.27,0.70,0.06,-0.49,1.08,2.77,2.39,1.64,3.77,6.12,5.63,3.31,5.80,0.32,3.99,0.96,1.49,1.35,1.92,0.83,2 -0.58,0.22,1.62,2.08,0.05,1.54,1.83,1.86,1.66,-0.35,0.23,2.18,3.35,3.25,3.11,2.21,2.20,0.88,0.29,-0.64,-0.14,0 --1.41,0.16,0.49,-0.27,-1.45,-1.58,-0.53,2.60,0.00,1.94,2.74,2.25,4.29,3.57,5.19,5.68,3.74,2.71,0.04,0.66,-0.12,2 -0.14,-1.56,0.80,1.75,4.02,2.65,7.00,5.59,5.60,4.53,1.47,-1.45,0.09,0.33,1.14,1.56,-1.05,-0.52,-0.85,-1.45,0.43,1 -0.34,1.26,-0.89,-1.54,1.42,1.20,-0.97,0.91,-1.12,1.39,2.50,3.38,2.64,3.99,6.12,4.86,3.30,2.95,1.76,0.58,0.74,0 -0.77,1.09,0.05,-1.28,0.32,-0.88,-2.77,0.51,0.77,0.62,3.19,3.77,4.30,6.44,7.19,4.65,2.95,2.55,3.28,2.05,0.42,2 -1.36,1.54,2.60,4.71,4.93,4.49,6.52,4.73,4.10,4.69,3.32,1.99,0.37,-0.80,-2.02,-1.16,0.12,-1.11,0.15,1.57,-1.19,0 -0.52,0.68,-0.42,0.46,0.65,1.34,0.94,2.43,1.75,1.58,2.56,2.47,2.58,2.55,5.71,1.90,2.70,2.12,4.11,-0.16,1.56,0 -0.09,0.51,-1.80,-0.71,-0.01,1.03,-0.86,2.03,2.06,1.94,1.65,3.95,5.26,4.18,5.65,3.51,2.19,2.44,2.03,0.35,-0.51,2 -0.56,-0.66,1.19,-0.15,3.04,0.88,2.48,4.21,1.25,-0.55,1.94,3.20,1.67,2.87,4.03,1.99,1.53,0.12,1.34,-0.81,-0.59,0 --1.07,0.14,0.99,1.17,3.43,5.31,4.64,7.15,3.50,3.70,2.28,2.90,1.41,-0.84,-1.79,-0.84,-0.37,-0.97,0.74,-0.12,0.70,1 -0.10,2.14,2.46,-1.27,-2.37,-0.23,-0.41,3.24,1.91,4.37,5.49,5.82,3.63,3.04,3.49,1.44,0.11,1.63,1.63,0.82,-0.09,2 -0.01,-0.29,3.90,1.63,3.70,4.48,6.66,4.81,5.55,2.73,1.83,2.75,-1.31,-2.11,1.01,1.82,-1.33,-2.14,-0.85,0.27,-1.06,0 -1.64,1.93,0.84,3.27,5.91,4.65,6.44,6.29,1.77,3.34,2.20,-0.38,-2.20,0.20,-0.92,1.20,-1.38,-0.54,1.59,-1.26,-0.07,1 --0.73,0.29,0.32,3.84,0.84,3.33,5.01,5.65,3.69,2.50,3.62,2.25,-0.18,1.18,2.79,1.66,1.66,0.36,0.42,1.86,-0.20,0 --0.03,-0.68,1.87,1.81,1.12,2.42,1.44,1.18,0.64,1.01,3.12,2.50,2.08,2.91,2.86,2.54,2.51,1.20,2.70,-0.50,0.93,0 -0.02,-0.86,-0.31,-0.00,-1.24,-0.55,-0.49,-0.95,1.77,2.84,2.93,3.73,4.05,3.42,4.33,4.30,2.38,1.73,2.78,0.37,1.06,2 --2.36,-1.03,-1.06,0.58,-0.12,0.14,0.43,-0.70,2.57,1.75,4.02,3.02,3.73,4.00,3.71,2.57,3.38,3.27,1.09,0.12,1.40,2 --0.88,-0.65,1.41,2.56,2.90,3.37,4.77,5.52,3.27,4.78,4.13,1.36,1.43,-1.27,-0.67,-0.40,-0.84,-0.35,0.64,1.00,0.34,1 --0.24,-0.17,0.70,-0.09,-1.41,0.95,2.12,3.11,2.37,3.97,5.41,4.29,5.85,3.95,4.16,3.70,1.53,2.10,0.18,1.41,0.24,2 -1.19,0.99,1.94,1.00,4.11,5.27,4.54,2.25,3.49,2.25,1.50,0.40,0.28,-0.13,0.16,1.58,0.42,1.17,-0.39,-0.01,0.32,1 -0.03,1.44,0.08,2.17,-0.46,-0.62,2.01,-0.67,3.27,-0.17,2.05,2.93,2.11,4.64,2.94,3.03,2.93,1.97,0.36,-0.42,-0.98,0 -1.30,2.37,1.71,2.99,1.85,2.22,5.40,4.48,4.14,4.87,2.44,1.53,0.07,1.94,0.48,2.10,0.74,1.33,0.01,-1.19,-1.90,1 --0.98,0.63,3.07,2.94,2.69,2.75,3.23,3.15,3.08,0.20,1.15,3.35,2.12,1.91,3.13,1.66,1.27,0.85,1.95,-0.36,-0.30,0 -0.64,1.22,1.29,-1.58,1.51,-0.22,2.67,4.65,3.66,3.94,6.06,4.55,3.88,4.22,2.83,1.69,0.77,-1.39,1.41,0.71,-0.25,1 -0.78,1.16,1.82,2.34,2.45,3.98,4.52,4.65,3.94,2.29,3.10,2.77,0.54,1.72,0.17,-0.86,0.23,2.00,2.09,1.05,-0.71,1 --1.20,-0.85,0.54,0.96,-0.42,0.91,2.16,2.52,3.16,5.42,3.85,5.01,4.74,3.47,2.38,1.07,2.14,0.43,0.70,0.10,-0.31,2 -0.50,0.93,1.93,0.63,2.13,1.65,4.22,4.03,4.19,1.33,0.91,4.12,0.57,-0.18,2.91,2.17,0.27,1.79,0.32,0.83,1.06,0 --1.02,-1.29,-1.24,-1.96,0.60,0.18,1.28,4.06,3.24,3.23,5.02,7.40,3.94,4.27,2.44,1.75,-0.66,-0.38,0.14,0.24,-0.20,2 --0.88,-0.40,0.83,2.62,0.99,2.94,5.41,2.60,3.57,1.07,2.86,1.75,0.73,2.23,3.11,4.37,0.19,1.62,-0.56,-0.11,-0.50,0 --0.54,0.51,1.51,0.72,3.07,3.74,4.04,1.09,5.29,3.87,4.62,2.39,1.08,1.52,0.78,0.91,0.69,0.42,0.12,0.93,1.34,1 --0.17,-0.02,-2.10,2.57,0.25,1.89,2.68,3.11,4.33,3.66,5.19,3.28,1.30,2.17,2.08,0.20,-1.88,-0.35,-0.77,1.21,-1.04,1 --0.41,-0.85,1.44,1.67,1.86,1.51,5.19,3.28,4.10,3.32,3.54,4.96,1.75,0.56,0.48,-0.72,-0.15,-3.03,1.74,-1.08,0.74,1 -3.94,1.10,-0.34,1.33,1.92,3.09,2.20,3.98,3.84,5.08,6.92,3.82,4.05,3.01,0.90,0.44,0.30,0.56,-0.74,1.10,-0.02,1 --0.48,-1.94,0.63,1.35,0.01,-1.43,0.74,-0.77,1.65,1.55,2.05,2.43,3.90,6.71,5.30,4.12,4.43,2.75,1.06,0.34,-0.61,0 -0.70,-0.65,0.11,0.65,0.19,-0.83,1.08,0.14,-1.04,0.06,2.08,2.92,4.00,6.48,5.50,4.80,4.54,2.88,0.42,1.09,0.48,2 --0.58,2.15,1.08,1.28,2.92,2.63,5.82,3.78,3.51,3.54,3.80,3.55,2.02,0.62,1.59,0.09,0.57,-0.31,1.11,-0.53,-1.48,1 -1.48,-0.77,0.93,-0.41,1.43,0.75,1.34,1.40,0.09,1.87,2.98,2.20,3.25,3.45,4.87,3.25,2.76,3.57,0.79,0.84,0.36,0 --0.73,1.59,0.28,1.63,3.14,1.86,3.65,3.16,1.24,2.81,1.00,3.48,2.34,2.04,4.79,2.64,2.60,2.00,-0.29,1.46,1.42,0 --0.76,0.25,1.77,-2.19,2.01,-1.01,1.08,1.11,0.97,2.60,4.54,3.00,4.31,3.36,4.03,2.92,1.22,1.47,0.38,3.04,0.87,2 -2.42,-0.87,-0.91,1.37,-0.92,1.31,1.96,0.79,3.56,4.07,5.10,3.68,3.22,5.14,3.29,1.93,0.37,1.40,0.79,0.05,0.95,2 --1.11,1.59,1.12,0.39,0.75,2.08,3.89,3.73,0.78,3.14,0.11,0.66,1.06,3.42,2.25,2.57,1.76,1.98,-0.51,1.26,-0.75,0 --1.66,0.77,2.03,0.18,2.01,0.48,0.80,0.59,-0.21,0.59,3.23,2.59,3.36,2.05,3.73,5.56,3.90,2.80,0.64,1.34,-0.34,0 --0.82,1.75,1.02,0.48,0.95,1.57,2.41,0.07,-0.76,1.78,1.78,3.64,4.44,2.88,5.54,6.13,4.96,1.27,3.06,1.50,-0.59,0 -2.60,-1.64,1.68,0.80,3.11,4.50,3.89,4.56,0.28,6.00,2.51,4.16,0.27,1.95,1.15,0.57,0.61,-0.94,-0.61,-1.37,0.27,1 -0.92,0.24,1.74,0.53,1.12,2.15,3.51,5.17,3.34,4.61,2.43,3.38,0.22,1.28,0.10,-0.18,-1.49,-0.05,0.78,1.11,-1.04,1 -0.77,-0.16,0.80,1.23,-0.58,1.14,1.63,1.51,1.27,1.23,1.71,3.75,2.26,4.37,4.56,4.45,2.83,2.58,2.10,0.88,-1.74,2 -0.96,-0.12,-1.59,2.23,1.82,-0.71,1.52,0.78,2.25,2.78,3.39,3.77,2.72,4.48,3.65,2.56,2.04,2.51,1.99,0.03,-2.68,2 --1.51,0.19,0.75,-1.50,-0.74,-0.35,1.45,-0.44,0.24,0.40,2.48,3.57,4.09,4.59,5.58,3.70,3.03,1.85,1.78,3.74,0.20,2 --0.63,0.32,2.21,1.86,2.79,1.89,1.72,2.49,2.63,2.86,4.68,2.80,1.02,1.23,0.05,2.92,0.43,-1.68,-0.46,-0.51,0.15,1 -0.43,-0.10,-1.18,0.06,-0.96,-0.59,-1.02,1.06,0.82,0.15,2.61,0.83,3.18,5.95,6.44,2.70,3.94,2.42,1.41,1.91,-0.98,2 -0.54,-0.63,2.71,1.63,0.90,1.07,1.66,3.20,3.86,4.86,3.65,4.23,1.51,2.67,0.59,-0.20,0.88,0.34,1.64,0.89,-1.37,1 -1.18,0.18,1.30,3.11,4.68,2.14,5.61,2.71,2.70,2.08,3.39,1.21,0.96,1.97,0.52,2.27,0.67,-0.99,0.30,-0.25,0.13,0 --0.36,-0.84,-1.47,-0.21,-0.86,0.64,0.40,2.54,3.74,4.36,5.15,4.17,4.22,3.67,3.60,0.67,2.51,0.15,-1.61,1.22,0.12,2 -1.32,0.17,-0.17,-1.98,-0.87,-0.05,1.69,-0.02,0.51,1.25,2.33,1.69,3.40,3.19,6.26,4.34,5.48,1.91,0.35,2.23,-0.06,0 --0.27,1.28,0.92,0.18,-1.40,-0.30,0.86,-0.28,1.10,-0.04,0.98,4.27,3.55,6.38,3.05,4.59,4.38,1.59,-0.58,-1.28,0.07,0 -0.39,1.11,0.74,-1.41,-0.64,-0.29,-0.47,2.16,-0.43,0.36,0.92,3.11,3.96,5.11,3.23,4.14,1.81,2.25,2.16,-0.85,-1.29,2 -0.07,2.02,0.15,1.43,-0.41,0.70,2.40,0.55,0.48,2.77,1.64,2.32,4.32,3.79,5.64,5.26,3.45,3.97,1.36,0.41,0.91,0 -0.55,1.21,0.06,0.10,2.71,0.42,3.64,4.16,0.56,3.01,1.90,1.36,1.65,4.09,3.83,2.81,2.04,2.09,-1.26,2.70,-1.12,0 --1.05,-0.52,0.03,2.85,-0.26,-1.37,0.73,1.02,1.63,-0.61,1.47,3.93,2.91,5.24,4.72,5.18,6.06,3.41,3.83,1.52,0.50,2 --0.47,2.01,0.68,2.55,4.41,3.25,5.07,4.84,6.27,3.78,3.65,3.54,0.99,0.96,-1.49,0.49,-0.09,-0.40,1.67,-0.97,0.89,1 --1.29,-0.05,0.97,2.61,2.93,2.12,0.83,3.17,1.45,1.45,1.45,1.58,2.11,3.73,2.16,2.23,1.68,0.03,1.14,-0.01,-1.23,0 --1.72,-1.85,0.54,-0.78,-2.60,0.08,1.28,1.07,1.44,1.84,1.92,4.76,2.84,4.50,5.22,4.17,3.57,3.75,1.21,-0.46,0.35,2 -0.76,-0.43,-0.25,-0.12,-0.09,1.90,1.80,2.52,3.63,3.90,4.97,4.02,3.84,2.44,2.09,0.79,1.38,-0.52,1.63,-0.20,1.17,1 --0.16,0.25,0.39,0.39,0.46,0.44,1.36,0.57,1.94,2.67,5.38,4.52,2.41,5.39,3.49,2.55,0.70,0.68,0.63,-0.01,-0.32,2 -1.87,-0.24,0.01,0.15,-0.21,0.66,0.48,3.44,4.38,6.04,5.57,3.59,4.83,2.11,1.34,1.96,1.55,0.83,1.55,0.37,0.21,2 -1.31,0.22,-0.12,-1.36,-0.51,0.86,1.15,1.47,-1.51,1.63,1.14,4.62,3.82,4.69,8.17,4.84,4.96,2.82,1.87,1.77,-1.04,0 --0.73,1.01,2.11,2.41,2.89,4.43,4.87,7.09,4.14,2.91,3.33,2.13,1.72,1.82,1.57,-0.43,-0.18,-2.19,0.27,-0.30,-1.58,1 --0.51,0.37,-0.34,-0.30,-1.47,-1.51,0.19,1.76,-0.68,2.29,2.33,4.11,2.88,2.46,4.47,2.58,3.54,2.02,1.60,-0.62,-0.17,2 -0.50,0.07,1.21,-0.24,0.29,-0.47,0.58,-1.05,0.40,1.28,1.92,4.37,4.42,4.19,5.07,3.93,4.84,1.86,1.35,1.27,1.19,2 --0.05,-0.02,-1.18,-0.76,-1.09,0.12,-0.82,1.20,0.63,0.77,3.03,1.75,4.39,5.02,5.47,5.09,3.34,2.69,1.60,0.39,-2.69,0 -0.86,0.58,1.49,1.57,3.84,4.33,3.80,3.74,3.97,5.54,4.55,3.36,4.04,2.49,0.25,1.67,-1.76,-0.88,-0.42,1.49,-0.88,1 --0.07,-0.17,-2.37,3.94,2.34,2.21,4.09,4.07,2.64,3.00,3.72,1.74,1.63,1.69,2.65,-0.88,0.06,1.33,0.88,-1.01,2.12,1 -0.70,-0.08,0.86,1.58,2.43,2.61,3.45,3.24,2.88,4.08,0.38,0.91,2.96,0.88,3.20,1.89,2.95,0.56,1.03,0.46,-1.36,0 --2.95,-0.08,-0.54,0.63,0.83,0.81,2.03,2.63,2.41,1.86,1.71,1.71,2.64,3.94,2.98,2.83,1.67,-0.02,2.18,2.36,0.81,0 --0.27,1.45,1.34,1.48,3.03,4.05,4.23,3.63,2.98,4.70,3.26,2.43,1.82,1.26,1.20,0.23,-0.24,0.75,-0.75,0.18,-1.13,1 --0.97,-0.17,0.90,-0.85,-0.13,0.44,0.79,-0.27,1.17,0.77,3.18,3.46,2.86,3.38,5.49,6.11,3.38,1.58,1.14,0.94,-0.71,2 --0.59,1.16,2.92,2.76,5.39,6.43,4.82,3.30,3.09,1.32,3.02,1.97,-0.35,-0.27,-0.58,-0.98,-0.43,-0.01,0.48,-1.66,-0.57,0 -0.46,0.48,3.25,1.82,5.57,3.18,3.48,4.12,4.36,1.64,4.14,1.39,1.09,1.77,0.67,-0.70,-1.04,-0.53,-0.15,-1.97,1.03,1 -1.29,0.25,1.02,-0.91,2.87,3.09,3.99,3.20,3.35,0.34,2.61,2.47,0.34,0.20,2.06,2.49,1.04,0.08,0.94,0.08,0.11,0 -0.85,0.95,1.13,0.46,2.86,4.18,5.39,4.48,2.03,3.15,1.53,2.63,0.21,-0.26,1.76,2.35,1.44,-1.13,-0.20,-1.06,0.49,0 -0.72,0.74,0.61,-0.17,-0.17,0.56,3.60,3.94,4.89,2.73,6.81,2.23,1.04,3.07,0.09,-0.75,1.30,1.72,-0.41,-0.04,2.03,1 -0.05,1.22,1.03,3.34,2.51,3.02,5.65,5.04,4.23,2.90,2.95,2.36,0.05,1.61,0.87,0.61,1.07,-0.76,-0.30,-0.87,-0.02,1 --1.26,1.90,-0.53,0.49,-0.57,1.14,-0.36,0.69,0.19,1.11,3.21,2.14,3.69,5.83,4.63,3.71,3.76,2.35,0.72,0.91,1.06,0 --1.23,0.50,0.64,1.10,3.85,4.00,6.53,4.91,3.56,4.37,2.74,1.45,-0.05,-1.51,0.75,0.37,-0.18,-0.73,-0.58,0.26,-0.39,1 --0.62,1.69,2.42,1.76,1.77,-1.12,-1.06,1.55,1.14,1.00,0.88,3.25,2.28,5.14,5.34,5.04,4.23,2.77,2.80,0.86,-1.61,2 --0.20,0.34,3.86,-0.05,4.67,1.62,4.08,4.44,3.92,5.55,2.47,2.49,2.81,-0.08,1.62,2.11,0.94,0.82,-0.35,0.65,1.00,1 --1.45,-0.82,0.35,-0.19,0.84,1.78,1.07,0.82,0.41,0.68,0.90,2.76,2.74,3.37,5.17,3.53,3.78,2.08,3.99,-1.14,0.39,0 -2.25,1.17,0.09,1.88,3.17,3.31,5.30,3.91,4.10,2.33,2.14,2.66,-0.26,0.40,-0.67,-0.88,-0.59,-0.86,-1.07,0.14,1.13,0 -0.10,-0.28,-1.93,0.39,-1.10,0.54,0.93,0.59,0.07,3.54,2.76,4.47,2.15,6.65,5.93,4.24,2.67,2.90,2.26,0.59,-0.02,2 --0.41,0.50,1.07,2.01,3.76,5.30,4.85,5.20,4.31,2.87,2.92,2.28,1.78,0.97,-0.09,-0.07,-0.17,-0.85,1.36,0.00,0.22,1 -0.13,1.05,-1.57,-1.20,0.60,-0.79,0.63,0.46,2.03,2.83,2.01,3.84,3.14,3.55,4.50,4.31,1.54,1.59,4.07,0.09,0.09,2 -0.52,0.12,-1.23,-1.03,-0.85,-0.37,-0.31,-1.20,0.34,1.47,1.87,2.18,5.16,4.59,5.80,4.90,3.94,1.91,0.78,1.56,0.13,2 --0.01,0.63,1.77,0.49,3.73,0.69,3.45,3.48,2.69,-0.52,0.49,1.55,1.98,1.78,4.14,4.03,1.74,2.39,1.92,-1.44,0.28,0 -1.17,1.29,1.52,0.16,-0.88,2.08,0.61,0.52,1.42,1.17,2.06,2.53,5.77,4.93,5.42,3.85,3.62,3.92,1.37,-0.60,0.08,0 --0.58,0.39,0.83,2.17,1.51,1.98,3.67,1.22,1.09,2.17,3.13,1.12,-0.26,3.74,1.60,2.12,2.89,2.51,1.60,0.52,1.34,0 --0.05,-0.35,0.07,1.72,-0.57,0.76,0.08,-0.64,1.16,3.40,3.12,5.01,4.02,3.75,4.04,0.79,1.74,1.31,0.49,0.44,1.10,2 -0.37,0.47,2.49,3.15,4.87,4.47,5.71,4.38,3.57,2.90,2.89,0.08,-0.18,-0.05,1.00,0.41,-0.64,-0.76,-1.34,1.03,1.87,1 --0.85,0.91,-0.67,-0.79,-0.95,1.35,0.38,0.26,1.72,3.60,3.75,2.91,4.38,6.22,7.09,5.52,2.59,2.70,3.15,2.46,-0.70,2 -0.58,-0.49,-0.80,0.98,2.54,-0.03,0.51,-1.32,-1.87,1.11,2.92,2.43,4.07,2.80,4.57,3.29,1.82,3.29,3.07,0.37,0.24,2 --1.00,-0.14,0.72,0.18,0.92,1.89,1.02,0.37,0.65,1.22,3.42,2.24,4.26,2.17,4.52,3.67,1.26,1.96,1.33,0.94,0.22,2 -0.66,-2.32,0.50,0.17,-0.97,-0.05,-0.52,-0.22,-0.27,1.57,2.29,3.84,4.12,4.68,5.11,6.36,3.28,1.28,3.89,0.69,0.68,2 -0.00,-0.83,0.71,0.72,0.51,1.38,1.22,2.09,3.31,4.49,5.03,5.80,4.00,2.34,0.74,1.59,1.64,-0.59,-0.60,0.92,0.53,1 --0.89,-0.87,-0.01,1.04,1.02,-0.22,3.14,1.12,0.33,1.95,2.02,1.40,1.83,3.17,4.96,3.99,4.18,3.54,1.62,0.90,1.02,0 -1.22,2.39,0.71,3.77,2.90,3.23,4.58,4.82,2.58,2.67,1.68,2.08,0.39,0.97,0.96,1.26,-2.24,-0.38,1.37,-0.32,-1.04,1 --0.32,1.06,0.78,0.69,0.88,-0.75,0.33,-1.51,0.27,2.01,1.91,3.49,3.28,4.43,4.46,5.01,1.83,2.98,2.21,0.39,0.68,2 --1.90,0.57,0.12,-1.00,1.33,-0.54,-0.25,0.31,0.90,1.34,1.11,2.72,3.58,3.33,7.06,6.81,2.97,4.27,2.52,1.54,-0.72,2 -0.84,0.87,1.66,2.13,1.28,3.61,5.42,2.88,4.38,3.78,3.12,2.36,0.85,2.18,-1.24,-1.61,1.64,1.01,-0.41,-0.28,0.44,1 -0.20,0.23,-0.20,0.20,-0.96,0.56,3.16,3.65,4.22,4.86,7.57,4.63,1.61,3.31,3.36,0.05,1.82,-1.24,-1.32,0.24,-0.64,1 -0.39,-0.92,-1.01,0.27,-0.69,2.08,2.23,0.85,4.65,4.83,5.82,5.40,3.31,2.15,3.54,-0.22,1.05,-0.08,-1.93,0.76,0.69,2 -0.95,1.90,3.91,1.59,2.09,2.37,4.42,3.93,2.25,2.14,3.89,2.00,1.40,1.82,2.27,3.54,1.76,0.85,1.08,-0.35,0.28,0 --0.58,0.31,0.38,0.58,1.97,2.87,0.44,0.51,1.52,3.83,5.23,2.74,5.65,4.08,3.39,1.99,0.81,1.80,0.96,1.11,1.36,2 --1.16,-2.96,0.22,2.18,-1.63,-0.11,0.26,0.32,-0.76,1.89,1.95,1.15,3.56,3.98,6.40,4.51,3.71,2.04,3.36,2.74,-0.18,2 -0.96,-1.02,-0.89,2.49,0.15,0.46,2.39,1.68,1.14,1.34,2.32,1.38,1.61,3.09,4.22,4.56,4.90,1.23,1.62,-0.44,-0.06,0 --0.82,-1.19,0.49,-0.40,1.33,-0.57,3.28,1.78,5.30,4.47,5.68,4.24,4.15,3.54,-0.09,1.24,2.68,0.61,-0.22,0.38,0.34,2 --2.30,0.62,2.50,1.63,2.40,2.97,3.28,3.51,4.01,1.18,0.91,3.42,-1.16,2.20,1.55,-0.30,1.56,1.01,-0.17,-1.06,-1.10,0 --2.95,1.03,0.78,2.65,3.26,3.80,4.35,5.38,3.50,5.61,5.22,2.12,1.02,1.34,0.92,1.13,0.33,-1.03,0.76,-0.79,-0.07,1 -1.95,-0.54,0.23,0.53,1.61,0.30,-0.12,-0.74,0.17,-0.36,3.17,2.41,3.96,4.62,5.69,3.70,4.49,-0.07,0.24,0.87,0.97,2 --1.02,1.23,-0.02,1.56,1.80,2.14,4.06,5.42,5.42,5.44,4.77,3.99,1.92,3.18,0.23,1.46,0.20,-0.81,0.05,0.47,-1.43,1 --0.33,-1.36,0.89,0.97,3.85,2.07,3.83,3.59,0.19,1.53,2.03,1.13,1.21,1.73,2.39,2.41,2.57,1.35,-0.50,-0.77,0.47,0 --0.27,-0.16,1.66,2.77,1.93,3.53,6.04,5.48,3.10,2.77,2.30,1.77,1.94,-0.02,-0.18,0.40,1.19,0.21,1.00,1.45,0.20,1 --0.21,-0.52,0.17,1.06,-0.89,0.01,-0.32,2.30,2.72,5.66,3.86,5.05,6.80,2.59,2.88,1.81,-0.42,2.36,0.12,-0.11,0.56,2 -0.36,-1.43,1.68,3.31,2.08,2.16,5.77,3.35,4.30,3.05,3.66,0.54,2.36,0.73,-0.17,-1.77,0.78,-1.51,-0.49,0.92,-0.48,1 -0.77,-1.32,1.88,1.65,0.27,1.65,1.76,1.72,5.35,4.19,4.66,4.86,6.15,3.15,1.29,-0.10,0.93,-1.75,1.36,0.04,1.73,2 --0.40,3.00,1.00,0.80,1.88,2.16,2.01,2.90,5.02,3.62,3.54,4.84,3.22,1.13,-1.21,0.95,-0.98,-0.10,0.15,-0.03,-1.35,1 --0.63,-0.67,2.58,1.38,1.46,0.71,0.96,2.08,3.23,2.18,1.02,3.23,3.50,1.25,2.72,4.08,3.43,1.57,2.87,0.84,2.12,0 --1.53,1.27,0.01,1.85,0.60,2.16,2.13,3.29,4.57,5.11,7.39,3.71,2.74,2.57,1.25,-0.45,-0.25,1.06,-0.67,0.25,-0.07,1 --0.12,-1.31,0.57,0.96,-0.48,0.50,0.69,0.84,0.20,1.67,5.25,2.34,3.86,5.25,7.41,4.46,3.27,3.29,1.97,0.38,-0.29,2 --1.24,0.54,-0.52,-0.11,-0.17,-0.09,3.08,2.37,4.88,4.69,6.89,5.56,2.74,1.96,2.92,1.49,0.77,1.03,0.32,-0.86,-0.07,1 -0.36,0.39,1.19,0.03,1.95,2.12,2.65,0.88,1.03,0.70,2.83,2.27,2.36,4.55,4.30,3.07,2.60,1.06,-0.83,0.93,2.34,0 -0.71,-0.66,0.72,-0.13,1.20,1.87,2.40,2.18,5.24,4.99,6.26,3.61,4.01,1.48,3.74,0.96,-2.16,-0.17,0.07,-0.68,-0.18,1 --0.53,0.12,2.56,1.95,2.40,2.82,4.84,3.31,3.26,1.97,2.93,0.98,1.38,2.62,0.12,0.15,1.55,0.86,2.34,-1.21,1.65,0 --0.67,0.37,0.76,2.19,2.33,4.85,4.61,6.18,3.13,5.67,3.27,0.45,1.27,1.54,1.82,1.00,-1.42,-0.07,-1.27,1.80,0.59,1 -1.15,1.64,1.05,0.92,2.69,5.00,3.69,1.82,3.67,3.41,3.72,2.82,1.78,0.90,0.14,0.16,-0.32,-0.17,0.91,2.07,-0.87,1 -1.08,2.06,-1.55,-0.80,0.18,-0.28,0.29,-0.28,1.44,4.40,3.18,4.48,1.88,4.04,1.94,3.14,2.39,0.86,-0.03,2.92,0.20,2 -1.78,1.93,-0.56,0.14,-0.27,-0.72,0.26,-0.56,2.31,1.05,3.35,3.01,5.96,2.28,4.66,5.31,4.00,-0.20,1.03,-0.75,1.18,2 -0.32,0.29,1.06,-0.96,1.14,2.18,1.89,3.36,4.55,2.28,5.34,4.34,3.18,2.50,2.40,-0.17,0.81,-1.77,-0.11,0.20,0.45,1 --0.34,1.37,0.49,-0.61,0.02,1.23,1.42,2.19,3.82,1.55,4.54,3.46,2.90,5.55,3.51,2.69,3.33,1.84,0.64,1.03,-0.78,2 --0.31,-0.10,-1.18,1.56,2.20,0.52,0.72,2.66,1.44,3.41,4.94,3.50,4.85,4.02,4.03,3.60,3.88,1.03,1.06,2.90,0.35,2 --0.09,1.57,1.46,3.24,0.43,0.80,1.41,1.04,1.15,3.11,-0.27,2.07,3.40,4.62,4.72,3.73,1.17,2.61,2.14,0.66,-0.29,0 -0.76,-0.32,0.30,-0.23,0.48,0.91,4.56,2.50,2.08,4.07,3.12,4.48,4.14,2.57,0.72,1.78,0.62,-1.04,0.90,-2.03,-0.37,1 --0.33,-0.52,0.19,2.20,2.16,3.52,3.61,3.98,3.02,2.41,2.95,1.40,2.48,1.97,2.53,3.05,1.83,2.05,2.54,1.53,-1.81,0 -1.05,1.31,0.37,-2.27,0.05,2.16,3.22,2.92,1.24,4.04,6.15,5.89,3.46,3.12,2.23,1.76,0.23,0.18,1.40,-0.93,-0.47,2 --0.27,1.72,2.26,0.69,0.53,-0.73,-1.23,1.29,2.09,3.28,3.57,5.44,4.19,4.46,3.04,3.17,2.72,2.35,1.43,0.45,1.47,2 -1.28,0.98,-0.79,0.96,0.78,2.04,2.77,5.42,2.28,3.09,1.06,0.69,2.77,1.78,2.79,2.84,3.36,3.17,0.55,1.20,-2.11,0 --0.33,0.23,3.15,2.59,5.00,5.74,4.77,5.46,3.15,4.58,1.02,1.38,0.45,-0.19,1.43,0.14,1.57,1.56,-0.12,1.86,-0.14,0 --0.24,0.17,1.28,4.37,3.72,2.10,2.53,4.43,5.32,1.68,2.98,2.16,-0.70,2.29,-0.55,0.09,-0.33,-1.12,0.33,-0.30,-0.46,1 --0.93,1.11,3.14,3.46,3.86,4.34,6.06,3.79,3.98,3.54,-0.15,3.23,0.68,1.57,1.35,-0.24,0.30,-0.95,-0.81,-0.91,-2.77,0 -1.71,0.67,2.47,2.64,2.48,4.83,7.36,6.32,4.46,2.23,3.56,3.91,1.07,1.04,1.35,-0.17,0.37,-0.49,1.53,0.09,1.04,1 --0.50,1.22,1.06,3.63,3.42,5.47,5.71,6.34,3.55,3.91,2.36,1.11,-0.06,-0.74,0.62,-1.34,-0.18,-0.66,-0.25,0.50,0.34,0 -0.06,0.66,0.86,2.15,3.72,4.05,4.36,4.07,4.89,3.94,-0.34,1.69,0.68,-0.23,-1.91,-0.68,-1.79,-1.64,-1.46,0.87,-0.38,1 --0.53,-1.64,-0.44,-0.82,1.23,1.41,0.43,0.21,0.29,2.54,1.33,2.28,2.59,3.23,8.40,5.22,4.89,2.14,0.83,2.03,1.24,0 -2.22,1.59,-0.28,1.36,-0.09,0.86,1.19,1.20,0.05,-0.59,3.51,2.98,3.63,4.19,5.27,3.59,4.00,2.82,1.57,1.13,-1.56,0 --0.43,0.89,0.59,1.36,0.07,2.64,-0.22,0.85,4.02,3.36,4.13,4.49,4.39,2.94,3.41,1.18,2.09,0.63,1.75,1.83,-2.39,2 --0.09,1.24,0.08,1.14,1.62,3.72,3.41,3.65,3.02,3.96,3.08,2.25,0.38,1.29,0.08,-0.48,0.02,1.77,-1.95,-0.60,0.28,1 --1.78,-0.42,1.68,-0.59,-0.67,-0.15,0.01,0.00,0.95,1.92,1.72,3.09,5.31,4.99,4.89,4.20,4.63,1.73,1.25,2.00,-0.34,0 --0.59,1.20,-0.24,0.77,0.23,1.58,0.07,-0.14,2.56,1.57,2.87,3.14,2.26,4.42,4.84,3.56,3.44,1.78,1.25,2.43,-0.40,2 --0.30,0.22,1.58,0.40,-0.07,1.47,2.99,4.04,1.96,5.39,5.67,3.53,3.94,1.80,1.96,0.95,-0.89,-1.39,0.11,-1.00,3.10,1 -0.18,-1.19,0.62,1.87,4.05,1.83,3.35,3.64,2.01,3.13,0.48,2.71,1.81,3.08,2.13,3.79,0.89,1.16,0.58,0.97,0.15,0 -0.36,0.37,0.40,-0.02,3.17,3.54,3.59,3.57,3.57,3.81,3.46,1.58,2.59,1.67,-0.70,0.14,-1.59,0.21,-1.36,0.50,0.81,1 --0.17,-0.99,0.72,4.11,2.48,2.75,4.53,4.38,5.21,5.23,0.88,4.44,-0.16,0.76,1.68,-1.61,1.35,-0.04,1.19,-1.25,-0.26,1 --0.97,0.53,0.19,1.70,0.49,0.93,3.39,2.53,4.22,5.41,7.33,5.69,2.24,1.33,0.67,0.85,-1.36,-0.64,-0.63,-0.26,-1.37,1 --0.31,2.35,1.51,0.29,1.16,-1.03,-0.30,0.40,1.83,2.32,2.45,2.47,3.80,3.94,5.03,5.51,3.97,2.74,0.91,1.68,-0.53,2 --0.28,1.07,0.41,0.10,0.20,1.36,1.94,4.02,3.46,6.39,7.11,5.02,3.47,3.32,1.62,0.37,-0.24,1.87,-1.47,1.03,0.31,1 -1.94,-0.37,1.13,2.37,3.63,5.42,5.39,5.16,4.12,2.20,1.41,2.64,0.91,1.11,-0.37,0.06,-0.16,-0.08,0.95,0.70,0.02,0 -1.68,0.45,0.53,2.78,-0.08,2.09,0.95,1.16,1.78,-0.49,1.28,2.71,2.42,2.43,2.97,1.43,3.34,1.89,0.82,0.67,0.67,0 -0.99,-0.65,0.53,-0.96,0.98,0.36,-0.01,1.61,0.96,2.95,2.23,3.10,4.15,4.26,4.49,4.23,3.14,1.75,1.61,0.40,-0.22,2 -0.17,0.55,0.89,0.22,0.68,1.14,2.57,3.92,3.35,4.94,6.57,3.65,4.71,1.67,1.28,2.16,-1.33,-0.86,1.11,-0.11,0.64,1 -0.08,0.05,1.77,1.39,-0.32,4.51,2.87,1.95,1.25,3.74,2.72,3.58,2.53,3.34,2.30,4.76,2.39,0.71,0.57,-0.34,1.13,0 -0.58,-0.25,-0.26,0.41,-0.33,0.90,2.33,3.39,5.01,2.95,7.60,5.91,4.33,2.37,2.45,-0.26,1.73,-0.14,0.83,0.23,0.17,2 -0.03,1.85,1.07,0.33,0.90,2.28,2.22,1.24,4.30,3.17,1.19,0.45,3.04,3.69,2.09,3.07,1.59,2.95,0.88,0.34,0.36,0 -0.73,0.84,1.06,-0.11,-0.33,-0.21,0.83,2.46,2.16,4.48,3.75,5.51,4.14,2.64,1.45,1.58,0.90,2.68,-1.70,-0.29,0.29,2 --0.67,2.07,0.27,-0.36,1.20,-0.28,1.34,-1.46,0.91,1.12,1.38,3.22,3.33,4.74,6.46,4.93,1.31,2.67,2.22,-0.50,0.47,0 -1.77,0.21,-1.04,0.13,-0.19,1.13,0.16,1.83,2.84,1.93,4.26,1.75,4.38,6.40,5.65,2.35,2.02,2.12,1.59,0.77,-0.88,2 --1.38,0.87,-0.73,0.57,-0.12,1.52,4.12,2.52,4.04,5.74,6.60,3.57,2.94,2.09,0.25,0.20,0.48,-1.15,-1.03,0.77,-0.91,1 -0.05,-1.23,0.14,0.91,-0.58,3.08,2.35,0.51,0.84,2.98,2.18,2.28,2.05,1.86,4.10,3.39,2.61,2.29,0.96,0.19,0.66,0 --0.06,0.61,0.84,0.30,2.22,2.58,2.19,3.14,0.54,3.05,1.38,3.20,2.12,2.64,4.52,3.59,2.71,2.04,1.11,0.52,0.34,0 -1.23,-0.55,0.71,3.86,4.64,4.05,6.19,4.40,4.77,2.66,2.91,1.23,-0.41,-0.86,-1.19,-0.95,-0.51,-1.10,0.24,-0.78,-0.36,1 --2.39,0.37,0.96,4.29,3.89,2.47,2.07,4.20,4.29,2.79,3.26,1.17,0.97,-0.65,-0.08,-0.44,0.69,-0.29,0.83,-0.05,-2.18,0 -0.52,2.88,3.25,2.72,2.43,0.97,1.99,2.23,3.11,1.75,2.59,1.88,3.28,2.93,4.16,2.08,2.06,1.17,0.82,0.05,-0.31,0 --0.40,1.40,1.26,3.36,4.01,5.46,4.96,5.33,5.62,3.13,1.82,1.52,-0.60,0.02,-0.22,1.74,1.26,0.71,-0.26,-0.67,1.20,1 --0.89,-0.21,1.19,-1.12,0.54,-0.01,1.08,2.91,2.55,5.37,4.41,3.29,3.07,3.25,3.82,1.40,-0.40,0.51,-0.51,0.54,0.81,2 -0.45,-0.49,0.64,-1.29,-0.06,-0.29,0.24,0.87,0.60,0.41,3.28,3.27,3.65,5.77,5.38,3.33,4.41,2.37,-0.06,0.45,-1.62,2 -0.56,1.23,0.77,0.90,1.55,2.44,3.40,5.51,4.52,4.94,5.36,3.70,3.47,3.44,-0.35,0.36,0.35,-0.52,0.60,0.32,1.32,1 --0.39,-0.89,0.06,0.43,0.64,1.28,1.35,0.72,0.54,1.93,1.58,3.98,3.74,3.34,5.30,4.01,2.55,2.54,-0.32,3.00,-1.24,2 --1.43,1.41,1.33,2.76,2.68,4.65,5.89,6.57,3.90,2.85,3.13,2.13,-0.28,1.84,1.11,-1.99,1.03,-0.68,-0.66,-0.42,-2.07,1 -1.25,-0.28,0.49,-0.33,1.08,2.05,1.92,1.42,4.10,7.16,5.09,4.75,2.61,0.24,3.07,2.26,1.09,-0.22,1.03,0.79,-0.06,1 -1.20,-0.48,0.80,1.72,0.17,0.87,0.76,2.72,3.55,4.12,5.44,4.42,3.41,1.86,1.62,-0.55,-1.15,-1.21,0.54,1.57,-2.09,2 --0.06,-0.16,-0.72,0.08,-0.04,2.06,0.87,-1.01,0.76,1.76,2.71,4.24,4.91,4.74,4.93,3.81,4.34,3.22,2.22,-0.85,0.55,2 -1.37,0.97,1.09,2.12,2.60,3.21,5.85,4.69,4.42,3.86,4.36,0.57,2.62,1.54,1.71,-0.28,0.11,-0.79,2.40,0.06,-2.04,1 --1.26,-2.86,3.07,2.76,2.83,5.46,2.95,4.77,4.51,4.25,4.73,2.11,1.21,0.96,0.01,-0.26,0.07,0.26,-0.03,-0.08,-1.21,1 --1.76,0.07,0.03,0.19,-0.24,-1.48,1.09,3.59,3.89,3.90,4.32,5.25,4.87,3.83,2.12,1.28,0.37,-0.21,0.59,-0.29,1.73,2 --1.93,1.11,0.45,-1.02,1.24,-0.77,1.83,0.72,2.01,1.47,3.14,3.19,5.38,4.28,5.50,4.97,3.18,1.20,1.91,0.97,0.86,2 --2.14,-0.30,1.58,0.49,-0.04,4.59,5.89,4.06,4.48,4.28,2.01,2.05,1.33,1.62,-0.35,1.19,0.61,0.36,0.63,-1.20,0.79,1 --1.55,0.28,1.51,1.98,3.42,3.38,5.09,2.45,3.80,1.66,3.54,0.54,1.92,1.39,2.54,0.42,2.83,0.44,1.76,-0.26,-0.96,0 -0.72,0.52,-0.61,0.76,0.45,0.47,1.68,6.01,4.04,5.60,5.50,5.97,6.67,2.20,2.13,1.00,-0.34,-0.36,0.09,1.61,1.67,1 -0.46,1.07,0.84,-0.19,0.61,2.48,2.69,1.95,3.70,1.40,3.26,4.12,3.99,4.14,4.01,1.56,3.99,0.88,0.66,0.98,-1.47,2 -1.66,0.77,0.53,-0.43,1.38,-0.36,1.17,2.96,1.32,2.59,4.14,4.14,4.40,5.03,3.64,3.84,1.35,1.43,1.60,-1.18,0.14,2 --0.16,1.00,1.05,2.65,0.76,3.35,3.35,3.55,4.24,2.66,3.89,1.54,1.76,0.67,1.28,0.91,-1.07,1.57,-0.77,1.26,-0.85,1 --0.57,0.38,-1.02,0.64,1.36,1.81,1.59,4.42,2.59,4.21,6.01,7.18,4.26,2.92,3.67,1.79,0.60,-1.85,-2.10,-0.24,-0.79,1 -1.47,0.94,1.12,0.38,-0.12,-0.88,2.57,-0.11,1.86,1.53,1.39,2.81,2.77,5.69,4.33,4.13,2.62,3.89,1.37,0.55,-1.98,0 --2.59,-2.15,1.49,0.46,1.92,4.02,4.98,2.80,0.72,4.18,2.19,3.95,2.30,0.36,3.15,2.94,1.27,0.54,1.22,0.24,2.14,0 --1.18,-0.48,0.32,1.32,1.61,0.89,-0.26,1.64,2.05,2.85,2.65,4.07,5.12,3.71,5.37,4.37,3.99,0.59,2.24,-0.10,0.29,2 --0.14,0.78,0.24,-1.81,-0.35,1.55,0.25,-0.03,-1.66,1.42,2.01,0.19,4.28,6.26,6.74,3.01,4.08,1.91,3.09,1.38,0.07,0 --0.05,0.40,-0.81,0.14,-1.55,-1.35,1.37,1.50,1.45,1.88,4.15,5.20,3.84,5.39,6.83,4.61,3.96,2.37,0.97,0.28,1.08,2 --1.74,1.27,-0.61,-0.98,0.79,-0.01,0.76,3.12,4.28,2.91,4.51,4.16,2.20,4.86,2.40,2.85,1.43,2.44,1.40,0.74,1.17,2 -0.20,-1.31,-1.01,-1.38,-1.69,0.98,2.35,2.05,3.35,4.63,5.88,3.41,4.00,4.75,3.06,2.29,0.62,0.95,2.11,-0.39,0.31,2 -0.72,0.94,-0.43,3.46,2.82,5.56,5.66,3.56,5.81,4.07,3.05,2.51,1.56,-0.92,0.51,-0.79,0.37,-0.46,0.37,0.61,1.12,1 -0.42,1.68,0.85,3.60,2.49,5.08,5.65,3.93,5.83,3.28,1.82,2.08,1.19,2.46,1.34,2.11,0.67,0.22,0.23,1.28,-0.18,0 --0.04,-0.43,-0.36,-0.92,0.47,1.78,0.08,2.61,2.76,5.18,6.12,3.67,5.03,2.49,3.30,0.81,0.42,0.53,-0.38,0.34,0.88,2 --1.11,-0.60,-2.39,-1.02,-0.18,0.15,0.37,-0.65,-0.97,0.12,3.11,2.11,2.12,5.38,6.27,6.54,3.73,2.34,4.57,0.33,1.19,0 --2.18,1.04,1.42,1.41,2.34,3.14,5.14,3.34,3.87,2.83,3.42,3.52,1.11,0.58,-0.37,-0.91,-0.05,0.96,-2.70,0.12,-2.02,1 -0.02,2.17,-0.25,1.48,-0.23,-0.27,2.78,0.85,3.50,4.28,4.55,6.23,3.97,3.99,0.65,0.22,1.51,-0.47,0.42,-0.11,-0.15,2 -0.33,0.20,0.55,1.40,0.09,0.77,1.15,1.48,3.04,3.20,4.96,3.58,3.60,3.43,3.56,2.95,2.52,3.75,1.18,1.61,-0.70,2 --0.10,1.76,-0.40,3.22,2.92,2.72,3.03,2.47,2.41,1.06,2.62,1.34,2.48,3.57,2.31,3.89,-0.13,1.12,1.98,0.42,0.80,0 --0.47,0.64,0.99,0.89,-3.00,1.55,1.03,-0.44,0.20,2.12,2.94,2.71,5.57,5.20,4.64,4.18,3.22,1.49,2.81,0.66,0.49,2 -0.09,-0.17,0.97,-0.68,2.24,0.21,2.83,3.59,3.66,4.71,6.36,5.45,4.41,1.90,1.29,1.59,0.11,1.27,0.37,-0.99,-0.02,1 --2.29,1.04,-0.15,2.18,1.66,4.08,3.85,5.15,3.86,4.07,4.68,2.11,1.57,1.93,-0.12,-0.16,-1.12,-0.12,0.74,-0.74,-0.08,1 --0.78,0.21,1.12,-0.76,1.06,2.28,2.94,2.56,1.67,1.36,0.81,2.62,2.78,1.12,1.96,1.66,1.17,2.07,0.94,1.57,0.37,0 --0.77,0.20,1.07,1.42,2.82,3.44,5.23,5.32,4.95,4.19,2.73,1.71,0.25,-1.15,0.08,-0.79,-0.88,-1.87,3.13,0.31,-2.23,1 -1.32,0.81,1.19,3.61,4.42,4.02,4.43,5.41,4.57,1.33,1.87,0.76,-1.76,1.56,1.57,0.50,1.43,1.72,1.81,2.04,-1.78,0 --1.90,0.72,1.21,3.14,5.48,4.34,7.25,5.19,3.27,1.63,1.96,1.54,0.42,0.05,0.06,-0.49,0.12,-1.06,0.34,0.50,-2.60,1 --1.48,0.31,0.94,-0.41,1.41,1.59,1.88,-1.91,-0.78,0.25,1.73,2.41,4.03,2.67,6.86,1.62,3.95,2.96,2.48,-0.55,0.43,0 -0.48,1.40,3.79,2.73,4.23,3.54,5.08,6.59,1.48,3.57,2.84,1.85,-2.61,0.52,-1.57,0.85,2.63,0.27,-1.09,0.33,-1.56,1 -1.54,0.82,-0.27,0.11,-0.19,0.80,2.41,1.90,1.83,2.11,3.01,3.52,4.34,3.40,2.67,2.51,1.25,2.52,2.05,1.88,0.95,2 -0.22,-0.35,2.41,1.79,5.32,4.95,5.63,4.35,4.43,2.79,2.13,2.29,-0.80,1.77,1.09,0.50,2.64,-0.28,0.52,-0.88,0.56,1 --1.96,-0.72,0.98,0.11,1.37,1.78,3.55,3.88,5.38,5.43,5.70,5.16,4.34,3.05,1.74,2.15,0.40,1.39,-0.23,-2.11,-1.47,1 -0.07,-0.85,2.42,2.60,2.23,4.12,3.68,0.59,2.88,3.19,1.99,1.71,1.81,2.78,2.06,0.93,1.55,-0.11,1.41,1.55,-1.15,0 -0.48,-0.10,0.42,-0.36,0.52,0.72,2.82,1.07,4.08,5.00,7.37,5.65,4.91,2.56,0.72,0.64,0.92,0.32,1.16,-0.99,-2.24,2 -1.48,0.48,0.09,2.87,1.87,3.88,3.91,4.70,1.67,1.47,1.02,2.38,1.22,4.94,2.38,0.42,2.46,-0.39,0.03,0.90,-0.40,0 --0.32,-0.25,-1.42,1.35,0.26,-0.19,-0.72,0.07,-1.29,1.35,1.74,6.58,4.07,5.30,5.90,4.02,4.37,2.86,1.78,0.16,-1.04,0 --0.74,0.85,3.46,1.51,3.42,4.95,6.28,5.38,1.05,2.19,2.89,2.50,-0.22,1.38,-0.66,1.55,0.14,-1.43,-1.14,-0.51,-0.16,1 -0.26,-0.19,-0.18,1.03,2.63,2.16,5.39,3.81,4.09,3.79,4.72,1.92,2.07,3.15,1.75,0.65,0.46,0.70,-1.11,-0.43,-0.29,1 --0.28,-0.72,-0.18,-0.11,3.62,2.37,3.98,3.47,2.71,3.24,4.96,2.48,4.46,1.43,0.32,0.61,-0.74,-1.43,-1.63,-0.78,0.63,1 --1.28,1.29,3.63,3.61,2.87,4.46,3.78,4.99,3.03,3.51,2.22,1.96,0.31,1.73,1.15,1.04,1.26,0.78,0.11,-0.88,0.37,1 -0.16,0.77,1.04,2.01,0.82,-0.16,-1.02,0.26,-1.19,0.80,1.45,1.81,4.28,5.70,7.01,4.83,5.29,0.77,0.91,0.99,-1.03,2 -1.30,2.31,1.52,3.47,4.08,4.99,4.67,5.15,4.40,2.70,3.53,2.18,1.55,-0.24,0.19,0.26,-1.18,0.48,-0.42,0.38,2.15,1 --0.47,1.21,1.61,2.03,3.49,5.96,7.62,4.31,3.47,3.48,2.21,0.89,1.68,-0.78,0.27,1.74,-0.17,0.73,-0.83,-1.01,-0.36,1 --1.21,2.39,2.60,1.17,1.48,2.68,4.99,4.34,3.66,3.43,4.03,3.15,1.26,0.99,-1.01,-0.14,-0.08,0.11,-0.61,1.29,-0.57,1 --1.33,-0.98,-0.76,1.05,1.20,-0.34,0.41,2.21,2.72,5.28,4.27,2.62,4.72,3.49,2.51,3.48,1.65,0.11,0.01,1.90,-1.08,2 -0.65,0.17,0.06,-0.05,1.08,0.25,3.57,1.63,4.11,3.89,5.14,3.43,3.03,2.15,1.73,-0.02,-0.55,2.01,1.03,0.45,0.06,1 -1.02,0.06,0.30,0.84,-0.25,-0.26,2.53,1.15,0.95,1.22,1.11,2.94,3.05,3.20,4.35,5.02,5.09,2.43,2.44,-0.14,-0.10,0 --1.22,-1.50,0.23,-1.61,0.02,0.11,-0.81,0.24,2.71,1.89,4.16,4.35,3.75,4.22,3.88,2.92,3.27,1.12,2.02,2.04,0.91,2 -1.32,-1.88,0.10,3.29,2.94,3.37,4.30,5.32,4.94,5.46,4.57,3.87,1.42,1.61,0.01,1.11,-1.93,-0.83,0.81,1.63,0.11,1 -0.67,-0.16,-1.29,1.40,1.11,2.42,3.32,3.18,2.85,5.55,5.91,4.10,4.25,1.87,1.32,-0.83,0.28,0.53,-0.39,-0.55,1.03,1 -0.66,-1.19,0.18,-0.97,0.91,3.55,3.19,3.15,4.18,4.01,5.24,4.79,3.12,3.85,1.07,2.09,-0.49,0.37,0.65,2.41,0.04,1 --0.08,1.08,1.04,1.18,1.96,0.09,2.16,0.53,0.43,3.10,2.30,3.40,2.92,5.94,4.53,6.71,4.59,1.03,1.91,1.51,-0.31,0 -0.41,-0.14,-1.23,0.18,0.33,0.58,1.79,1.47,4.92,3.13,4.09,4.00,5.18,3.47,1.94,2.34,1.08,0.31,-0.18,-1.80,0.09,2 --1.46,-0.89,1.13,-0.61,-1.21,2.18,1.47,1.51,2.38,3.47,6.88,5.54,2.60,2.83,0.36,1.55,0.48,0.97,0.67,-0.93,1.66,2 --1.27,1.14,-0.32,0.60,0.44,0.99,1.80,2.75,4.58,6.67,5.60,6.34,1.26,0.55,0.97,0.19,-0.69,0.52,-1.45,0.67,-0.92,1 -1.63,-0.32,0.56,0.86,-0.41,0.53,0.94,1.44,0.23,3.56,6.54,4.47,5.19,4.20,4.54,3.09,1.98,0.96,1.91,0.88,0.14,2 --0.56,-2.03,0.56,0.14,0.92,0.92,3.27,1.69,4.32,2.71,6.55,4.40,4.01,1.44,2.23,2.96,1.45,0.38,3.05,1.97,-0.54,2 --0.03,-0.29,0.07,-0.56,0.43,2.04,2.54,4.70,3.45,6.21,4.69,2.86,5.08,2.35,0.04,0.92,-0.11,-1.67,0.39,-0.41,0.41,1 -2.12,1.87,0.08,-0.97,0.39,-0.18,1.48,2.87,3.18,5.96,4.29,3.48,4.49,3.68,1.57,0.89,1.16,-0.47,0.45,0.29,0.00,2 -0.27,1.23,-0.01,1.05,1.24,-0.07,3.48,3.59,4.62,3.40,3.57,4.69,4.72,1.69,2.47,3.05,1.46,-0.30,-2.01,0.99,1.91,1 --0.11,2.01,1.18,1.28,4.05,4.98,4.26,3.57,2.44,1.04,1.83,1.78,1.33,-0.92,-0.01,1.85,1.08,-1.02,1.88,0.39,0.28,0 -0.47,0.23,-0.29,0.55,2.09,1.41,2.03,3.71,6.09,5.18,3.63,3.40,3.26,1.37,1.57,2.28,0.22,0.25,-0.06,-0.99,0.19,1 -1.13,-0.45,-1.38,-0.25,-0.76,0.84,0.69,2.65,1.10,2.69,3.23,2.66,3.17,4.96,5.23,2.06,4.29,0.87,1.71,0.51,0.22,2 -0.57,-0.19,1.86,1.03,0.09,-0.73,1.34,-1.13,0.29,2.16,1.99,1.61,2.50,5.78,4.60,5.27,5.29,2.58,2.27,2.08,0.69,2 --1.07,0.68,0.65,-0.81,-0.73,0.86,-0.17,0.51,-0.03,1.63,2.66,2.05,3.64,5.12,4.94,4.10,2.90,1.78,0.80,0.60,-0.95,0 --0.55,0.46,1.36,1.91,4.00,4.54,6.17,5.30,2.79,3.13,2.21,1.21,2.01,0.26,-0.21,-0.62,0.18,-0.75,-0.37,0.06,-0.25,1 --1.69,0.50,-0.02,-2.79,1.37,0.27,0.88,2.72,1.77,2.59,3.04,3.52,3.00,6.69,5.43,4.54,2.88,0.58,2.36,0.68,-0.15,2 --1.35,0.49,-1.21,0.59,-0.41,0.59,-0.69,0.81,2.00,1.92,3.21,4.82,4.68,4.24,3.66,4.50,3.07,2.72,1.85,0.39,0.54,2 --0.32,1.37,-0.42,3.71,2.54,4.36,5.47,3.69,3.26,2.52,2.22,0.32,1.97,1.23,0.63,2.03,0.15,1.58,-0.62,-0.42,1.22,0 -0.87,0.07,1.32,-0.05,0.95,0.35,2.22,6.05,3.00,6.16,5.67,5.63,2.59,3.02,1.34,1.88,0.76,-1.41,1.58,1.32,-0.91,1 -0.36,1.27,0.02,0.84,0.33,0.15,0.42,2.17,2.41,4.38,6.46,4.10,3.69,2.92,3.82,2.50,1.12,-0.00,-0.67,-0.53,-0.87,2 -0.20,2.55,-0.28,0.23,0.54,-0.05,1.13,-1.04,1.75,1.41,1.50,2.67,4.99,5.85,6.58,4.65,3.86,3.18,1.44,1.61,0.10,0 -0.10,-0.55,0.82,0.93,0.14,0.80,2.19,1.62,2.33,4.60,3.79,4.22,4.41,3.95,4.34,2.73,1.52,2.19,1.53,2.60,-0.39,2 -1.46,3.18,-0.26,2.10,2.28,4.72,5.49,4.88,3.13,2.69,2.63,0.88,0.80,1.09,-0.17,0.06,2.00,1.08,-1.73,-0.25,0.29,0 -0.25,1.31,2.23,0.95,3.84,3.84,3.99,3.07,3.26,2.87,1.77,1.74,0.38,0.45,2.66,2.02,0.21,-0.81,0.52,2.01,-0.07,0 --0.93,0.94,2.44,0.59,1.91,3.28,3.49,4.25,2.97,4.21,3.77,0.77,2.63,1.80,0.40,-1.05,-1.45,0.25,0.01,1.65,-1.76,1 --0.52,-0.27,0.04,0.91,-0.04,-1.33,1.60,2.34,0.82,2.57,3.39,1.69,5.08,3.87,5.38,6.00,1.06,1.28,0.93,1.78,0.67,2 --0.10,0.71,-0.62,1.18,0.02,0.32,0.19,0.69,2.17,2.41,1.85,4.80,4.76,5.70,4.18,5.06,1.31,3.98,0.98,0.48,-2.68,2 --0.65,0.69,2.29,-0.16,0.51,0.26,2.34,-0.42,0.49,0.31,0.34,4.54,3.46,4.81,5.49,5.19,3.10,3.86,2.96,1.09,-1.42,0 --0.02,0.67,2.34,3.18,2.16,4.77,6.70,4.54,4.92,3.39,2.56,1.50,1.53,2.52,1.14,-1.56,-1.18,-0.56,0.02,-1.05,-0.18,1 -0.01,-1.99,0.16,2.30,-0.53,1.93,3.61,3.00,4.61,5.73,4.53,4.25,3.14,3.04,1.61,0.60,-0.52,0.62,1.00,1.21,-0.27,1 --0.40,0.41,-0.48,1.04,0.79,-0.66,1.18,0.52,2.20,0.59,0.85,4.85,3.64,3.62,5.97,2.63,3.83,1.72,2.08,1.31,1.37,0 -0.63,-0.07,2.71,2.55,3.36,3.22,3.69,4.67,3.45,3.87,4.15,1.46,-0.52,1.90,0.88,3.15,1.27,-0.53,0.09,0.01,0.60,1 diff --git a/samples/gpu/768x576.avi b/samples/data/768x576.avi similarity index 100% rename from samples/gpu/768x576.avi rename to samples/data/768x576.avi diff --git a/samples/cpp/H1to3p.xml b/samples/data/H1to3p.xml similarity index 100% rename from samples/cpp/H1to3p.xml rename to samples/data/H1to3p.xml diff --git a/samples/cpp/tutorial_code/images/HappyFish.jpg b/samples/data/HappyFish.jpg similarity index 100% rename from samples/cpp/tutorial_code/images/HappyFish.jpg rename to samples/data/HappyFish.jpg diff --git a/samples/cpp/tutorial_code/images/LinuxLogo.jpg b/samples/data/LinuxLogo.jpg similarity index 100% rename from samples/cpp/tutorial_code/images/LinuxLogo.jpg rename to samples/data/LinuxLogo.jpg diff --git a/samples/cpp/tutorial_code/images/WindowsLogo.jpg b/samples/data/WindowsLogo.jpg similarity index 100% rename from samples/cpp/tutorial_code/images/WindowsLogo.jpg rename to samples/data/WindowsLogo.jpg diff --git a/samples/python2/data/aero1.jpg b/samples/data/aero1.jpg similarity index 100% rename from samples/python2/data/aero1.jpg rename to samples/data/aero1.jpg diff --git a/samples/python2/data/aero3.jpg b/samples/data/aero3.jpg similarity index 100% rename from samples/python2/data/aero3.jpg rename to samples/data/aero3.jpg diff --git a/samples/gpu/aloeL.jpg b/samples/data/aloeL.jpg similarity index 100% rename from samples/gpu/aloeL.jpg rename to samples/data/aloeL.jpg diff --git a/samples/gpu/aloeR.jpg b/samples/data/aloeR.jpg similarity index 100% rename from samples/gpu/aloeR.jpg rename to samples/data/aloeR.jpg diff --git a/samples/cpp/baboon.jpg b/samples/data/baboon.jpg similarity index 100% rename from samples/cpp/baboon.jpg rename to samples/data/baboon.jpg diff --git a/samples/gpu/basketball1.png b/samples/data/basketball1.png similarity index 100% rename from samples/gpu/basketball1.png rename to samples/data/basketball1.png diff --git a/samples/gpu/basketball2.png b/samples/data/basketball2.png similarity index 100% rename from samples/gpu/basketball2.png rename to samples/data/basketball2.png diff --git a/samples/cpp/board.jpg b/samples/data/board.jpg similarity index 100% rename from samples/cpp/board.jpg rename to samples/data/board.jpg diff --git a/samples/cpp/box.png b/samples/data/box.png similarity index 100% rename from samples/cpp/box.png rename to samples/data/box.png diff --git a/samples/cpp/box_in_scene.png b/samples/data/box_in_scene.png similarity index 100% rename from samples/cpp/box_in_scene.png rename to samples/data/box_in_scene.png diff --git a/samples/cpp/building.jpg b/samples/data/building.jpg similarity index 100% rename from samples/cpp/building.jpg rename to samples/data/building.jpg diff --git a/samples/cpp/tutorial_code/images/chicky_512.png b/samples/data/chicky_512.png similarity index 100% rename from samples/cpp/tutorial_code/images/chicky_512.png rename to samples/data/chicky_512.png diff --git a/samples/cpp/data01.xml b/samples/data/data01.xml similarity index 100% rename from samples/cpp/data01.xml rename to samples/data/data01.xml diff --git a/samples/python2/data/digits.png b/samples/data/digits.png similarity index 100% rename from samples/python2/data/digits.png rename to samples/data/digits.png diff --git a/samples/cpp/fruits.jpg b/samples/data/fruits.jpg similarity index 100% rename from samples/cpp/fruits.jpg rename to samples/data/fruits.jpg diff --git a/samples/cpp/graf1.png b/samples/data/graf1.png similarity index 100% rename from samples/cpp/graf1.png rename to samples/data/graf1.png diff --git a/samples/cpp/graf3.png b/samples/data/graf3.png similarity index 100% rename from samples/cpp/graf3.png rename to samples/data/graf3.png diff --git a/samples/cpp/tutorial_code/images/imageTextN.png b/samples/data/imageTextN.png similarity index 100% rename from samples/cpp/tutorial_code/images/imageTextN.png rename to samples/data/imageTextN.png diff --git a/samples/cpp/tutorial_code/images/imageTextR.png b/samples/data/imageTextR.png similarity index 100% rename from samples/cpp/tutorial_code/images/imageTextR.png rename to samples/data/imageTextR.png diff --git a/samples/cpp/intrinsics.yml b/samples/data/intrinsics.yml similarity index 100% rename from samples/cpp/intrinsics.yml rename to samples/data/intrinsics.yml diff --git a/samples/cpp/left01.jpg b/samples/data/left01.jpg similarity index 100% rename from samples/cpp/left01.jpg rename to samples/data/left01.jpg diff --git a/samples/cpp/left02.jpg b/samples/data/left02.jpg similarity index 100% rename from samples/cpp/left02.jpg rename to samples/data/left02.jpg diff --git a/samples/cpp/left03.jpg b/samples/data/left03.jpg similarity index 100% rename from samples/cpp/left03.jpg rename to samples/data/left03.jpg diff --git a/samples/cpp/left04.jpg b/samples/data/left04.jpg similarity index 100% rename from samples/cpp/left04.jpg rename to samples/data/left04.jpg diff --git a/samples/cpp/left05.jpg b/samples/data/left05.jpg similarity index 100% rename from samples/cpp/left05.jpg rename to samples/data/left05.jpg diff --git a/samples/cpp/left06.jpg b/samples/data/left06.jpg similarity index 100% rename from samples/cpp/left06.jpg rename to samples/data/left06.jpg diff --git a/samples/cpp/left07.jpg b/samples/data/left07.jpg similarity index 100% rename from samples/cpp/left07.jpg rename to samples/data/left07.jpg diff --git a/samples/cpp/left08.jpg b/samples/data/left08.jpg similarity index 100% rename from samples/cpp/left08.jpg rename to samples/data/left08.jpg diff --git a/samples/cpp/left09.jpg b/samples/data/left09.jpg similarity index 100% rename from samples/cpp/left09.jpg rename to samples/data/left09.jpg diff --git a/samples/cpp/left11.jpg b/samples/data/left11.jpg similarity index 100% rename from samples/cpp/left11.jpg rename to samples/data/left11.jpg diff --git a/samples/cpp/left12.jpg b/samples/data/left12.jpg similarity index 100% rename from samples/cpp/left12.jpg rename to samples/data/left12.jpg diff --git a/samples/cpp/left13.jpg b/samples/data/left13.jpg similarity index 100% rename from samples/cpp/left13.jpg rename to samples/data/left13.jpg diff --git a/samples/cpp/left14.jpg b/samples/data/left14.jpg similarity index 100% rename from samples/cpp/left14.jpg rename to samples/data/left14.jpg diff --git a/samples/cpp/lena.jpg b/samples/data/lena.jpg similarity index 100% rename from samples/cpp/lena.jpg rename to samples/data/lena.jpg diff --git a/samples/cpp/letter-recognition.data b/samples/data/letter-recognition.data similarity index 100% rename from samples/cpp/letter-recognition.data rename to samples/data/letter-recognition.data diff --git a/samples/python2/data/licenseplate_motion.jpg b/samples/data/licenseplate_motion.jpg similarity index 100% rename from samples/python2/data/licenseplate_motion.jpg rename to samples/data/licenseplate_motion.jpg diff --git a/samples/cpp/tutorial_code/images/opencv-logo.png b/samples/data/opencv-logo.png similarity index 100% rename from samples/cpp/tutorial_code/images/opencv-logo.png rename to samples/data/opencv-logo.png diff --git a/samples/cpp/pic1.png b/samples/data/pic1.png similarity index 100% rename from samples/cpp/pic1.png rename to samples/data/pic1.png diff --git a/samples/cpp/pic2.png b/samples/data/pic2.png similarity index 100% rename from samples/cpp/pic2.png rename to samples/data/pic2.png diff --git a/samples/cpp/pic3.png b/samples/data/pic3.png similarity index 100% rename from samples/cpp/pic3.png rename to samples/data/pic3.png diff --git a/samples/cpp/pic4.png b/samples/data/pic4.png similarity index 100% rename from samples/cpp/pic4.png rename to samples/data/pic4.png diff --git a/samples/cpp/pic5.png b/samples/data/pic5.png similarity index 100% rename from samples/cpp/pic5.png rename to samples/data/pic5.png diff --git a/samples/cpp/pic6.png b/samples/data/pic6.png similarity index 100% rename from samples/cpp/pic6.png rename to samples/data/pic6.png diff --git a/samples/cpp/right01.jpg b/samples/data/right01.jpg similarity index 100% rename from samples/cpp/right01.jpg rename to samples/data/right01.jpg diff --git a/samples/cpp/right02.jpg b/samples/data/right02.jpg similarity index 100% rename from samples/cpp/right02.jpg rename to samples/data/right02.jpg diff --git a/samples/cpp/right03.jpg b/samples/data/right03.jpg similarity index 100% rename from samples/cpp/right03.jpg rename to samples/data/right03.jpg diff --git a/samples/cpp/right04.jpg b/samples/data/right04.jpg similarity index 100% rename from samples/cpp/right04.jpg rename to samples/data/right04.jpg diff --git a/samples/cpp/right05.jpg b/samples/data/right05.jpg similarity index 100% rename from samples/cpp/right05.jpg rename to samples/data/right05.jpg diff --git a/samples/cpp/right06.jpg b/samples/data/right06.jpg similarity index 100% rename from samples/cpp/right06.jpg rename to samples/data/right06.jpg diff --git a/samples/cpp/right07.jpg b/samples/data/right07.jpg similarity index 100% rename from samples/cpp/right07.jpg rename to samples/data/right07.jpg diff --git a/samples/cpp/right08.jpg b/samples/data/right08.jpg similarity index 100% rename from samples/cpp/right08.jpg rename to samples/data/right08.jpg diff --git a/samples/cpp/right09.jpg b/samples/data/right09.jpg similarity index 100% rename from samples/cpp/right09.jpg rename to samples/data/right09.jpg diff --git a/samples/cpp/right11.jpg b/samples/data/right11.jpg similarity index 100% rename from samples/cpp/right11.jpg rename to samples/data/right11.jpg diff --git a/samples/cpp/right12.jpg b/samples/data/right12.jpg similarity index 100% rename from samples/cpp/right12.jpg rename to samples/data/right12.jpg diff --git a/samples/cpp/right13.jpg b/samples/data/right13.jpg similarity index 100% rename from samples/cpp/right13.jpg rename to samples/data/right13.jpg diff --git a/samples/cpp/right14.jpg b/samples/data/right14.jpg similarity index 100% rename from samples/cpp/right14.jpg rename to samples/data/right14.jpg diff --git a/samples/gpu/rubberwhale1.png b/samples/data/rubberwhale1.png similarity index 100% rename from samples/gpu/rubberwhale1.png rename to samples/data/rubberwhale1.png diff --git a/samples/gpu/rubberwhale2.png b/samples/data/rubberwhale2.png similarity index 100% rename from samples/gpu/rubberwhale2.png rename to samples/data/rubberwhale2.png diff --git a/samples/cpp/shape_sample/1.png b/samples/data/shape_sample/1.png similarity index 100% rename from samples/cpp/shape_sample/1.png rename to samples/data/shape_sample/1.png diff --git a/samples/cpp/shape_sample/10.png b/samples/data/shape_sample/10.png similarity index 100% rename from samples/cpp/shape_sample/10.png rename to samples/data/shape_sample/10.png diff --git a/samples/cpp/shape_sample/11.png b/samples/data/shape_sample/11.png similarity index 100% rename from samples/cpp/shape_sample/11.png rename to samples/data/shape_sample/11.png diff --git a/samples/cpp/shape_sample/12.png b/samples/data/shape_sample/12.png similarity index 100% rename from samples/cpp/shape_sample/12.png rename to samples/data/shape_sample/12.png diff --git a/samples/cpp/shape_sample/13.png b/samples/data/shape_sample/13.png similarity index 100% rename from samples/cpp/shape_sample/13.png rename to samples/data/shape_sample/13.png diff --git a/samples/cpp/shape_sample/14.png b/samples/data/shape_sample/14.png similarity index 100% rename from samples/cpp/shape_sample/14.png rename to samples/data/shape_sample/14.png diff --git a/samples/cpp/shape_sample/15.png b/samples/data/shape_sample/15.png similarity index 100% rename from samples/cpp/shape_sample/15.png rename to samples/data/shape_sample/15.png diff --git a/samples/cpp/shape_sample/16.png b/samples/data/shape_sample/16.png similarity index 100% rename from samples/cpp/shape_sample/16.png rename to samples/data/shape_sample/16.png diff --git a/samples/cpp/shape_sample/17.png b/samples/data/shape_sample/17.png similarity index 100% rename from samples/cpp/shape_sample/17.png rename to samples/data/shape_sample/17.png diff --git a/samples/cpp/shape_sample/18.png b/samples/data/shape_sample/18.png similarity index 100% rename from samples/cpp/shape_sample/18.png rename to samples/data/shape_sample/18.png diff --git a/samples/cpp/shape_sample/19.png b/samples/data/shape_sample/19.png similarity index 100% rename from samples/cpp/shape_sample/19.png rename to samples/data/shape_sample/19.png diff --git a/samples/cpp/shape_sample/2.png b/samples/data/shape_sample/2.png similarity index 100% rename from samples/cpp/shape_sample/2.png rename to samples/data/shape_sample/2.png diff --git a/samples/cpp/shape_sample/20.png b/samples/data/shape_sample/20.png similarity index 100% rename from samples/cpp/shape_sample/20.png rename to samples/data/shape_sample/20.png diff --git a/samples/cpp/shape_sample/3.png b/samples/data/shape_sample/3.png similarity index 100% rename from samples/cpp/shape_sample/3.png rename to samples/data/shape_sample/3.png diff --git a/samples/cpp/shape_sample/4.png b/samples/data/shape_sample/4.png similarity index 100% rename from samples/cpp/shape_sample/4.png rename to samples/data/shape_sample/4.png diff --git a/samples/cpp/shape_sample/5.png b/samples/data/shape_sample/5.png similarity index 100% rename from samples/cpp/shape_sample/5.png rename to samples/data/shape_sample/5.png diff --git a/samples/cpp/shape_sample/6.png b/samples/data/shape_sample/6.png similarity index 100% rename from samples/cpp/shape_sample/6.png rename to samples/data/shape_sample/6.png diff --git a/samples/cpp/shape_sample/7.png b/samples/data/shape_sample/7.png similarity index 100% rename from samples/cpp/shape_sample/7.png rename to samples/data/shape_sample/7.png diff --git a/samples/cpp/shape_sample/8.png b/samples/data/shape_sample/8.png similarity index 100% rename from samples/cpp/shape_sample/8.png rename to samples/data/shape_sample/8.png diff --git a/samples/cpp/shape_sample/9.png b/samples/data/shape_sample/9.png similarity index 100% rename from samples/cpp/shape_sample/9.png rename to samples/data/shape_sample/9.png diff --git a/samples/python2/data/starry_night.jpg b/samples/data/starry_night.jpg similarity index 100% rename from samples/python2/data/starry_night.jpg rename to samples/data/starry_night.jpg diff --git a/samples/cpp/stereo_calib.xml b/samples/data/stereo_calib.xml similarity index 99% rename from samples/cpp/stereo_calib.xml rename to samples/data/stereo_calib.xml index 68875facf2..0772302c99 100644 --- a/samples/cpp/stereo_calib.xml +++ b/samples/data/stereo_calib.xml @@ -29,4 +29,3 @@ "right14.jpg" - diff --git a/samples/cpp/stuff.jpg b/samples/data/stuff.jpg similarity index 100% rename from samples/cpp/stuff.jpg rename to samples/data/stuff.jpg diff --git a/samples/cpp/templ.png b/samples/data/templ.png similarity index 100% rename from samples/cpp/templ.png rename to samples/data/templ.png diff --git a/samples/python2/data/text_defocus.jpg b/samples/data/text_defocus.jpg similarity index 100% rename from samples/python2/data/text_defocus.jpg rename to samples/data/text_defocus.jpg diff --git a/samples/python2/data/text_motion.jpg b/samples/data/text_motion.jpg similarity index 100% rename from samples/python2/data/text_motion.jpg rename to samples/data/text_motion.jpg diff --git a/samples/cpp/tree.avi b/samples/data/tree.avi similarity index 100% rename from samples/cpp/tree.avi rename to samples/data/tree.avi diff --git a/samples/gpu/bgfg_segm.cpp b/samples/gpu/bgfg_segm.cpp index 7e9865d825..89bb8d6a2f 100644 --- a/samples/gpu/bgfg_segm.cpp +++ b/samples/gpu/bgfg_segm.cpp @@ -23,7 +23,7 @@ int main(int argc, const char** argv) { cv::CommandLineParser cmd(argc, argv, "{ c camera | | use camera }" - "{ f file | 768x576.avi | input video file }" + "{ f file | ../data/768x576.avi | input video file }" "{ m method | mog | method (mog, mog2, gmg, fgd) }" "{ h help | | print help message }"); diff --git a/samples/gpu/generalized_hough.cpp b/samples/gpu/generalized_hough.cpp index a9081c56b7..fb1cb8979c 100644 --- a/samples/gpu/generalized_hough.cpp +++ b/samples/gpu/generalized_hough.cpp @@ -27,7 +27,7 @@ static Mat loadImage(const string& name) int main(int argc, const char* argv[]) { CommandLineParser cmd(argc, argv, - "{ image i | pic1.png | input image }" + "{ image i | ../data/pic1.png | input image }" "{ template t | templ.png | template image }" "{ full | | estimate scale and rotation }" "{ gpu | | use gpu version }" diff --git a/samples/gpu/houghlines.cpp b/samples/gpu/houghlines.cpp index 29dc69ce2f..040ef289a3 100644 --- a/samples/gpu/houghlines.cpp +++ b/samples/gpu/houghlines.cpp @@ -15,12 +15,12 @@ static void help() { cout << "This program demonstrates line finding with the Hough transform." << endl; cout << "Usage:" << endl; - cout << "./gpu-example-houghlines , Default is pic1.png\n" << endl; + cout << "./gpu-example-houghlines , Default is ../data/pic1.png\n" << endl; } int main(int argc, const char* argv[]) { - const string filename = argc >= 2 ? argv[1] : "pic1.png"; + const string filename = argc >= 2 ? argv[1] : "../data/pic1.png"; Mat src = imread(filename, IMREAD_GRAYSCALE); if (src.empty()) diff --git a/samples/gpu/morphology.cpp b/samples/gpu/morphology.cpp index 8e2961af99..b5e50caa3c 100644 --- a/samples/gpu/morphology.cpp +++ b/samples/gpu/morphology.cpp @@ -44,7 +44,7 @@ App::App(int argc, const char* argv[]) exit(0); } - String filename = argc == 2 ? argv[1] : "baboon.jpg"; + String filename = argc == 2 ? argv[1] : "../data/baboon.jpg"; Mat img = imread(filename); if (img.empty()) diff --git a/samples/gpu/performance/tests.cpp b/samples/gpu/performance/tests.cpp index 9f2c2d13b8..9767e7ac6d 100644 --- a/samples/gpu/performance/tests.cpp +++ b/samples/gpu/performance/tests.cpp @@ -281,8 +281,8 @@ TEST(meanShift) TEST(SURF) { - Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE); - if (src.empty()) throw runtime_error("can't open aloeL.jpg"); + Mat src = imread(abspath("../data/aloeL.jpg"), IMREAD_GRAYSCALE); + if (src.empty()) throw runtime_error("can't open ../data/aloeL.jpg"); xfeatures2d::SURF surf; vector keypoints; @@ -311,8 +311,8 @@ TEST(SURF) TEST(FAST) { - Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE); - if (src.empty()) throw runtime_error("can't open aloeL.jpg"); + Mat src = imread(abspath("../data/aloeL.jpg"), IMREAD_GRAYSCALE); + if (src.empty()) throw runtime_error("can't open ../data/aloeL.jpg"); vector keypoints; @@ -336,17 +336,18 @@ TEST(FAST) TEST(ORB) { - Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE); - if (src.empty()) throw runtime_error("can't open aloeL.jpg"); + Mat src = imread(abspath("../data/aloeL.jpg"), IMREAD_GRAYSCALE); + if (src.empty()) throw runtime_error("can't open ../data/aloeL.jpg"); + + Ptr orb = ORB::create(4000); - ORB orb(4000); vector keypoints; Mat descriptors; - orb(src, Mat(), keypoints, descriptors); + orb->detectAndCompute(src, Mat(), keypoints, descriptors); CPU_ON; - orb(src, Mat(), keypoints, descriptors); + orb->detectAndCompute(src, Mat(), keypoints, descriptors); CPU_OFF; cuda::ORB_CUDA d_orb; @@ -1065,9 +1066,9 @@ TEST(equalizeHist) TEST(Canny) { - Mat img = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE); + Mat img = imread(abspath("../data/aloeL.jpg"), IMREAD_GRAYSCALE); - if (img.empty()) throw runtime_error("can't open aloeL.jpg"); + if (img.empty()) throw runtime_error("can't open ../data/aloeL.jpg"); Mat edges(img.size(), CV_8UC1); @@ -1166,8 +1167,8 @@ TEST(gemm) TEST(GoodFeaturesToTrack) { - Mat src = imread(abspath("aloeL.jpg"), IMREAD_GRAYSCALE); - if (src.empty()) throw runtime_error("can't open aloeL.jpg"); + Mat src = imread(abspath("../data/aloeL.jpg"), IMREAD_GRAYSCALE); + if (src.empty()) throw runtime_error("can't open ../data/aloeL.jpg"); vector pts; @@ -1191,11 +1192,11 @@ TEST(GoodFeaturesToTrack) TEST(PyrLKOpticalFlow) { - Mat frame0 = imread(abspath("rubberwhale1.png")); - if (frame0.empty()) throw runtime_error("can't open rubberwhale1.png"); + Mat frame0 = imread(abspath("../data/rubberwhale1.png")); + if (frame0.empty()) throw runtime_error("can't open ../data/rubberwhale1.png"); - Mat frame1 = imread(abspath("rubberwhale2.png")); - if (frame1.empty()) throw runtime_error("can't open rubberwhale2.png"); + Mat frame1 = imread(abspath("../data/rubberwhale2.png")); + if (frame1.empty()) throw runtime_error("can't open ../data/rubberwhale2.png"); Mat gray_frame; cvtColor(frame0, gray_frame, COLOR_BGR2GRAY); @@ -1242,7 +1243,7 @@ TEST(PyrLKOpticalFlow) TEST(FarnebackOpticalFlow) { - const string datasets[] = {"rubberwhale", "basketball"}; + const string datasets[] = {"../data/rubberwhale", "../data/basketball"}; for (size_t i = 0; i < sizeof(datasets)/sizeof(*datasets); ++i) { for (int fastPyramids = 0; fastPyramids < 2; ++fastPyramids) { for (int useGaussianBlur = 0; useGaussianBlur < 2; ++useGaussianBlur) { @@ -1274,10 +1275,10 @@ TEST(FarnebackOpticalFlow) TEST(MOG) { - const std::string inputFile = abspath("768x576.avi"); + const std::string inputFile = abspath("../data/768x576.avi"); cv::VideoCapture cap(inputFile); - if (!cap.isOpened()) throw runtime_error("can't open 768x576.avi"); + if (!cap.isOpened()) throw runtime_error("can't open ../data/768x576.avi"); cv::Mat frame; cap >> frame; @@ -1327,10 +1328,10 @@ TEST(MOG) TEST(MOG2) { - const std::string inputFile = abspath("768x576.avi"); + const std::string inputFile = abspath("../data/768x576.avi"); cv::VideoCapture cap(inputFile); - if (!cap.isOpened()) throw runtime_error("can't open 768x576.avi"); + if (!cap.isOpened()) throw runtime_error("can't open ../data/768x576.avi"); cv::Mat frame; cap >> frame; diff --git a/samples/gpu/road.png b/samples/gpu/road.png deleted file mode 100644 index a52c87cffb..0000000000 Binary files a/samples/gpu/road.png and /dev/null differ diff --git a/samples/gpu/tsucuba_left.png b/samples/gpu/tsucuba_left.png deleted file mode 100644 index 09679b24fb..0000000000 Binary files a/samples/gpu/tsucuba_left.png and /dev/null differ diff --git a/samples/gpu/tsucuba_right.png b/samples/gpu/tsucuba_right.png deleted file mode 100644 index a97b2763fc..0000000000 Binary files a/samples/gpu/tsucuba_right.png and /dev/null differ diff --git a/samples/python2/asift.py b/samples/python2/asift.py index 25320865c4..b24977bc07 100755 --- a/samples/python2/asift.py +++ b/samples/python2/asift.py @@ -113,8 +113,8 @@ if __name__ == '__main__': try: fn1, fn2 = args except: - fn1 = 'data/aero1.jpg' - fn2 = 'data/aero3.jpg' + fn1 = '../data/aero1.jpg' + fn2 = '../data/aero3.jpg' img1 = cv2.imread(fn1, 0) img2 = cv2.imread(fn2, 0) diff --git a/samples/python2/coherence.py b/samples/python2/coherence.py index 92122e876d..46d7414af5 100755 --- a/samples/python2/coherence.py +++ b/samples/python2/coherence.py @@ -43,7 +43,7 @@ if __name__ == '__main__': try: fn = sys.argv[1] except: - fn = '../cpp/baboon.jpg' + fn = '../data/baboon.jpg' src = cv2.imread(fn) diff --git a/samples/python2/color_histogram.py b/samples/python2/color_histogram.py index 160baf66f4..7e964d5c57 100755 --- a/samples/python2/color_histogram.py +++ b/samples/python2/color_histogram.py @@ -31,7 +31,7 @@ if __name__ == '__main__': fn = sys.argv[1] except: fn = 0 - cam = video.create_capture(fn, fallback='synth:bg=../cpp/baboon.jpg:class=chess:noise=0.05') + cam = video.create_capture(fn, fallback='synth:bg=../data/baboon.jpg:class=chess:noise=0.05') while True: flag, frame = cam.read() diff --git a/samples/python2/deconvolution.py b/samples/python2/deconvolution.py index abc8dc181f..218efe883b 100755 --- a/samples/python2/deconvolution.py +++ b/samples/python2/deconvolution.py @@ -19,11 +19,11 @@ Usage: ESC - exit Examples: - deconvolution.py --angle 135 --d 22 data/licenseplate_motion.jpg + deconvolution.py --angle 135 --d 22 ../data/licenseplate_motion.jpg (image source: http://www.topazlabs.com/infocus/_images/licenseplate_compare.jpg) - deconvolution.py --angle 86 --d 31 data/text_motion.jpg - deconvolution.py --circle --d 19 data/text_defocus.jpg + deconvolution.py --angle 86 --d 31 ../data/text_motion.jpg + deconvolution.py --circle --d 19 ../data/text_defocus.jpg (image source: compact digital photo camera, no artificial distortion) @@ -70,7 +70,7 @@ if __name__ == '__main__': try: fn = args[0] except: - fn = 'data/licenseplate_motion.jpg' + fn = '../data/licenseplate_motion.jpg' win = 'deconvolution' diff --git a/samples/python2/dft.py b/samples/python2/dft.py index 792ebe1234..a1622b53e2 100755 --- a/samples/python2/dft.py +++ b/samples/python2/dft.py @@ -56,7 +56,7 @@ if __name__ == "__main__": if len(sys.argv)>1: im = cv2.imread(sys.argv[1]) else : - im = cv2.imread('../c/baboon.jpg') + im = cv2.imread('../data/baboon.jpg') print "usage : python dft.py " # convert to grayscale diff --git a/samples/python2/digits.py b/samples/python2/digits.py index 98fd8890f5..63dbb1e9d8 100755 --- a/samples/python2/digits.py +++ b/samples/python2/digits.py @@ -3,7 +3,7 @@ ''' SVM and KNearest digit recognition. -Sample loads a dataset of handwritten digits from 'digits.png'. +Sample loads a dataset of handwritten digits from '../data/digits.png'. Then it trains a SVM and KNearest classifiers on it and evaluates their accuracy. @@ -38,7 +38,7 @@ from common import clock, mosaic SZ = 20 # size of each digit is SZ x SZ CLASS_N = 10 -DIGITS_FN = 'data/digits.png' +DIGITS_FN = '../data/digits.png' def split2d(img, cell_size, flatten=True): h, w = img.shape[:2] diff --git a/samples/python2/distrans.py b/samples/python2/distrans.py index dc2a137c51..819a06c9b4 100755 --- a/samples/python2/distrans.py +++ b/samples/python2/distrans.py @@ -22,7 +22,7 @@ if __name__ == '__main__': try: fn = sys.argv[1] except: - fn = '../cpp/fruits.jpg' + fn = '../data/fruits.jpg' print __doc__ img = cv2.imread(fn, 0) diff --git a/samples/python2/facedetect.py b/samples/python2/facedetect.py index ab82f9a9f5..72b8561c3f 100755 --- a/samples/python2/facedetect.py +++ b/samples/python2/facedetect.py @@ -38,7 +38,7 @@ if __name__ == '__main__': cascade = cv2.CascadeClassifier(cascade_fn) nested = cv2.CascadeClassifier(nested_fn) - cam = create_capture(video_src, fallback='synth:bg=../cpp/lena.jpg:noise=0.05') + cam = create_capture(video_src, fallback='synth:bg=../data/lena.jpg:noise=0.05') while True: ret, img = cam.read() diff --git a/samples/python2/find_obj.py b/samples/python2/find_obj.py index 718a14fa57..fb1e0730d9 100755 --- a/samples/python2/find_obj.py +++ b/samples/python2/find_obj.py @@ -139,8 +139,8 @@ if __name__ == '__main__': try: fn1, fn2 = args except: - fn1 = '../cpp/box.png' - fn2 = '../cpp/box_in_scene.png' + fn1 = '../data/box.png' + fn2 = '../data/box_in_scene.png' img1 = cv2.imread(fn1, 0) img2 = cv2.imread(fn2, 0) diff --git a/samples/python2/floodfill.py b/samples/python2/floodfill.py index ef19141f8f..5152f30c18 100755 --- a/samples/python2/floodfill.py +++ b/samples/python2/floodfill.py @@ -22,7 +22,7 @@ if __name__ == '__main__': try: fn = sys.argv[1] except: - fn = '../cpp/fruits.jpg' + fn = '../data/fruits.jpg' print __doc__ img = cv2.imread(fn, True) diff --git a/samples/python2/gabor_threads.py b/samples/python2/gabor_threads.py index 6d10ffdb4b..b004fb7582 100755 --- a/samples/python2/gabor_threads.py +++ b/samples/python2/gabor_threads.py @@ -52,7 +52,7 @@ if __name__ == '__main__': try: img_fn = sys.argv[1] except: - img_fn = '../cpp/baboon.jpg' + img_fn = '../data/baboon.jpg' img = cv2.imread(img_fn) if img is None: diff --git a/samples/python2/grabcut.py b/samples/python2/grabcut.py index 42d9743bea..014dcc90e7 100644 --- a/samples/python2/grabcut.py +++ b/samples/python2/grabcut.py @@ -102,9 +102,9 @@ print __doc__ if len(sys.argv) == 2: filename = sys.argv[1] # for drawing purposes else: - print "No input image given, so loading default image, lena.jpg \n" + print "No input image given, so loading default image, ../data/lena.jpg \n" print "Correct Usage: python grabcut.py \n" - filename = '../cpp/lena.jpg' + filename = '../data/lena.jpg' img = cv2.imread(filename) img2 = img.copy() # a copy of original image diff --git a/samples/python2/hist.py b/samples/python2/hist.py index 41eec1d3a3..41f79984a1 100755 --- a/samples/python2/hist.py +++ b/samples/python2/hist.py @@ -57,7 +57,7 @@ if __name__ == '__main__': if len(sys.argv)>1: fname = sys.argv[1] else : - fname = '../cpp/lena.jpg' + fname = '../data/lena.jpg' print "usage : python hist.py " im = cv2.imread(fname) diff --git a/samples/python2/houghcircles.py b/samples/python2/houghcircles.py index 38ed6f3032..edf0b785a6 100755 --- a/samples/python2/houghcircles.py +++ b/samples/python2/houghcircles.py @@ -3,7 +3,7 @@ ''' This example illustrates how to use cv2.HoughCircles() function. Usage: ./houghcircles.py [] -image argument defaults to ../cpp/board.jpg +image argument defaults to ../data/board.jpg ''' import cv2 @@ -15,7 +15,7 @@ print __doc__ try: fn = sys.argv[1] except: - fn = "../cpp/board.jpg" + fn = "../data/board.jpg" src = cv2.imread(fn, 1) img = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY) diff --git a/samples/python2/houghlines.py b/samples/python2/houghlines.py index cf67945b19..5836bee547 100755 --- a/samples/python2/houghlines.py +++ b/samples/python2/houghlines.py @@ -2,7 +2,7 @@ ''' This example illustrates how to use Hough Transform to find lines Usage: ./houghlines.py [] -image argument defaults to ../cpp/pic1.png +image argument defaults to ../data/pic1.png ''' import cv2 import numpy as np @@ -12,7 +12,7 @@ import math try: fn = sys.argv[1] except: - fn = "../cpp/pic1.png" + fn = "../data/pic1.png" print __doc__ src = cv2.imread(fn) dst = cv2.Canny(src, 50, 200) diff --git a/samples/python2/inpaint.py b/samples/python2/inpaint.py index 5044afb899..4ff1ddb6e5 100755 --- a/samples/python2/inpaint.py +++ b/samples/python2/inpaint.py @@ -24,7 +24,7 @@ if __name__ == '__main__': try: fn = sys.argv[1] except: - fn = '../cpp/fruits.jpg' + fn = '../data/fruits.jpg' print __doc__ diff --git a/samples/python2/letter_recog.py b/samples/python2/letter_recog.py index ef8c7229c9..cf7aecebcd 100755 --- a/samples/python2/letter_recog.py +++ b/samples/python2/letter_recog.py @@ -153,7 +153,7 @@ if __name__ == '__main__': args, dummy = getopt.getopt(sys.argv[1:], '', ['model=', 'data=', 'load=', 'save=']) args = dict(args) args.setdefault('--model', 'rtrees') - args.setdefault('--data', '../cpp/letter-recognition.data') + args.setdefault('--data', '../data/letter-recognition.data') print 'loading data %s ...' % args['--data'] samples, responses = load_base(args['--data']) diff --git a/samples/python2/logpolar.py b/samples/python2/logpolar.py index 66082484d3..783c7b81a0 100644 --- a/samples/python2/logpolar.py +++ b/samples/python2/logpolar.py @@ -6,7 +6,7 @@ if __name__ == '__main__': try: fn = sys.argv[1] except: - fn = '../cpp/fruits.jpg' + fn = '../data/fruits.jpg' img = cv2.imread(fn) if img is None: diff --git a/samples/python2/morphology.py b/samples/python2/morphology.py index d9bdb7f1c2..76fa76c690 100755 --- a/samples/python2/morphology.py +++ b/samples/python2/morphology.py @@ -26,7 +26,7 @@ if __name__ == '__main__': try: fn = sys.argv[1] except: - fn = '../cpp/baboon.jpg' + fn = '../data/baboon.jpg' img = cv2.imread(fn) diff --git a/samples/python2/stereo_match.py b/samples/python2/stereo_match.py index 0803a3d12b..5b21617cca 100755 --- a/samples/python2/stereo_match.py +++ b/samples/python2/stereo_match.py @@ -32,8 +32,8 @@ def write_ply(fn, verts, colors): if __name__ == '__main__': print 'loading images...' - imgL = cv2.pyrDown( cv2.imread('../gpu/aloeL.jpg') ) # downscale images for faster processing - imgR = cv2.pyrDown( cv2.imread('../gpu/aloeR.jpg') ) + imgL = cv2.pyrDown( cv2.imread('../data/aloeL.jpg') ) # downscale images for faster processing + imgR = cv2.pyrDown( cv2.imread('../data/aloeR.jpg') ) # disparity range is tuned for 'aloe' image pair window_size = 3 diff --git a/samples/python2/texture_flow.py b/samples/python2/texture_flow.py index 0e1849ce3f..e47c4b8e5a 100755 --- a/samples/python2/texture_flow.py +++ b/samples/python2/texture_flow.py @@ -18,7 +18,7 @@ if __name__ == '__main__': try: fn = sys.argv[1] except: - fn = 'data/starry_night.jpg' + fn = '../data/starry_night.jpg' img = cv2.imread(fn) if img is None: diff --git a/samples/python2/video.py b/samples/python2/video.py index 187bb6d512..227b13f371 100755 --- a/samples/python2/video.py +++ b/samples/python2/video.py @@ -20,8 +20,8 @@ Usage: - synth: for procedural video Synth examples: - synth:bg=../cpp/lena.jpg:noise=0.1 - synth:class=chess:bg=../cpp/lena.jpg:noise=0.1:size=640x480 + synth:bg=../data/lena.jpg:noise=0.1 + synth:class=chess:bg=../data/lena.jpg:noise=0.1:size=640x480 Keys: ESC - exit @@ -130,8 +130,8 @@ classes = dict(chess=Chess) presets = dict( empty = 'synth:', - lena = 'synth:bg=../cpp/lena.jpg:noise=0.1', - chess = 'synth:class=chess:bg=../cpp/lena.jpg:noise=0.1:size=640x480' + lena = 'synth:bg=../data/lena.jpg:noise=0.1', + chess = 'synth:class=chess:bg=../data/lena.jpg:noise=0.1:size=640x480' ) diff --git a/samples/python2/watershed.py b/samples/python2/watershed.py index c6247da22c..75a24a6538 100755 --- a/samples/python2/watershed.py +++ b/samples/python2/watershed.py @@ -79,6 +79,6 @@ if __name__ == '__main__': try: fn = sys.argv[1] except: - fn = '../cpp/fruits.jpg' + fn = '../data/fruits.jpg' print __doc__ App(fn).run() diff --git a/samples/tapi/bgfg_segm.cpp b/samples/tapi/bgfg_segm.cpp index 17a511cddc..40587713b7 100644 --- a/samples/tapi/bgfg_segm.cpp +++ b/samples/tapi/bgfg_segm.cpp @@ -18,7 +18,7 @@ int main(int argc, const char** argv) { CommandLineParser cmd(argc, argv, "{ c camera | false | use camera }" - "{ f file | 768x576.avi | input video file }" + "{ f file | ../data/768x576.avi | input video file }" "{ t type | mog2 | method's type (knn, mog2) }" "{ h help | false | print help message }" "{ m cpu_mode | false | press 'm' to switch OpenCL<->CPU}"); diff --git a/samples/tapi/hog.cpp b/samples/tapi/hog.cpp index 3ccc41b185..e361c2b735 100644 --- a/samples/tapi/hog.cpp +++ b/samples/tapi/hog.cpp @@ -71,7 +71,7 @@ int main(int argc, char** argv) "{ h help | false | print help message }" "{ i input | | specify input image}" "{ c camera | -1 | enable camera capturing }" - "{ v video | 768x576.avi | use video as input }" + "{ v video | ../data/768x576.avi | use video as input }" "{ g gray | false | convert image to gray one or not}" "{ s scale | 1.0 | resize the image before detect}" "{ o output | | specify output path when input is images}"; diff --git a/samples/tapi/squares.cpp b/samples/tapi/squares.cpp index 87a3894b93..e18e533d66 100644 --- a/samples/tapi/squares.cpp +++ b/samples/tapi/squares.cpp @@ -141,7 +141,7 @@ static UMat drawSquaresBoth( const UMat& image, int main(int argc, char** argv) { const char* keys = - "{ i input | pic1.png | specify input image }" + "{ i input | ../data/pic1.png | specify input image }" "{ o output | squares_output.jpg | specify output save path}" "{ h help | false | print help message }" "{ m cpu_mode | false | run without OpenCL }";