More debugging help: the "<<" operator has been redefined for MeteoFilter, MeteoProcessor and BufferedIOHandler. Since the Config object is copied all over the place, it is not always printed.

Several 1D statistical methods has been implemented while the existing ones have been made nodata safe.

Added a redefinition of the << operator for IOPlugin and IOHandler. This should be convenient for debugging!

Some small optimizations have been brought into the spatial interpolations following some tests with cachegrind. Nothing huge, but small improvements.

The linear regression implementation is now able to remove a variable number of "invalid" points based on the initial size of the data set. Some extra weighting methods have been implemented (but are not yet used).

Several speed optimizations have been brought to the 2D interpolations (using the const keyword when possible, etc). The Quake3 1/x^2 approximation has been implemented for the IDW_core and brings a slight loss of precision (1e-6 in relative error in real life tests) while boasting a huge reduction of computational time (factor of 3 when called within Alpine3D with its own overhead).

The documentation can now be build and not installed (instead of linking building and installation as previously done)

The array memory alignement has been fixed for Array2D (this was the only that was wrongly aligned). This is a fix to issue 43

The WIND_CURV spatial interpolations algorithm now intelligently checks if the curvatures are available or not and gives a warning if not (and also take a 0 grade so that it would not be used).

The SMET plugin now uses the user provided coordinate system (as a default value for input and as a target coordinate system for output).

Overall all include statements within in the library have been replaced by angle brackets, the default install path for the include file is $CMAKE_INSTALL_DIR/include/meteoio, the meteoio libraries (static and shared) will be installed in $CMAKE_INSTALL_DIR/lib per default.

The plugins will be installed in the subdirectory $CMAKE_INSTALL_DIR/lib/meteoio/plugins

Then, the remaining namespace issues with doxygen have been fixed, by enclosing the full class implementation in the namespace (as seen for the libstdc++). This removes all these irritating issues. But the popc version has been broken by the change (as seen in LegacyIO).

Changed the name of the Date_IO class to Date. In case of namespace conflicts, just use mio::Date to reference the MeteoIO Date class.

The long wave radiation parameter is now ILWR instead of LWR (since some might have net long wave and this is also closer to short wave (with ISWR)).

The << operator has been overloaded for a few types (Arrays, Grids, Coords, Dates, Meteo and Station data) and the to_String() methods removed (except for Dates because it might make sense there to get a string) as a way to provide easy debugging output. This makes the meteo_reading example even simpler! 

The physical filter algorithms (as defined in libinterpol2D) have seen their interface modified so they all follow the same logic (for the order and naming of the arguments).

The documentation has been cleaned up (the warnings have been fixed, some missing items added).

The arrays and grids now have a "print" method that prints their content to screen (usefull for debugging). The Coords class also has this method (as required to print the grid objects).

A "using namespace std" was found in ImisIO.h and has been removed. A few comments/indentation/clean up have been done (including in the doc/examples)

The quality rating sorting was broken and has been fixed. The RH interpolation method was not properly working and has been fixed (using the wrong vector for input data). The naming of the number of stations to be used has been made more consistent between the various algorithms and an improved information output has been added.

Kicked out all legacy code for the spatial interpolation - cleaned up libinterpol2D.* and Meteo2DInterpolator.* - in Coords.cc there was an ambigous if condition lacking a few brackets. Added comments to illustrate the algorithms in InterpolationAlgorithms.cc

The new interpolations interface with all algorithms that used to reside within libinterpol2D exclusively. Every algorithm is an own class derived from InterpolationAlgorithm abstract base class. An AlgorithmFactory instantiates the required algorithm within class Meteo2DInterpolator. The user needs to configured which algorithms to be used within the section [Interpolations2D] in the io.ini:

[Interpolations2D]
TA::algorithms = cst cst_lapse idw_lapse
TA::cst_lapse = -0.008

libinterpol1D has a new function for the calculation of arithmetic means. all of libinterpol2D is static. the rest will be thrown out in the coming days.

