Adds lens distortion correction methods from @nghia-vo for projection and sinograms.

Add a simple extension of the gradient descent method for solving Tikhonov regularization of the form:

Example of usage:

recon = tomopy.recon(
    proj, theta, center=rot_center, algorithm='tikh',
    reg_data=v, reg_par=[-1, alpha], num_iter=32,
) # where -1 refers to automatic gradient step search 

This release contains an update to the lprec wrapper and bug fixes for the documentation and the new GPU accelerated code.

• Version is now pulled from git tags instead of from VERSION file
• dxchange is no longer a required dependency
• CMake build system to handle addition of code in two new languages: C++ and CUDA
• Python bindings to C++/CUDA code still go through C interface (i.e. no direct binding)
• SIRT and MLEM have been implemented on the GPU and CPU using rotation-based algorithm
  • GPU support has been validated for Windows and Linux
  • CPU version uses OpenCV for rotation
    • OpenCV distributed via conda + MinGW on Windows does not work. Use MSVC compiler on Windows.
  • GPU version uses NPP for rotation
  • benchmarking on NVIDIA P100: ~11x slower than gridrec but vastly improved reconstruction quality
  • benchmarking on NVIDIA V100: per-slice speed-up over ray-based algorithm is ~650x, e.g. a TomoBank reconstruction (2048p + 1,500 proj angles) formerly requiring ~6.5 hours is completed in ~40 seconds
• Support for Microsoft Visual C++ (MSVC) compiler
  • Implemented gridrec in C++ (uses std::complex) which is enabled by default on Windows
• To enable new algorithms, include accelerated=True to tomopy.recon for SIRT and MLEM
  • there are other options available but unless there is an explicitly understanding the effects of the other parameters, use the defaults.
• Multi-GPU support is available
  • Automatic detection of number of available devices
  • Multiple threads started at Python level automatically spread out over the number of available GPUs
• Secondary thread-pools created in C++ code to provide highly efficient communication with the GPU and additional parallelism on the CPU.
  • When running on the GPU, set ncore parameter to tomopy.recon to the number of GPUs available.
  • Each "Python" thread creates a unique secondary thread-pool with a default size of 2 * number-of-cpus. This is intentional and, in general, the larger the secondary thread-pool, the more efficiently the CPU-GPU communication latency is hidden. However, in general, more than 24 threads per thread-pool provides no benefit (all latency is essentially hidden at that point)

• NEW: Detector drift auto detection for APS-1ID beamline data (#367)
• BLD: Change build targets to Python 2.7, 3.6, 3.7

• NEW: Arguments added for alignment functions (#352)
• NEW: Benchmarking via PyCTest
• ENH: Optimizations in utils.c
• BLD: Initial work transitioning build system to CMake

• Added Windows build support for python>=3.5
• Updated build system to use GNU Make
• Add Expectation Maximization, Total Variation, Log-Polar, and Gradient descent reconstruction algorithms
• Rebased master branch to remove history of large unused files and reduce repository size

Updates

• Removed all remnants of pyfftw, now that mkl_fft is on conda-forge.
• Moved the logic of loading fft implementation to _fft_loader.py called from init.py.
• Optimizations to rotation.py to minimize creation of intermediary numpy arrays.
• Conda-forge channel is set-up as the default distribution channel.
• Alignment is now available and the FAQ is edited correspondingly.
• Add UFO wrapper and adapt documentation.
• Wrote more efficient code for _reciprocal_grid and _reciprocal_coord.
• Encapsulated uses of fft, ifft and fft2, ifft2 by replacing direct calls to pyfftw.interfaces.numpy functions with calls to wrapper functions defined in tomopy.util.misc.
• Wrote definitions of these functions in terms of mkl_fft functions, in terms of pyfftw functions and in terms of numpy.fft functions as fall-back.
• Supported in-place operations with overwrite_input=True.
• in _retrieve_phase ifft2 is now done in-place for efficiency.
• Used floating point functions, i.e. ceilf, sinf, cosf, etc. instead
  of functions with doubles signature, i.e. ceil, sin, cos, etc..
• Replaced use of lroundf(x) with (int) roundf(x).
• The latter one can be vectorized, while the former can not.
• Icc-specific pragmas get applied to loops to assist vectorization
  if Intel C Compiler is used to compile the code.
• The loop updating H was split in two to avoid genuine vector dependencies
  inhibiting vectorization by ICC.
• Use 64-bytes aligned memory allocation from X/Open-7 posix standard
  instead of using fftw allocator.
• unctions _elipsoid and _transform now use numpy arrays for intermediate computations rather than Python lists.
• Added two "re-projection" based algorithms for automated vertical and horizontal alignment of projection images.
• Changed smin and smax arguments in call to _search_coarse in the large sinograms case to smin / 4.0 and smax / 4.0 in order to incorporate downsampling.
• VisibleDeprecationWarning: using a non-integer number instead of an integer will result in an error in the future.

New modules

• alignment: Automated alignment of projection images.

New dependencies

• numexpr
• futures # [py2k]