The new Coords object is now used by all grids (Grid2DObject, Grid3DObject, DEMObject) as well as by all plugins (but checking proper operation was not possible for GSNIO because of missing libraries on my system...). The documentation has been updated as well as the code examples. A few extra methods have been added when usage has shown the need/convenience of having them (specially for standardazing some processing called by the plugins). A few small bugs have been fixed (possibility of not updating or improperly updating the coordinates in some rare cases).

The proper marshalling for Grid3DObject has been implemented (it was more or less a dummy method until now). One bug has been fixed for Proj4 support. The code of most of the plugins has been cleaned up in order to get rid of the few remaining "using namespace" in header files. 

The class Stationdata now properly uses the new Coords class. All usual dependencies have been fixed (A3DIO.cc) but not (yet) the optional plugins. The Coords class has been modified so that it computes the matching coordinates as soon as possible instead of the previous implementation that was delaying it as much as possible (thus making "const Coords..." impossible).

The includes have been cleaned up (compilation was failing because of multiple "using namespace" in header files) and all "using namespace" have been removed from header files (please don't put any of these back!!). The doxygen comments has been updated.

The DEMObject has been modified so that it can now correctly handle grids with nodata values when computing slope/azimuth/curvature (this is in effect the fix for issue 15). This is "best effort" approach: several strategies are applied if some points are missing in order to still be able to compute as much as possible the parameters for their neighbours (if the latter contain an elevation!). The resulting grids are consistent for slopes (ie: if the slope can be computed, then the azimuth too and the normals too) and the curvature is handled separately (ie: it is possible to find points where ONLY the curvature is nodata).

Several inappropriate behaviors have been fixed for cells next to a nodata point (or next to an edge). This should have fixed issue 7.

The necessary check have been added to libinterpol2D:SimpleDEMWindInterpolate

Oups... My previous commit was wrong, this is the commit that fixes the compilation bugs in libinterpol2D.

A mistake has been found in BoschungIO: the key for precipitation was wrong (we were reading the precipitation type as a precipitation amount, which was quite bad for the simulation!).

A few missing cases of nodata have been identified (thanks Cyril!) and fixed in libinterpol2D

A new slope computation algorithm has bee added: CARD It computes the slope using Corripio and then discretizes the azimuth along 8 cardinal directions and the slope by degrees. This should be all that GEOtop needs for its drainage direction (then simply calling a dem.update("CARDINAL")).

The copyright notices have been put in place in all files (headers and cc) with proper attribution of copyright.

The documentation has been improved, specially fixing issue 22. Warning messages of doxygen have been fixed. An example subdirectory has been created in /doc and contains (currently) 2 examples of code using MeteoIO.

The doxygen comments have been fixed and largely expanded: the welcome page is now populated and some general documentation proposed. 

The prototypes of the filters have been fixed (doxygen was complaining) so that we always use std:: when necessary.

The Grid3DObject checkCoordinates has been implemented along the same lines as Grid2DObject. The altitude is still missing though...

The check for POPC++ has been added to the autotools configuration. 

A small improvement to the way the A3DIO plugins handles incoming nodata has been done. A few HACKS have been fixed and removed. Some error messages (in libinterpol2D) have been improved, their printf relpaced by a std::cerr and an extra check (using assert) has been added so that no Td would be computed if Rh<0 (and we would throw an exception).

The constructor for local grid in MapProj has been changed and its prototype modified. It should now make more sense and allow using LOCAL in io.ini like any other projection keyword.

The code that was doing IO buffering in LegacyIO when POPC was used has been deleted (this is not the right place to do caching). A method prototype has been slightly tweaked (using const string instead of char*).

Since Laws.c/h is already a file that is part of Snowpack and since making it a separate library does not make so much sense (it is quite small and only 3 short functions from it are used in MeteoIO), the necessary code has been transfered to libinterpol2D and these two files have been deleted.

A warning in IOUtils has been silenced.

A new define (DEBUG_ARITHM) has been added that activates the non-catching of arithmetic exceptions. This is specially required for parallel execution when the code from the library might execute in a process different from the caller (thus not having the required flag set on the cpu for its process). This is enabled/disabled in the Makefile.in (or the Makefile for the end user). 

The std:: namespace declaration has been added to a lots of places, making the "use namespace std" usage irrelevant (and thus suppressed). Other namespaces that were called with a "use" have been found not to be used anymore and therefore also removed.

Several bugs in the doxygen comments have been fixed: typo (misplaced space), comments not matching the declaration anymore, etc Doxygen now executes without warnings.

The spatial interpolation class has been modified so that it works with Grid2DObjects instead of Array2D. This makes room for being able (one day) to work with a DEM bigger than the requested grid... (yes, this would be so sexy!)

Warnings have been silenced in GrassIO.cc

A minor initialization bug was fixed in DEMObject. The new wind interpolation method has been disabled by default (not safe to use before making sure that it does not create unphysical behavior). A minor optimization has been implemented in libinterpol2D: if the DEM min and max altitudes are know, the median elevation is now used as a reference elevation for reprojections.

The doxygen comments have been fixed and enhanced.

The meteoio_demo program has been updated to fully use the DEMObject.

* Changed nomenclature in CArray2D<T> to reflect STL conventions:
	GetSize() renamed to size()
	Create() renamed to resize()
	Destroy() renamed to clear()

The new wind interpolation method that uses the local terrain's curvature has been merged. It comes from (Liston-Elder, 2006) and has been implemented by Gael Rosset (HES-SO) duri8ng his Bachelor internship. It still has to be tested in order to see how it performs compared to measurements...

The DEMObject has been tweaked a little more (fixing some issues with constructors), as well as some code tagging. 

The spatial interpolations now use a DEMObject for the dem.

A new class has been created, DEMObject. It inherits from Grid2DObject but also contains DEM specific functionality: computation of slope, azimuth, normal vector's components and curvature. 

A new method has been created for both DEMObject and Grid2DObject: the sub() method that allows extracting a subset of a given grid (usefull for distributed computing).

The Grid2DObject class has been tweaked in order to make it rely on IOUtils::nodata instead of its own nodata. The required changes have been made in A3DIO and libinterpol2D.

The Makefile.in and configure.ac have been adapted and slightly improved (still a long way to go...)

The code for optional reading of wind directions has been activated in A3DIO. Some dead, commented code has been removed. 

The first version of the required code for fancier wind interpolation has been added. This highlights the need for a redesign of the structure of the spatial interpolations interface.

Some issues with the local grid computation have been fixed. Namely, its was stupid to compute the x-axis distance at 0 deg latitude... The coordinates are now computed using distance and bearing instead of two distances.

A3DIO now checks if the provided xcoord/ycoord and lat/long are consistent (both being given in meteo1d). If not, we throw an exception.

meteoio_demo has been updated to use the local grid instead of swiss coordinates (the issue of the output grid still remains unsolved).

The Grid2DObjects have been modified by adding a latitude and a longitude field. These have to be provided alongside the other parameters, the goal being to consider that the east and north coordinates are convenience coordinates (for example for calculating distances), but that the reference coordinates are latitude/longitude.

The required changes have been implemented into BoschungIO and A3DIO. The latter now also computes latitude/longitude automatically out of the CH1903 coordinates (after checking if the lat/long are not already provided, like for meteo1d). 

The required formulas for implementing a local grid system have been put into IOUtils. These allow to compute the distance between two points, given their lat/long or the coordinate of a point given a starting lat/long, a distance and a bearing. This allows to define a local grid system, for example using the lower left corner of the dem as the origin.

The convertString for Date_IO is now used by meteoio_demo and createA3DFiles instead of a hand made equivalent. 

The Makefiles have been tweaked in order to remove unecessay dependencies (in test) and to add a missing compilation rule (main Makefile). 

The same Laws.c as in Snowpack has been brought into MeteoIO and the necessary changes have been made. 

Nothing special, just some re-indentation in order to make the code lines clear and easy to run and understand.

The documentation can now be built from the Makefile (that also contains a help section). By default, the BOSCUNG and IMIS plugins are disabled.

The necessary skeleton has been added to Meteo2DInterpolator and libinterpol2D so that the wind interpolation model can easily be implemented.

The whole library has been given its new name and several classes have been renamed in order to better match their purpose. The Makefile has been modified accordingly.