Add the full source of BambuStudio

using version 1.0.10

src/BambuStudio.hpp

@@ -0,0 +1,52 @@
+#ifndef SLIC3R_HPP
+#define SLIC3R_HPP
+
+#include "libslic3r/Config.hpp"
+#include "libslic3r/Model.hpp"
+
+namespace Slic3r {
+
+namespace IO {
+	enum ExportFormat : int {
+        AMF,
+        OBJ,
+        STL,
+        // SVG,
+        TMF,
+        Gcode
+    };
+}
+
+class CLI {
+public:
+    int run(int argc, char **argv);
+
+private:
+    DynamicPrintAndCLIConfig    m_config;
+    DynamicPrintConfig			m_print_config;
+    DynamicPrintConfig          m_extra_config;
+    std::vector<std::string>    m_input_files;
+    std::vector<std::string>    m_actions;
+    std::vector<std::string>    m_transforms;
+    std::vector<Model>          m_models;
+
+    bool setup(int argc, char **argv);
+
+    /// Prints usage of the CLI.
+    void print_help(bool include_print_options = false, PrinterTechnology printer_technology = ptAny) const;
+
+    /// Exports loaded models to a file of the specified format, according to the options affecting output filename.
+    bool export_models(IO::ExportFormat format);
+    //BBS: add export_project function
+    bool export_project(Model *model, std::string& path, PlateDataPtrs &partplate_data, std::vector<Preset*>& project_presets,
+        std::vector<ThumbnailData*>& thumbnails, std::vector<ThumbnailData*>& calibration_thumbnails,
+        std::vector<PlateBBoxData*>& plate_bboxes, const DynamicPrintConfig* config);
+
+    bool has_print_action() const { return m_config.opt_bool("export_gcode") || m_config.opt_bool("export_sla"); }
+
+    std::string output_filepath(const Model &model, IO::ExportFormat format) const;
+};
+
+}
+
+#endif

src/BambuStudio_app_msvc.cpp

@@ -0,0 +1,313 @@
+// Why?
+#define _WIN32_WINNT 0x0502
+// The standard Windows includes.
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <Windows.h>
+#include <shellapi.h>
+#include <wchar.h>
+
+
+
+#ifdef SLIC3R_GUI
+extern "C"
+{
+    // Let the NVIDIA and AMD know we want to use their graphics card
+    // on a dual graphics card system.
+    __declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;
+    __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
+}
+#endif /* SLIC3R_GUI */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef SLIC3R_GUI
+    #include <GL/GL.h>
+#endif /* SLIC3R_GUI */
+
+#include <string>
+#include <vector>
+
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/classification.hpp>
+
+#include <stdio.h>
+
+#ifdef SLIC3R_GUI
+class OpenGLVersionCheck
+{
+public:
+    std::string version;
+    std::string glsl_version;
+    std::string vendor;
+    std::string renderer;
+
+    HINSTANCE   hOpenGL = nullptr;
+    bool 		success = false;
+
+    bool load_opengl_dll()
+    {
+        MSG      msg     = {0};
+        WNDCLASS wc      = {0};
+        wc.lpfnWndProc   = OpenGLVersionCheck::supports_opengl2_wndproc;
+        wc.hInstance     = (HINSTANCE)GetModuleHandle(nullptr);
+        wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND);
+        wc.lpszClassName = L"BambuStudio_opengl_version_check";
+        wc.style = CS_OWNDC;
+        if (RegisterClass(&wc)) {
+            HWND hwnd = CreateWindowW(wc.lpszClassName, L"BambuStudio_opengl_version_check", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, wc.hInstance, (LPVOID)this);
+            if (hwnd) {
+                message_pump_exit = false;
+                while (GetMessage(&msg, NULL, 0, 0 ) > 0 && ! message_pump_exit)
+                    DispatchMessage(&msg);
+            }
+        }
+        return this->success;
+    }
+
+    void unload_opengl_dll()
+    {
+        if (this->hOpenGL) {
+            BOOL released = FreeLibrary(this->hOpenGL);
+            if (released)
+                printf("System OpenGL library released\n");
+            else
+                printf("System OpenGL library NOT released\n");
+            this->hOpenGL = nullptr;
+        }
+    }
+
+    bool is_version_greater_or_equal_to(unsigned int major, unsigned int minor) const
+    {
+        // printf("is_version_greater_or_equal_to, version: %s\n", version.c_str());
+        std::vector<std::string> tokens;
+        boost::split(tokens, version, boost::is_any_of(" "), boost::token_compress_on);
+        if (tokens.empty())
+            return false;
+
+        std::vector<std::string> numbers;
+        boost::split(numbers, tokens[0], boost::is_any_of("."), boost::token_compress_on);
+
+        unsigned int gl_major = 0;
+        unsigned int gl_minor = 0;
+        if (numbers.size() > 0)
+            gl_major = ::atoi(numbers[0].c_str());
+        if (numbers.size() > 1)
+            gl_minor = ::atoi(numbers[1].c_str());
+        // printf("Major: %d, minor: %d\n", gl_major, gl_minor);
+        if (gl_major < major)
+            return false;
+        else if (gl_major > major)
+            return true;
+        else
+            return gl_minor >= minor;
+    }
+
+protected:
+    static bool message_pump_exit;
+
+    void check(HWND hWnd)
+    {
+        hOpenGL = LoadLibraryExW(L"opengl32.dll", nullptr, 0);
+        if (hOpenGL == nullptr) {
+            printf("Failed loading the system opengl32.dll\n");
+            return;
+        }
+
+        typedef HGLRC 		(WINAPI *Func_wglCreateContext)(HDC);
+        typedef BOOL 		(WINAPI *Func_wglMakeCurrent  )(HDC, HGLRC);
+        typedef BOOL     	(WINAPI *Func_wglDeleteContext)(HGLRC);
+        typedef GLubyte* 	(WINAPI *Func_glGetString     )(GLenum);
+
+        Func_wglCreateContext 	wglCreateContext = (Func_wglCreateContext)GetProcAddress(hOpenGL, "wglCreateContext");
+        Func_wglMakeCurrent 	wglMakeCurrent 	 = (Func_wglMakeCurrent)  GetProcAddress(hOpenGL, "wglMakeCurrent");
+        Func_wglDeleteContext 	wglDeleteContext = (Func_wglDeleteContext)GetProcAddress(hOpenGL, "wglDeleteContext");
+        Func_glGetString 		glGetString 	 = (Func_glGetString)	  GetProcAddress(hOpenGL, "glGetString");
+
+        if (wglCreateContext == nullptr || wglMakeCurrent == nullptr || wglDeleteContext == nullptr || glGetString == nullptr) {
+            printf("Failed loading the system opengl32.dll: The library is invalid.\n");
+            return;
+        }
+
+        PIXELFORMATDESCRIPTOR pfd =
+        {
+            sizeof(PIXELFORMATDESCRIPTOR),
+            1,
+            PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
+            PFD_TYPE_RGBA,            	// The kind of framebuffer. RGBA or palette.
+            32,                        	// Color depth of the framebuffer.
+            0, 0, 0, 0, 0, 0,
+            0,
+            0,
+            0,
+            0, 0, 0, 0,
+            24,                        	// Number of bits for the depthbuffer
+            8,                        	// Number of bits for the stencilbuffer
+            0,                        	// Number of Aux buffers in the framebuffer.
+            PFD_MAIN_PLANE,
+            0,
+            0, 0, 0
+        };
+
+        HDC ourWindowHandleToDeviceContext = ::GetDC(hWnd);
+        // Gdi32.dll
+        int letWindowsChooseThisPixelFormat = ::ChoosePixelFormat(ourWindowHandleToDeviceContext, &pfd);
+        // Gdi32.dll
+        SetPixelFormat(ourWindowHandleToDeviceContext, letWindowsChooseThisPixelFormat, &pfd);
+        // Opengl32.dll
+        HGLRC glcontext = wglCreateContext(ourWindowHandleToDeviceContext);
+        wglMakeCurrent(ourWindowHandleToDeviceContext, glcontext);
+        // Opengl32.dll
+        const char *data = (const char*)glGetString(GL_VERSION);
+        if (data != nullptr)
+            this->version = data;
+        // printf("check -version: %s\n", version.c_str());
+        data = (const char*)glGetString(0x8B8C); // GL_SHADING_LANGUAGE_VERSION
+        if (data != nullptr)
+            this->glsl_version = data;
+        data = (const char*)glGetString(GL_VENDOR);
+        if (data != nullptr)
+            this->vendor = data;
+        data = (const char*)glGetString(GL_RENDERER);
+        if (data != nullptr)
+            this->renderer = data;
+        // Opengl32.dll
+        wglDeleteContext(glcontext);
+        ::ReleaseDC(hWnd, ourWindowHandleToDeviceContext);
+        this->success = true;
+    }
+
+    static LRESULT CALLBACK supports_opengl2_wndproc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+    {
+        switch(message)
+        {
+        case WM_CREATE:
+        {
+            CREATESTRUCT *pCreate = reinterpret_cast<CREATESTRUCT*>(lParam);
+            OpenGLVersionCheck *ogl_data = reinterpret_cast<OpenGLVersionCheck*>(pCreate->lpCreateParams);
+            ogl_data->check(hWnd);
+            DestroyWindow(hWnd);
+            return 0;
+        }
+        case WM_NCDESTROY:
+            message_pump_exit = true;
+            return 0;
+        default:
+            return DefWindowProc(hWnd, message, wParam, lParam);
+        }
+    }
+};
+
+bool OpenGLVersionCheck::message_pump_exit = false;
+#endif /* SLIC3R_GUI */
+
+extern "C" {
+    typedef int (__stdcall *Slic3rMainFunc)(int argc, wchar_t **argv);
+    Slic3rMainFunc bambustudio_main = nullptr;
+}
+
+extern "C" {
+#ifdef SLIC3R_WRAPPER_NOCONSOLE
+int APIENTRY wWinMain(HINSTANCE /* hInstance */, HINSTANCE /* hPrevInstance */, PWSTR /* lpCmdLine */, int /* nCmdShow */)
+{
+    int 	  argc;
+    wchar_t **argv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
+#else
+int wmain(int argc, wchar_t **argv)
+{
+#endif
+    // Allow the asserts to open message box, such message box allows to ignore the assert and continue with the application.
+    // Without this call, the seemingly same message box is being opened by the abort() function, but that is too late and
+    // the application will be killed even if "Ignore" button is pressed.
+    _set_error_mode(_OUT_TO_MSGBOX);
+
+    std::vector<wchar_t*> argv_extended;
+    argv_extended.emplace_back(argv[0]);
+
+#ifdef SLIC3R_WRAPPER_GCODEVIEWER
+    wchar_t gcodeviewer_param[] = L"--gcodeviewer";
+    argv_extended.emplace_back(gcodeviewer_param);
+#endif /* SLIC3R_WRAPPER_GCODEVIEWER */
+
+#ifdef SLIC3R_GUI
+    // Here one may push some additional parameters based on the wrapper type.
+    bool force_mesa = false;
+#endif /* SLIC3R_GUI */
+    for (int i = 1; i < argc; ++ i) {
+#ifdef SLIC3R_GUI
+        if (wcscmp(argv[i], L"--sw-renderer") == 0)
+            force_mesa = true;
+        else if (wcscmp(argv[i], L"--no-sw-renderer") == 0)
+            force_mesa = false;
+#endif /* SLIC3R_GUI */
+        argv_extended.emplace_back(argv[i]);
+    }
+    argv_extended.emplace_back(nullptr);
+
+#ifdef SLIC3R_GUI
+    OpenGLVersionCheck opengl_version_check;
+    bool load_mesa =
+        // Forced from the command line.
+        force_mesa ||
+        // Running over a rempote desktop, and the RemoteFX is not enabled, therefore Windows will only provide SW OpenGL 1.1 context.
+        // In that case, use Mesa.
+        ::GetSystemMetrics(SM_REMOTESESSION) ||
+        // Try to load the default OpenGL driver and test its context version.
+        ! opengl_version_check.load_opengl_dll() || ! opengl_version_check.is_version_greater_or_equal_to(2, 0);
+#endif /* SLIC3R_GUI */
+
+    wchar_t path_to_exe[MAX_PATH + 1] = { 0 };
+    ::GetModuleFileNameW(nullptr, path_to_exe, MAX_PATH);
+    wchar_t drive[_MAX_DRIVE];
+    wchar_t dir[_MAX_DIR];
+    wchar_t fname[_MAX_FNAME];
+    wchar_t ext[_MAX_EXT];
+    _wsplitpath(path_to_exe, drive, dir, fname, ext);
+    _wmakepath(path_to_exe, drive, dir, nullptr, nullptr);
+
+#ifdef SLIC3R_GUI
+// https://wiki.qt.io/Cross_compiling_Mesa_for_Windows
+// http://download.qt.io/development_releases/prebuilt/llvmpipe/windows/
+    if (load_mesa) {
+        opengl_version_check.unload_opengl_dll();
+        wchar_t path_to_mesa[MAX_PATH + 1] = { 0 };
+        wcscpy(path_to_mesa, path_to_exe);
+        wcscat(path_to_mesa, L"mesa\\opengl32.dll");
+        printf("Loading MESA OpenGL library: %S\n", path_to_mesa);
+        HINSTANCE hInstance_OpenGL = LoadLibraryExW(path_to_mesa, nullptr, 0);
+        if (hInstance_OpenGL == nullptr) {
+            printf("MESA OpenGL library was not loaded\n");
+        } else
+            printf("MESA OpenGL library was loaded sucessfully\n");
+    }
+#endif /* SLIC3R_GUI */
+
+
+    wchar_t path_to_slic3r[MAX_PATH + 1] = { 0 };
+    wcscpy(path_to_slic3r, path_to_exe);
+    wcscat(path_to_slic3r, L"BambuStudio.dll");
+//	printf("Loading Slic3r library: %S\n", path_to_slic3r);
+    HINSTANCE hInstance_Slic3r = LoadLibraryExW(path_to_slic3r, nullptr, 0);
+    if (hInstance_Slic3r == nullptr) {
+        printf("BambuStudio.dll was not loaded, error=%d\n", GetLastError());
+        return -1;
+    }
+
+    // resolve function address here
+    bambustudio_main = (Slic3rMainFunc)GetProcAddress(hInstance_Slic3r,
+#ifdef _WIN64
+        // there is just a single calling conversion, therefore no mangling of the function name.
+        "bambustudio_main"
+#else	// stdcall calling convention declaration
+        "_bambustudio_main@8"
+#endif
+        );
+    if (bambustudio_main == nullptr) {
+        printf("could not locate the function bambustudio_main in BambuStudio.dll\n");
+        return -1;
+    }
+    // argc minus the trailing nullptr of the argv
+    return bambustudio_main((int)argv_extended.size() - 1, argv_extended.data());
+}
+}

src/BaseException.cpp

@@ -0,0 +1,357 @@
+#include "BaseException.h"
+#include <iomanip>
+#include <string>
+#include <sstream>
+#include <iostream>
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <boost/log/trivial.hpp>
+#include <boost/format.hpp>
+
+static std::string g_log_folder;
+static std::atomic<int> g_crash_log_count = 0;
+static std::mutex g_dump_mutex;
+
+CBaseException::CBaseException(HANDLE hProcess, WORD wPID, LPCTSTR lpSymbolPath, PEXCEPTION_POINTERS pEp):
+	CStackWalker(hProcess, wPID, lpSymbolPath)
+{
+	if (NULL != pEp)
+	{
+		m_pEp = new EXCEPTION_POINTERS;
+		CopyMemory(m_pEp, pEp, sizeof(EXCEPTION_POINTERS));
+	}
+	output_file = new boost::nowide::ofstream();
+	std::time_t t = std::time(0);
+	std::tm* now_time = std::localtime(&t);
+	std::stringstream buf;
+
+	if (!g_log_folder.empty()) {
+		buf << std::put_time(now_time, "crash_%a_%b_%d_%H_%M_%S_") <<g_crash_log_count++ <<".log";
+		auto log_folder = (boost::filesystem::path(g_log_folder) / "log").make_preferred();
+		if (!boost::filesystem::exists(log_folder)) {
+		    boost::filesystem::create_directory(log_folder);
+	    }
+		auto crash_log_path = boost::filesystem::path(log_folder / buf.str()).make_preferred();
+		std::string log_filename = crash_log_path.string();
+		output_file->open(log_filename, std::ios::out | std::ios::app);
+	}
+}
+
+CBaseException::~CBaseException(void)
+{
+	if (output_file) {
+		output_file->close();
+		delete output_file;
+	}
+}
+
+
+//BBS set crash log folder
+void CBaseException::set_log_folder(std::string log_folder)
+{
+	g_log_folder = log_folder;
+}
+
+void CBaseException::OutputString(LPCTSTR lpszFormat, ...)
+{
+	TCHAR szBuf[2048] = _T("");
+	va_list args;
+	va_start(args, lpszFormat);
+	_vsntprintf_s(szBuf, 2048, lpszFormat, args);
+	va_end(args);
+
+	//WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), szBuf, _tcslen(szBuf), NULL, NULL);
+
+	//output it to the current directory of binary
+	std::string output_str = textconv_helper::T2A_(szBuf);
+	*output_file << output_str;
+	output_file->flush();
+}
+
+void CBaseException::ShowLoadModules()
+{
+	LoadSymbol();
+	LPMODULE_INFO pHead = GetLoadModules();
+	LPMODULE_INFO pmi = pHead;
+
+	TCHAR szBuf[MAX_COMPUTERNAME_LENGTH] = _T("");
+	DWORD dwSize = MAX_COMPUTERNAME_LENGTH;
+	GetUserName(szBuf, &dwSize);
+	OutputString(_T("Current User:%s\r\n"), szBuf);
+	OutputString(_T("BaseAddress:\tSize:\tName\tPath\tSymbolPath\tVersion\r\n"));
+	while (NULL != pmi)
+	{
+		OutputString(_T("%08x\t%d\t%s\t%s\t%s\t%s\r\n"), (unsigned long)(pmi->ModuleAddress), pmi->dwModSize, pmi->szModuleName, pmi->szModulePath, pmi->szSymbolPath, pmi->szVersion);
+		pmi = pmi->pNext;
+	}
+
+	FreeModuleInformations(pHead);
+}
+
+void CBaseException::ShowCallstack(HANDLE hThread, const CONTEXT* context)
+{
+	OutputString(_T("Show CallStack:\r\n"));
+	LPSTACKINFO phead = StackWalker(hThread, context);
+	FreeStackInformations(phead);
+}
+
+void CBaseException::ShowExceptionResoult(DWORD dwExceptionCode)
+{
+	OutputString(_T("Exception Code :%08x "), dwExceptionCode);
+// BBS: to be checked
+#if 1
+	switch (dwExceptionCode)
+	{
+	case EXCEPTION_ACCESS_VIOLATION:
+		{
+			//OutputString(_T("ACCESS_VIOLATION(%s)\r\n"), _T("读写非法内存"));
+			OutputString(_T("ACCESS_VIOLATION\r\n"));
+		}
+		return ;
+	case EXCEPTION_DATATYPE_MISALIGNMENT:
+		{
+			//OutputString(_T("DATATYPE_MISALIGNMENT(%s)\r\n"), _T("线程视图在不支持对齐的硬件上读写未对齐的数据"));
+			OutputString(_T("DATATYPE_MISALIGNMENT\r\n"));
+		}
+		return ;
+	case EXCEPTION_BREAKPOINT:
+		{
+			//OutputString(_T("BREAKPOINT(%s)\r\n"), _T("遇到一个断点"));
+			OutputString(_T("BREAKPOINT\r\n"));
+		}
+		return ;
+	case EXCEPTION_SINGLE_STEP:
+		{
+			//OutputString(_T("SINGLE_STEP(%s)\r\n"), _T("单步")); //一般是发生在调试事件中
+			OutputString(_T("SINGLE_STEP\r\n"));
+		}
+		return ;
+	case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+		{
+			//OutputString(_T("ARRAY_BOUNDS_EXCEEDED(%s)\r\n"), _T("数组访问越界"));
+			OutputString(_T("ARRAY_BOUNDS_EXCEEDED\r\n"));
+		}
+		return ;
+	case EXCEPTION_FLT_DENORMAL_OPERAND:
+		{
+			//OutputString(_T("FLT_DENORMAL_OPERAND(%s)\r\n"), _T("浮点操作的一个操作数不正规，给定的浮点数无法表示")); //操作数的问题
+			OutputString(_T("FLT_DENORMAL_OPERAND\r\n"));
+		}
+		return ;
+	case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+		{
+			//OutputString(_T("FLT_DIVIDE_BY_ZERO(%s)\r\n"), _T("浮点数除0操作"));
+			OutputString(_T("FLT_DIVIDE_BY_ZERO\r\n"));
+		}
+		return ;
+	case EXCEPTION_FLT_INEXACT_RESULT:
+		{
+			//OutputString(_T("FLT_INEXACT_RESULT(%s)\r\n"), _T("浮点数操作的结果无法表示")); //无法表示一般是数据太小，超过浮点数表示的范围, 计算之后产生的结果异常
+			OutputString(_T("FLT_INEXACT_RESULT\r\n"));
+		}
+		return ;
+	case EXCEPTION_FLT_INVALID_OPERATION:
+		{
+			//OutputString(_T("FLT_INVALID_OPERATION(%s)\r\n"), _T("其他浮点数异常"));
+			OutputString(_T("FLT_INVALID_OPERATION\r\n"));
+		}
+		return ;
+	case EXCEPTION_FLT_OVERFLOW:
+		{
+			//OutputString(_T("FLT_OVERFLOW(%s)\r\n"), _T("浮点操作的指数超过了相应类型的最大值"));
+			OutputString(_T("FLT_OVERFLOW\r\n"));
+		}
+		return ;
+	case EXCEPTION_FLT_STACK_CHECK:
+		{
+			//OutputString(_T("STACK_CHECK(%s)\r\n"), _T("栈越界或者栈向下溢出"));
+			OutputString(_T("STACK_CHECK\r\n"));
+		}
+		return ;
+	case EXCEPTION_INT_DIVIDE_BY_ZERO:
+		{
+			//OutputString(_T("INT_DIVIDE_BY_ZERO(%s)\r\n"), _T("整数除0异常"));
+			OutputString(_T("INT_DIVIDE_BY_ZERO\r\n"));
+		}
+		return ;
+	case EXCEPTION_INVALID_HANDLE:
+		{
+			//OutputString(_T("INVALID_HANDLE(%s)\r\n"), _T("句柄无效"));
+			OutputString(_T("INVALID_HANDLE\r\n"));
+		}
+		return ;
+	case EXCEPTION_PRIV_INSTRUCTION:
+		{
+			//OutputString(_T("PRIV_INSTRUCTION(%s)\r\n"), _T("线程试图执行当前机器模式不支持的指令"));
+			OutputString(_T("PRIV_INSTRUCTION\r\n"));
+		}
+		return ;
+	case EXCEPTION_IN_PAGE_ERROR:
+		{
+			//OutputString(_T("IN_PAGE_ERROR(%s)\r\n"), _T("线程视图访问未加载的虚拟内存页或者不能加载的虚拟内存页"));
+			OutputString(_T("IN_PAGE_ERROR\r\n"));
+		}
+		return ;
+	case EXCEPTION_ILLEGAL_INSTRUCTION:
+		{
+			//OutputString(_T("ILLEGAL_INSTRUCTION(%s)\r\n"), _T("线程视图执行无效指令"));
+			OutputString(_T("ILLEGAL_INSTRUCTION\r\n"));
+		}
+		return ;
+	case EXCEPTION_NONCONTINUABLE_EXCEPTION:
+		{
+			//OutputString(_T("NONCONTINUABLE_EXCEPTION(%s)\r\n"), _T("线程试图在一个不可继续执行的异常发生后继续执行"));
+			OutputString(_T("NONCONTINUABLE_EXCEPTION\r\n"));
+		}
+		return ;
+	case EXCEPTION_STACK_OVERFLOW:
+		{
+			//OutputString(_T("STACK_OVERFLOW(%s)\r\n"), _T("栈溢出"));
+			OutputString(_T("STACK_OVERFLOW\r\n"));
+		}
+		return ;
+	case EXCEPTION_INVALID_DISPOSITION:
+		{
+			//OutputString(_T("INVALID_DISPOSITION(%s)\r\n"), _T("异常处理程序给异常调度器返回了一个无效配置")); //使用高级语言编写的程序永远不会遇到这个异常
+			OutputString(_T("INVALID_DISPOSITION\r\n"));
+		}
+		return ;
+	case EXCEPTION_FLT_UNDERFLOW:
+		{
+			//OutputString(_T("FLT_UNDERFLOW(%s)\r\n"), _T("浮点数操作的指数小于相应类型的最小值"));
+			OutputString(_T("FLT_UNDERFLOW\r\n"));
+		}
+		return ;
+	case EXCEPTION_INT_OVERFLOW:
+		{
+			//OutputString(_T("INT_OVERFLOW(%s)\r\n"), _T("整数操作越界"));
+			OutputString(_T("INT_OVERFLOW\r\n"));
+		}
+		return ;
+	}
+
+	TCHAR szBuffer[512] = { 0 };
+
+	FormatMessage(  FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_HMODULE,
+		GetModuleHandle( _T("NTDLL.DLL") ),
+		dwExceptionCode, 0, szBuffer, sizeof( szBuffer ), 0 );
+
+	OutputString(_T("%s"), szBuffer);
+	OutputString(_T("\r\n"));
+#endif
+}
+
+LONG WINAPI CBaseException::UnhandledExceptionFilter(PEXCEPTION_POINTERS pExceptionInfo )
+{
+	if (pExceptionInfo->ExceptionRecord->ExceptionCode < 0x80000000
+		//BBS: Load project on computers with SDC may trigger this exception (in ShowModal()),
+		//     It's not fatal and should be ignored, or there will be lots of meaningless crash logs
+		|| pExceptionInfo->ExceptionRecord->ExceptionCode==0xe0434352)
+		//BBS: ignore the exception when copy preset
+		//|| pExceptionInfo->ExceptionRecord->ExceptionCode==0xe06d7363)
+	{
+		//BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": got an ExceptionCode %1%, skip it!") % pExceptionInfo->ExceptionRecord->ExceptionCode;
+		return EXCEPTION_CONTINUE_SEARCH;
+	}
+    g_dump_mutex.lock();
+	CBaseException base(GetCurrentProcess(), GetCurrentProcessId(), NULL, pExceptionInfo);
+	base.ShowExceptionInformation();
+    g_dump_mutex.unlock();
+
+	return EXCEPTION_CONTINUE_SEARCH;
+}
+
+LONG WINAPI CBaseException::UnhandledExceptionFilter2(PEXCEPTION_POINTERS pExceptionInfo )
+{
+	CBaseException base(GetCurrentProcess(), GetCurrentProcessId(), NULL, pExceptionInfo);
+	base.ShowExceptionInformation();
+
+	return EXCEPTION_CONTINUE_SEARCH;
+}
+
+BOOL CBaseException::GetLogicalAddress(
+	PVOID addr, PTSTR szModule, DWORD len, DWORD& section, DWORD& offset )
+{
+	MEMORY_BASIC_INFORMATION mbi;
+
+	if ( !VirtualQuery( addr, &mbi, sizeof(mbi) ) )
+		return FALSE;
+
+	DWORD hMod = (DWORD)mbi.AllocationBase;
+
+	if ( !GetModuleFileName( (HMODULE)hMod, szModule, len ) )
+		return FALSE;
+
+	if (!hMod)
+		return FALSE;
+
+	PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)hMod;
+	PIMAGE_NT_HEADERS pNtHdr = (PIMAGE_NT_HEADERS)(hMod + pDosHdr->e_lfanew);
+	PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION( pNtHdr );
+
+	DWORD rva = (DWORD)addr - hMod;
+
+	//计算当前地址在第几个节
+	for (unsigned i = 0; i < pNtHdr->FileHeader.NumberOfSections; i++, pSection++ )
+	{
+		DWORD sectionStart = pSection->VirtualAddress;
+		DWORD sectionEnd = sectionStart + max(pSection->SizeOfRawData, pSection->Misc.VirtualSize);
+
+		if ( (rva >= sectionStart) && (rva <= sectionEnd) )
+		{
+			section = i+1;
+			offset = rva - sectionStart;
+			return TRUE;
+		}
+	}
+
+	return FALSE;   // Should never get here!
+}
+
+void CBaseException::ShowRegistorInformation(PCONTEXT pCtx)
+{
+#ifdef _M_IX86  // Intel Only!
+	OutputString( _T("\nRegisters:\r\n") );
+
+	OutputString(_T("EAX:%08X\r\nEBX:%08X\r\nECX:%08X\r\nEDX:%08X\r\nESI:%08X\r\nEDI:%08X\r\n"),
+		pCtx->Eax, pCtx->Ebx, pCtx->Ecx, pCtx->Edx, pCtx->Esi, pCtx->Edi );
+
+	OutputString( _T("CS:EIP:%04X:%08X\r\n"), pCtx->SegCs, pCtx->Eip );
+	OutputString( _T("SS:ESP:%04X:%08X  EBP:%08X\r\n"),pCtx->SegSs, pCtx->Esp, pCtx->Ebp );
+	OutputString( _T("DS:%04X  ES:%04X  FS:%04X  GS:%04X\r\n"), pCtx->SegDs, pCtx->SegEs, pCtx->SegFs, pCtx->SegGs );
+	OutputString( _T("Flags:%08X\r\n"), pCtx->EFlags );
+
+#endif
+
+	OutputString( _T("\r\n") );
+}
+
+void CBaseException::STF(unsigned int ui,  PEXCEPTION_POINTERS pEp)
+{
+	CBaseException base(GetCurrentProcess(), GetCurrentProcessId(), NULL, pEp);
+	throw base;
+}
+
+void CBaseException::ShowExceptionInformation()
+{
+	OutputString(_T("Exceptions:\r\n"));
+	ShowExceptionResoult(m_pEp->ExceptionRecord->ExceptionCode);
+
+	OutputString(_T("Exception Flag :0x%x "), m_pEp->ExceptionRecord->ExceptionFlags);
+	OutputString(_T("NumberParameters :%ld \n"), m_pEp->ExceptionRecord->NumberParameters);
+	for (int i = 0; i < m_pEp->ExceptionRecord->NumberParameters; i++)
+	{
+		OutputString(_T("Param %d :0x%x \n"), i, m_pEp->ExceptionRecord->ExceptionInformation[i]);
+	}
+	OutputString(_T("Context :%p \n"), m_pEp->ContextRecord);
+    OutputString(_T("ContextFlag : 0x%x, EFlags: 0x%x \n"), m_pEp->ContextRecord->ContextFlags, m_pEp->ContextRecord->EFlags);
+
+	TCHAR szFaultingModule[MAX_PATH];
+	DWORD section, offset;
+	GetLogicalAddress(m_pEp->ExceptionRecord->ExceptionAddress, szFaultingModule, sizeof(szFaultingModule), section, offset );
+	OutputString( _T("Fault address:  0x%X 0x%X:0x%X %s\r\n"), m_pEp->ExceptionRecord->ExceptionAddress, section, offset, szFaultingModule );
+
+	ShowRegistorInformation(m_pEp->ContextRecord);
+
+	ShowCallstack(GetCurrentThread(), m_pEp->ContextRecord);
+}

src/BaseException.h

@@ -0,0 +1,31 @@
+#pragma once
+#include <boost/nowide/cstdio.hpp>
+#include <boost/nowide/fstream.hpp>
+#include "stackwalker.h"
+#include <eh.h>
+
+class CBaseException : public CStackWalker
+{
+public:
+	CBaseException(HANDLE hProcess = GetCurrentProcess(), WORD wPID = GetCurrentProcessId(), LPCTSTR lpSymbolPath = NULL, PEXCEPTION_POINTERS pEp = NULL);
+	~CBaseException(void);
+	virtual void OutputString(LPCTSTR lpszFormat, ...);
+	virtual void ShowLoadModules();
+	virtual void ShowCallstack(HANDLE hThread = GetCurrentThread(), const CONTEXT* context = NULL);
+	virtual void ShowExceptionResoult(DWORD dwExceptionCode);
+	virtual BOOL GetLogicalAddress(PVOID addr, PTSTR szModule, DWORD len, DWORD& section, DWORD& offset );
+	virtual void ShowRegistorInformation(PCONTEXT pCtx);
+	virtual void ShowExceptionInformation();
+	static LONG WINAPI UnhandledExceptionFilter(PEXCEPTION_POINTERS pExceptionInfo);
+	static LONG WINAPI UnhandledExceptionFilter2(PEXCEPTION_POINTERS pExceptionInfo);
+	static void STF(unsigned int ui,  PEXCEPTION_POINTERS pEp);
+	//BBS set crash log folder
+	static void set_log_folder(std::string log_folder);
+protected:
+	PEXCEPTION_POINTERS m_pEp;
+	boost::nowide::ofstream *output_file;
+};
+
+#define SET_DEFULTER_HANDLER() SetUnhandledExceptionFilter(CBaseException::UnhandledExceptionFilter)
+
+#define SET_DEFAUL_EXCEPTION() _set_se_translator(CBaseException::STF)

src/CMakeLists.txt

@@ -0,0 +1,269 @@
+cmake_minimum_required(VERSION 3.13)
+project(BambuStudio-native)
+
+add_subdirectory(build-utils)
+add_subdirectory(admesh)
+# add_subdirectory(avrdude)
+# boost/nowide
+add_subdirectory(boost)
+add_subdirectory(clipper)
+add_subdirectory(miniz)
+add_subdirectory(minilzo)
+add_subdirectory(glu-libtess)
+add_subdirectory(qhull)
+add_subdirectory(Shiny)
+add_subdirectory(semver)
+add_subdirectory(libigl)
+add_subdirectory(hints)
+
+# Adding libnest2d project for bin packing...
+add_subdirectory(libnest2d)
+
+add_subdirectory(libslic3r)
+
+if (SLIC3R_GUI)
+    add_subdirectory(imgui)
+    add_subdirectory(hidapi)
+    include_directories(hidapi/include)
+
+    if(WIN32)
+        message(STATUS "WXWIN environment set to: $ENV{WXWIN}")
+    elseif(UNIX)
+        set(wxWidgets_USE_UNICODE ON)
+        if(SLIC3R_STATIC)
+            set(wxWidgets_USE_STATIC ON)
+        else()
+            set(wxWidgets_USE_STATIC OFF)
+        endif()
+    endif()
+
+    if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+        set (wxWidgets_CONFIG_OPTIONS "--toolkit=gtk${SLIC3R_GTK}")
+        if (SLIC3R_WX_STABLE)
+            find_package(wxWidgets 3.0 REQUIRED COMPONENTS base core adv html gl aui net media webview)
+        else ()
+            find_package(wxWidgets 3.1 REQUIRED COMPONENTS base core adv html gl aui net media webview)
+        endif ()
+    else ()
+        find_package(wxWidgets 3.1 REQUIRED COMPONENTS html adv gl core base webview aui net media)
+    endif ()
+
+    if(UNIX)
+        message(STATUS "wx-config path: ${wxWidgets_CONFIG_EXECUTABLE}")
+    endif()
+
+    include(${wxWidgets_USE_FILE})
+
+    find_package(JPEG QUIET)
+    find_package(TIFF QUIET)
+
+    string(REGEX MATCH "wxpng" WX_PNG_BUILTIN ${wxWidgets_LIBRARIES})
+    if (PNG_FOUND AND NOT WX_PNG_BUILTIN)
+        list(FILTER wxWidgets_LIBRARIES EXCLUDE REGEX png)
+        list(APPEND wxWidgets_LIBRARIES ${PNG_LIBRARIES})
+    endif ()
+
+    string(REGEX MATCH "wxtiff" WX_TIFF_BUILTIN ${wxWidgets_LIBRARIES})
+    if (TIFF_FOUND AND NOT WX_TIFF_BUILTIN)
+        list(FILTER wxWidgets_LIBRARIES EXCLUDE REGEX tiff)
+        list(APPEND wxWidgets_LIBRARIES ${TIFF_LIBRARIES})
+    endif ()
+
+    string(REGEX MATCH "wxjpeg" WX_JPEG_BUILTIN ${wxWidgets_LIBRARIES})
+    if (JPEG_FOUND AND NOT WX_JPEG_BUILTIN)
+        list(FILTER wxWidgets_LIBRARIES EXCLUDE REGEX jpeg)
+        list(APPEND wxWidgets_LIBRARIES ${JPEG_LIBRARIES})
+    endif ()
+
+    string(REGEX MATCH "wxexpat" WX_EXPAT_BUILTIN ${wxWidgets_LIBRARIES})
+    if (EXPAT_FOUND AND NOT WX_EXPAT_BUILTIN)
+        list(FILTER wxWidgets_LIBRARIES EXCLUDE REGEX expat)
+        list(APPEND wxWidgets_LIBRARIES ${EXPAT_LIBRARIES})
+    endif ()
+    
+    # This is an issue in the new wxWidgets cmake build, doesn't deal with librt
+    find_library(LIBRT rt)
+    if(LIBRT)
+        list(APPEND wxWidgets_LIBRARIES ${LIBRT})
+    endif()
+
+    # This fixes a OpenGL linking issue on OSX. wxWidgets cmake build includes
+    # wrong libs for opengl in the link line and it does not link to it by himself.
+    # libslic3r_gui will link to opengl anyway, so lets override wx
+    list(FILTER wxWidgets_LIBRARIES EXCLUDE REGEX OpenGL)
+
+#    list(REMOVE_ITEM wxWidgets_LIBRARIES oleacc)
+    message(STATUS "wx libs: ${wxWidgets_LIBRARIES}")
+
+    add_subdirectory(slic3r)
+endif()
+
+
+# Create a slic3r executable
+# Process mainfests for various platforms.
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/platform/msw/BambuStudio.rc.in ${CMAKE_CURRENT_BINARY_DIR}/BambuStudio.rc @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/platform/msw/BambuStudio.manifest.in ${CMAKE_CURRENT_BINARY_DIR}/BambuStudio.manifest @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/platform/osx/Info.plist.in ${CMAKE_CURRENT_BINARY_DIR}/Info.plist @ONLY)
+if (WIN32)
+    add_library(BambuStudio SHARED BambuStudio.cpp BambuStudio.hpp BaseException.cpp BaseException.h StackWalker.cpp StackWalker.h)
+else ()
+    add_executable(BambuStudio BambuStudio.cpp BambuStudio.hpp)
+endif ()
+
+if (MINGW)
+    target_link_options(BambuStudio PUBLIC "-Wl,-allow-multiple-definition")
+    set_target_properties(BambuStudio PROPERTIES PREFIX "")
+endif (MINGW)
+
+if (NOT WIN32 AND NOT APPLE)
+    # Binary name on unix like systems (Linux, Unix)
+    set_target_properties(BambuStudio PROPERTIES OUTPUT_NAME "bambu-studio")
+endif ()
+
+target_link_libraries(BambuStudio libslic3r cereal)
+if (APPLE)
+#    add_compile_options(-stdlib=libc++)
+#    add_definitions(-DBOOST_THREAD_DONT_USE_CHRONO -DBOOST_NO_CXX11_RVALUE_REFERENCES -DBOOST_THREAD_USES_MOVE)
+    # -liconv: boost links to libiconv by default
+    target_link_libraries(BambuStudio "-liconv -framework IOKit" "-framework CoreFoundation" "-framework AVFoundation" "-framework AVKit" "-framework CoreMedia" "-framework VideoToolbox" -lc++)
+elseif (MSVC)
+    # Manifest is provided through BambuStudio.rc, don't generate your own.
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO")
+else ()
+    # Boost on Raspberry-Pi does not link to pthreads explicitely.
+    target_link_libraries(BambuStudio ${CMAKE_DL_LIBS} -lstdc++ Threads::Threads)
+endif ()
+
+# Add the Slic3r GUI library, libcurl, OpenGL and GLU libraries.
+if (SLIC3R_GUI)
+#    target_link_libraries(BambuStudio ws2_32 uxtheme setupapi libslic3r_gui ${wxWidgets_LIBRARIES})
+target_link_libraries(BambuStudio libslic3r_gui)
+    if (MSVC)
+        # Generate debug symbols even in release mode.
+        target_link_options(BambuStudio PUBLIC "$<$<CONFIG:RELEASE>:/DEBUG>")
+        target_link_libraries(BambuStudio user32.lib Setupapi.lib)
+    elseif (MINGW)
+        target_link_libraries(BambuStudio ws2_32 uxtheme setupapi)
+    elseif (APPLE)
+        target_link_libraries(BambuStudio "-framework OpenGL")
+    else ()
+        target_link_libraries(BambuStudio -ldl)
+    endif ()
+    #if (WIN32)
+    #    find_library(PSAPI_LIB NAMES Psapi)
+    #    target_link_libraries(BambuStudio ${PSAPI_LIB})
+    #endif ()
+endif ()
+
+# On Windows, a shim application is required to produce a console / non console version of the Slic3r application.
+# Also the shim may load the Mesa software OpenGL renderer if the default renderer does not support OpenGL 2.0 and higher.
+if (WIN32)
+    if (MINGW)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -municode")
+    endif()
+
+    add_executable(BambuStudio_app_gui WIN32 BambuStudio_app_msvc.cpp ${CMAKE_CURRENT_BINARY_DIR}/BambuStudio.rc)
+    # Generate debug symbols even in release mode.
+    if(MSVC)
+        target_link_options(BambuStudio_app_gui PUBLIC "$<$<CONFIG:RELEASE>:/DEBUG>")
+    endif()
+    target_compile_definitions(BambuStudio_app_gui PRIVATE -DSLIC3R_WRAPPER_NOCONSOLE)
+    add_dependencies(BambuStudio_app_gui BambuStudio)
+    set_target_properties(BambuStudio_app_gui PROPERTIES OUTPUT_NAME "bambu-studio")
+    target_link_libraries(BambuStudio_app_gui PRIVATE boost_headeronly)
+endif ()
+
+# Link the resources dir to where Slic3r GUI expects it
+set(output_dlls_Release "")
+set(output_dlls_Debug "")
+set(output_dlls_RelWithDebInfo "")
+if (WIN32)
+    # This has to be a separate target due to the windows command line lenght limits
+    add_custom_target(BambuStudioDllsCopy ALL DEPENDS BambuStudio)
+
+    if (CMAKE_CONFIGURATION_TYPES)
+        foreach (CONF ${CMAKE_CONFIGURATION_TYPES})
+            file(TO_NATIVE_PATH "${CMAKE_CURRENT_BINARY_DIR}/${CONF}" WIN_CONF_OUTPUT_DIR)
+            file(TO_NATIVE_PATH "${CMAKE_CURRENT_BINARY_DIR}/${CONF}/resources" WIN_RESOURCES_SYMLINK)
+            add_custom_command(TARGET BambuStudio POST_BUILD
+                COMMAND if exist "${WIN_CONF_OUTPUT_DIR}" "("
+                        if not exist "${WIN_RESOURCES_SYMLINK}" "("
+                            mklink /J "${WIN_RESOURCES_SYMLINK}" "${SLIC3R_RESOURCES_DIR_WIN}"
+                        ")"
+                    ")"
+                COMMENT "Symlinking the resources directory into the build tree"
+                VERBATIM
+            )
+        endforeach ()
+
+        if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
+            bambustudio_copy_dlls(BambuStudioDllsCopy "Debug" "d" output_dlls_Debug)
+        elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo")
+            bambustudio_copy_dlls(BambuStudioDllsCopy "RelWithDebInfo" "" output_dlls_RelWithDebInfo)
+        else()
+            bambustudio_copy_dlls(BambuStudioDllsCopy "Release" "" output_dlls_Release)
+        endif()
+    else ()
+        file(TO_NATIVE_PATH "${CMAKE_CURRENT_BINARY_DIR}/resources" WIN_RESOURCES_SYMLINK)
+        add_custom_command(TARGET BambuStudio POST_BUILD
+            COMMAND if not exist "${WIN_RESOURCES_SYMLINK}" "(" mklink /J "${WIN_RESOURCES_SYMLINK}" "${SLIC3R_RESOURCES_DIR_WIN}" ")"
+            COMMENT "Symlinking the resources directory into the build tree"
+            VERBATIM
+        )
+    endif ()
+
+
+else ()
+    if (APPLE AND NOT CMAKE_MACOSX_BUNDLE)
+        # On OSX, the name of the binary matches the name of the Application.
+        add_custom_command(TARGET BambuStudio POST_BUILD
+            COMMAND ln -sf BambuStudio bambu-studio
+            WORKING_DIRECTORY "$<TARGET_FILE_DIR:BambuStudio>"
+            VERBATIM)
+    else ()
+        add_custom_command(TARGET BambuStudio POST_BUILD
+            WORKING_DIRECTORY "$<TARGET_FILE_DIR:BambuStudio>"
+            VERBATIM)
+    endif ()
+    if (XCODE)
+        # Because of Debug/Release/etc. configurations (similar to MSVC) the slic3r binary is located in an extra level
+        set(BIN_RESOURCES_DIR "${CMAKE_CURRENT_BINARY_DIR}/resources")
+        set(BIN_CONF_DIR "Debug")
+    else ()
+        set(BIN_RESOURCES_DIR "${CMAKE_CURRENT_BINARY_DIR}/../resources")
+    endif ()
+    if (CMAKE_MACOSX_BUNDLE)
+        set(BIN_RESOURCES_DIR "${CMAKE_CURRENT_BINARY_DIR}/${BIN_CONF_DIR}/BambuStudio.app/Contents/Resources")
+        set(MACOSX_BUNDLE_ICON_FILE Icon.icns)
+        set(MACOSX_BUNDLE_BUNDLE_NAME "Bambu Studio")
+        set(MACOSX_BUNDLE_SHORT_VERSION_STRING ${SLIC3R_VERSION})
+        set(MACOSX_BUNDLE_COPYRIGHT "Copyright(C) 2022-2032 Bambu Lab")
+    endif()
+    add_custom_command(TARGET BambuStudio POST_BUILD
+        COMMAND ln -sfn "${SLIC3R_RESOURCES_DIR}" "${BIN_RESOURCES_DIR}"
+        COMMENT "Symlinking the resources directory into the build tree"
+        VERBATIM)
+endif ()
+
+# Slic3r binary install target. Default build type is release in case no CMAKE_BUILD_TYPE is provided.
+if( ("${CMAKE_BUILD_TYPE}" STREQUAL "Release") OR ("${CMAKE_BUILD_TYPE}" STREQUAL "") )
+    set (build_type "Release")
+    set(CMAKE_BUILD_POSTFIX "")
+elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo")
+    set (build_type "RelWithDebInfo")
+    set(CMAKE_BUILD_POSTFIX "")
+else()
+    set (build_type "Debug")
+    set(CMAKE_BUILD_POSTFIX "d")
+endif()
+message(STATUS "libslic3r-CMAKE_BUILD_TYPE: ${build_type}")
+message(STATUS "CMAKE_CURRENT_BINARY_DIR: ${CMAKE_CURRENT_BINARY_DIR}")
+if (WIN32)
+    install(TARGETS BambuStudio RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}")
+    if (MSVC)
+        install(TARGETS BambuStudio_app_gui RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}")
+    endif ()
+    install(FILES ${output_dlls_${build_type}} DESTINATION "${CMAKE_INSTALL_PREFIX}")
+else ()
+    install(TARGETS BambuStudio RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" BUNDLE DESTINATION ${CMAKE_INSTALL_BINDIR})
+endif ()

src/Shiny/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 2.8.12)
+project(Shiny)
+
+add_library(Shiny STATIC
+    Shiny.h
+    ShinyConfig.h
+    ShinyData.h
+    ShinyMacros.h
+    ShinyManager.c
+    ShinyManager.h
+    ShinyNode.c
+    ShinyNode.h
+    ShinyNodePool.c
+    ShinyNodePool.h
+    ShinyNodeState.c
+    ShinyNodeState.h
+    ShinyOutput.c
+    ShinyOutput.h
+    ShinyPrereqs.h
+    ShinyTools.c
+    ShinyTools.h
+    ShinyVersion.h
+    ShinyZone.c
+    ShinyZone.h
+)

src/Shiny/Shiny.h

@@ -0,0 +1,36 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_H
+#define SHINY_H
+
+/*---------------------------------------------------------------------------*/
+
+#include "ShinyMacros.h"
+
+#ifdef SLIC3R_PROFILE
+#include "ShinyManager.h"
+#endif /* SLIC3R_PROFILE */
+
+#endif /* SHINY_H */

src/Shiny/ShinyConfig.h

@@ -0,0 +1,61 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_CONFIG_H
+#define SHINY_CONFIG_H
+
+
+/*---------------------------------------------------------------------------*/
+
+/* if SHINY_LOOKUP_RATE is defined to TRUE then Shiny will record the success of its hash function. This is useful for debugging. Default is FALSE.
+ */
+#ifndef SHINY_LOOKUP_RATE
+// #define SHINY_LOOKUP_RATE		FALSE
+#endif
+
+/* if SHINY_HAS_ENABLED is defined to TRUE then Shiny can be enabled and disabled at runtime. TODO: bla bla...
+ */
+#ifndef SHINY_HAS_ENABLED
+// #define SHINY_HAS_ENABLED		FALSE
+#endif
+
+/* TODO: 
+ */
+#define SHINY_OUTPUT_MODE_FLAT	0x1
+
+/* TODO: 
+ */
+#define SHINY_OUTPUT_MODE_TREE	0x2
+
+/* TODO: 
+ */
+#define SHINY_OUTPUT_MODE_BOTH	0x3
+
+/* TODO: 
+ */
+#ifndef SHINY_OUTPUT_MODE
+#define SHINY_OUTPUT_MODE		SHINY_OUTPUT_MODE_BOTH
+#endif
+
+#endif /* SHINY_CONFIG_H */

src/Shiny/ShinyData.h

@@ -0,0 +1,102 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_DATA_H
+#define SHINY_DATA_H
+
+#include "ShinyPrereqs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct {
+	uint32_t entryCount;
+	shinytick_t selfTicks;
+} ShinyLastData;
+
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct {
+	shinytick_t cur;
+	float avg;
+} ShinyTickData;
+
+typedef struct {
+	uint32_t cur;
+	float avg;
+} ShinyCountData;
+
+typedef struct {
+	ShinyCountData entryCount;
+	ShinyTickData selfTicks;
+	ShinyTickData childTicks;
+} ShinyData;
+
+SHINY_INLINE shinytick_t ShinyData_totalTicksCur(const ShinyData *self) {
+	return self->selfTicks.cur + self->childTicks.cur;
+}
+
+SHINY_INLINE float ShinyData_totalTicksAvg(const ShinyData *self) {
+	return self->selfTicks.avg + self->childTicks.avg;
+}
+
+SHINY_INLINE void ShinyData_computeAverage(ShinyData *self, float a_damping) {
+	self->entryCount.avg = self->entryCount.cur +
+		a_damping * (self->entryCount.avg - self->entryCount.cur);
+	self->selfTicks.avg = self->selfTicks.cur +
+		a_damping * (self->selfTicks.avg - self->selfTicks.cur);
+	self->childTicks.avg = self->childTicks.cur +
+		a_damping * (self->childTicks.avg - self->childTicks.cur);
+}
+
+SHINY_INLINE void ShinyData_copyAverage(ShinyData *self) {
+	self->entryCount.avg = (float) self->entryCount.cur;
+	self->selfTicks.avg = (float) self->selfTicks.cur;
+	self->childTicks.avg = (float) self->childTicks.cur;
+}
+
+SHINY_INLINE void ShinyData_clearAll(ShinyData *self) {
+	self->entryCount.cur = 0;
+	self->entryCount.avg = 0;
+	self->selfTicks.cur = 0;
+	self->selfTicks.avg = 0;
+	self->childTicks.cur = 0;
+	self->childTicks.avg = 0;
+}
+
+SHINY_INLINE void ShinyData_clearCurrent(ShinyData *self) {
+	self->entryCount.cur = 0;
+	self->selfTicks.cur = 0;
+	self->childTicks.cur = 0;
+}
+
+#if __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* SHINY_DATA_H */

src/Shiny/ShinyMacros.h

@@ -0,0 +1,281 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_MACROS_H
+#define SHINY_MACROS_H
+
+#ifdef SLIC3R_PROFILE
+
+#include "ShinyManager.h"
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#define PROFILE_UPDATE()													\
+	ShinyManager_update(&Shiny_instance)
+
+#define PROFILE_SET_DAMPING(floatfrom0to1)									\
+	Shiny_instance.damping = (floatfrom0to1);
+
+#define PROFILE_GET_DAMPING()												\
+	(Shiny_instance.damping)
+
+#define PROFILE_OUTPUT(filename)											\
+	ShinyManager_output(&Shiny_instance, (filename))
+
+#define PROFILE_OUTPUT_STREAM(stream)										\
+	ShinyManager_outputToStream(&Shiny_instance, (stream))
+
+#ifdef __cplusplus
+#define PROFILE_GET_TREE_STRING()											\
+	ShinyManager_outputTreeToString(&Shiny_instance)
+
+#define PROFILE_GET_FLAT_STRING()											\
+	ShinyManager_outputFlatToString(&Shiny_instance)
+#endif /* __cplusplus */
+
+#define PROFILE_DESTROY()													\
+	ShinyManager_destroy(&Shiny_instance)
+
+#define PROFILE_CLEAR()														\
+	ShinyManager_clear(&Shiny_instance)
+
+#define PROFILE_SORT_ZONES()												\
+	ShinyManager_sortZones(&Shiny_instance)
+
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#define PROFILE_GET_TOTAL_TICKS_CUR()										\
+	ShinyData_totalTicksCur(&Shiny_instance.rootZone.data)
+
+#define PROFILE_GET_TOTAL_TICKS()											\
+	ShinyData_totalTicksAvg(&Shiny_instance.rootZone.data)
+
+#define PROFILE_GET_PROFILED_TICKS_CUR()									\
+	(Shiny_instance.rootZone.data.selfTicks.cur)
+
+#define PROFILE_GET_PROFILED_TICKS()										\
+	(Shiny_instance.rootZone.data.selfTicks.avg)
+
+#define PROFILE_GET_UNPROFILED_TICKS_CUR()									\
+	(Shiny_instance.rootZone.data.childTicks.cur)
+
+#define PROFILE_GET_UNPROFILED_TICKS()										\
+	(Shiny_instance.rootZone.data.childTicks.avg)
+
+#define PROFILE_GET_SHARED_TOTAL_TICKS_CUR(name)							\
+	ShinyData_totalTicksCur(&(_PROFILE_ID_ZONE_SHARED(name).data))
+
+#define PROFILE_GET_SHARED_TOTAL_TICKS(name)								\
+	ShinyData_totalTicksAvg(&(_PROFILE_ID_ZONE_SHARED(name).data))
+
+#define PROFILE_GET_SHARED_SELF_TICKS_CUR(name)								\
+	(_PROFILE_ID_ZONE_SHARED(name).data.selfTicks.cur)
+
+#define PROFILE_GET_SHARED_SELF_TICKS(name)									\
+	(_PROFILE_ID_ZONE_SHARED(name).data.selfTicks.avg)
+
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#define PROFILE_IS_SHARED_SELF_BELOW(name, floatfrom0to1)					\
+	ShinyManager_isZoneSelfTimeBelow(										\
+		&Shiny_instance, _PROFILE_ID_ZONE_SHARED(name), floatfrom0to1)
+
+#define PROFILE_IS_SHARED_TOTAL_BELOW(name, floatfrom0to1)					\
+	ShinyManager_isZoneTotalTimeBelow(										\
+		&Shiny_instance, _PROFILE_ID_ZONE_SHARED(name), floatfrom0to1)
+
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#define PROFILE_END()														\
+	ShinyManager_endCurNode(&Shiny_instance)
+
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#define PROFILE_BEGIN( name )												\
+																			\
+	static _PROFILE_ZONE_DEFINE(_PROFILE_ID_ZONE(name), #name);				\
+	_PROFILE_ZONE_BEGIN(_PROFILE_ID_ZONE(name))
+
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#ifdef __cplusplus
+#define PROFILE_BLOCK( name )												\
+																			\
+	_PROFILE_BLOCK_DEFINE(_PROFILE_ID_BLOCK());								\
+	PROFILE_BEGIN(name)
+#endif /* __cplusplus */
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#ifdef __cplusplus
+#define PROFILE_FUNC()														\
+																			\
+	_PROFILE_BLOCK_DEFINE(_PROFILE_ID_BLOCK());								\
+	static _PROFILE_ZONE_DEFINE(_PROFILE_ID_ZONE_FUNC(), __FUNCTION__);		\
+	_PROFILE_ZONE_BEGIN(_PROFILE_ID_ZONE_FUNC())
+#endif /* __cplusplus */
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#define PROFILE_CODE( code )												\
+																			\
+	do {																	\
+		static _PROFILE_ZONE_DEFINE(_PROFILE_ID_ZONE_CODE(), #code);		\
+		_PROFILE_ZONE_BEGIN(_PROFILE_ID_ZONE_CODE());						\
+		{ code; }															\
+		PROFILE_END();														\
+	} while(0)
+
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#define PROFILE_SHARED_EXTERN( name )										\
+																			\
+	_PROFILE_ZONE_DECLARE(extern, _PROFILE_ID_ZONE_SHARED(name))
+
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#define PROFILE_SHARED_DEFINE( name )										\
+																			\
+	_PROFILE_ZONE_DEFINE(_PROFILE_ID_ZONE_SHARED(name), #name)
+
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#define PROFILE_SHARED_BEGIN( name )										\
+																			\
+	_PROFILE_ZONE_BEGIN(_PROFILE_ID_ZONE_SHARED(name))
+
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#ifdef __cplusplus
+#define PROFILE_SHARED_BLOCK( name )										\
+																			\
+	_PROFILE_BLOCK_DEFINE(_PROFILE_ID_BLOCK());								\
+	_PROFILE_ZONE_BEGIN(_PROFILE_ID_ZONE_SHARED(name))
+#endif /* __cplusplus */
+
+
+/*---------------------------------------------------------------------------*/
+/* public preprocessors */
+
+#ifdef SHINY_HAS_ENABLED
+#define PROFILE_SET_ENABLED( boolean )										\
+	Shiny_instance.enabled = boolean
+#endif
+
+
+/*---------------------------------------------------------------------------*/
+/* internal preprocessors */
+
+#define _PROFILE_ID_ZONE( name )			__ShinyZone_##name
+#define _PROFILE_ID_ZONE_FUNC()				__ShinyZoneFunc
+#define _PROFILE_ID_ZONE_CODE()				__ShinyZoneCode
+#define _PROFILE_ID_ZONE_SHARED( name )		name##__ShinyZoneShared
+#define _PROFILE_ID_BLOCK()					__ShinyBlock
+
+
+/*---------------------------------------------------------------------------*/
+/* internal preprocessor */
+
+#define _PROFILE_ZONE_DEFINE( id, string )									\
+																			\
+	ShinyZone id = {														\
+		NULL, SHINY_ZONE_STATE_HIDDEN, string,								\
+		{ { 0, 0 }, { 0, 0 }, { 0, 0 } }									\
+	}
+
+
+/*---------------------------------------------------------------------------*/
+/* internal preprocessor */
+
+#define _PROFILE_ZONE_DECLARE( prefix, id )									\
+																			\
+	prefix ShinyZone id
+
+
+/*---------------------------------------------------------------------------*/
+/* internal preprocessor */
+
+#define _PROFILE_BLOCK_DEFINE( id )											\
+																			\
+	ShinyEndNodeOnDestruction SHINY_UNUSED id
+
+
+/*---------------------------------------------------------------------------*/
+/* internal preprocessor */
+
+#define _PROFILE_ZONE_BEGIN( id )											\
+																			\
+	do {																	\
+		static ShinyNodeCache cache = &_ShinyNode_dummy;					\
+		ShinyManager_lookupAndBeginNode(&Shiny_instance, &cache, &id);		\
+	} while(0)
+
+/*---------------------------------------------------------------------------*/
+
+#else /* SLIC3R_PROFILE */
+
+#define PROFILE_UPDATE()
+#define PROFILE_SET_DAMPING(x)
+#define PROFILE_GET_DAMPING()			0.0f
+#define PROFILE_OUTPUT(x)
+#define PROFILE_OUTPUT_STREAM(x)
+#define PROFILE_CLEAR()
+#define PROFILE_GET_TREE_STRING()		std::string()
+#define PROFILE_GET_FLAT_STRING()		std::string()
+#define PROFILE_DESTROY()
+#define PROFILE_BEGIN(name)
+#define PROFILE_BLOCK(name)
+#define PROFILE_FUNC()
+#define PROFILE_CODE(code)				do { code; } while (0)
+#define PROFILE_SHARED_GLOBAL(name)
+#define PROFILE_SHARED_MEMBER(name)
+#define PROFILE_SHARED_DEFINE(name)
+#define PROFILE_SHARED_BEGIN(name)
+#define PROFILE_SHARED_BLOCK(name)
+#define PROFILE_SET_ENABLED(boolean)
+
+#endif /* SLIC3R_PROFILE */
+
+#endif /* SHINY_MACROS_H */

src/Shiny/ShinyManager.c

@@ -0,0 +1,445 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifdef SLIC3R_PROFILE
+
+#include "ShinyManager.h"
+
+#include <malloc.h>
+#include <memory.h>
+#include <string.h>
+#include <stdio.h>
+
+/*---------------------------------------------------------------------------*/
+
+#define TABLE_SIZE_INIT		256
+
+/*---------------------------------------------------------------------------*/
+
+ShinyManager Shiny_instance = {
+#if SHINY_HAS_ENABLED == TRUE
+	/* enabled = */ false,
+#endif
+	/* _lastTick = */ 0,
+	/* _curNode = */ &Shiny_instance.rootNode,
+	/* _tableMask = */ 0,
+	/* _nodeTable = */ _ShinyManager_dummyNodeTable,
+#if SHINY_LOOKUP_RATE == TRUE
+	/* _lookupCount = */ 0,
+	/* _lookupSuccessCount = */ 0,
+#endif
+	/* _tableSize = */ 1,
+	/* nodeCount = */ 1,
+	/* zoneCount = */ 1,
+	/* _lastZone = */ &Shiny_instance.rootZone,
+	/* _lastNodePool = */ NULL,
+	/* _firstNodePool = */ NULL,
+	/* rootNode = */ {
+		/* _last = */ { 0, 0 },
+		/* zone = */ &Shiny_instance.rootZone,
+		/* parent = */ &Shiny_instance.rootNode,
+		/* nextSibling = */ NULL,
+		/* firstChild = */ NULL,
+		/* lastChild = */ NULL,
+		/* childCount = */ 0,
+		/* entryLevel = */ 0,
+		/* _cache = */ NULL,
+		/* data = */ { { 0, 0 }, { 0, 0 }, { 0, 0 } }
+	},
+	/* rootZone = */ {
+		/* next = */ NULL,
+		/* _state = */ SHINY_ZONE_STATE_HIDDEN,
+		/* name = */ "<unprofiled>",
+		/* data = */ { { 0, 0 }, { 0, 0 }, { 0, 0 } }
+	},
+	/* damping = */ 0.f, // Damping disabled, every PROFILE_UPDATE will be performed from scratch. Original value: 0.9f
+	/* _initialized = */ FALSE,
+	/* _firstUpdate = */ TRUE
+};
+
+ShinyNode* _ShinyManager_dummyNodeTable[] = { NULL };
+
+
+/*---------------------------------------------------------------------------*/
+
+#if SHINY_COMPILER == SHINY_COMPILER_MSVC
+#	pragma warning (push)
+#	pragma warning (disable: 4311)
+#endif
+
+/* primary hash function */
+SHINY_INLINE uint32_t hash_value(void* a_pParent, void* a_pZone) {
+	uint32_t a = (uint32_t) a_pParent + (uint32_t) a_pZone;
+//	uint32_t a = *reinterpret_cast<uint32_t*>(&a_pParent) + *reinterpret_cast<uint32_t*>(&a_pZone);
+
+	a = (a+0x7ed55d16) + (a<<12);
+	a = (a^0xc761c23c) ^ (a>>19);
+	return a;
+}
+
+/*
+ * secondary hash used as index offset: force it to be odd
+ * so it's relatively prime to the power-of-two table size
+ */
+SHINY_INLINE uint32_t hash_offset(uint32_t a) {
+	return ((a << 8) + (a >> 4)) | 1;
+}
+
+#if SHINY_COMPILER == SHINY_COMPILER_MSVC
+#	pragma warning (pop)
+#endif
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyManager_preLoad(ShinyManager *self) {
+	if (!self->_initialized) {
+		_ShinyManager_init(self);
+
+		_ShinyManager_createNodeTable(self, TABLE_SIZE_INIT);
+		_ShinyManager_createNodePool(self, TABLE_SIZE_INIT / 2);
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyManager_update(ShinyManager *self) {
+#if SHINY_HAS_ENABLED == TRUE
+	if (!enabled) return;
+#endif
+
+	_ShinyManager_appendTicksToCurNode(self);
+	ShinyZone_preUpdateChain(&self->rootZone);
+
+	if (self->_firstUpdate || self->damping == 0) {
+		self->_firstUpdate = FALSE;
+		ShinyNode_updateTreeClean(&self->rootNode);
+		ShinyZone_updateChainClean(&self->rootZone);
+
+	} else {
+		ShinyNode_updateTree(&self->rootNode, self->damping);
+		ShinyZone_updateChain(&self->rootZone, self->damping);
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyManager_updateClean(ShinyManager *self) {
+#if SHINY_HAS_ENABLED == TRUE
+	if (!enabled) return;
+#endif
+
+	_ShinyManager_appendTicksToCurNode(self);
+	ShinyZone_preUpdateChain(&self->rootZone);
+
+	self->_firstUpdate = FALSE;
+	ShinyNode_updateTreeClean(&self->rootNode);
+	ShinyZone_updateChainClean(&self->rootZone);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyManager_clear(ShinyManager *self) {
+	ShinyManager_destroy(self);
+	ShinyManager_preLoad(self);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyManager_destroy(ShinyManager *self) {
+	ShinyManager_destroyNodes(self);
+	ShinyManager_resetZones(self);
+	_ShinyManager_uninit(self);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+ShinyNode* _ShinyManager_lookupNode(ShinyManager *self, ShinyNodeCache *a_cache, ShinyZone *a_zone) {
+	uint32_t nHash = hash_value(self->_curNode, a_zone);
+	uint32_t nIndex = nHash & self->_tableMask;
+	ShinyNode* pNode = self->_nodeTable[nIndex];
+
+	_ShinyManager_incLookup(self);
+	_ShinyManager_incLookupSuccess(self);
+
+	if (pNode) {
+		uint32_t nStep;
+
+		if (ShinyNode_isEqual(pNode, self->_curNode, a_zone)) return pNode; /* found it! */
+		
+		/* hash collision: */
+
+		/* compute a secondary hash function for stepping */
+		nStep = hash_offset(nHash);
+
+		for (;;) {
+			_ShinyManager_incLookup(self);
+
+			nIndex = (nIndex + nStep) & self->_tableMask;
+			pNode = self->_nodeTable[nIndex];
+
+			if (!pNode) break; /* found empty slot */
+			else if (ShinyNode_isEqual(pNode, self->_curNode, a_zone)) return pNode; /* found it! */
+		}
+
+		/* loop is guaranteed to end because the hash table is never full */
+	}
+
+	if (a_zone->_state == SHINY_ZONE_STATE_HIDDEN) { /* zone is not initialized */
+		ShinyZone_init(a_zone, self->_lastZone);
+
+		self->_lastZone = a_zone;
+		self->zoneCount++;
+
+		if (self->_initialized == FALSE) { /* first time init */
+			_ShinyManager_init(self);
+
+			_ShinyManager_createNodeTable(self, TABLE_SIZE_INIT);
+			_ShinyManager_createNodePool(self, TABLE_SIZE_INIT / 2);
+
+			/* initialization has invalidated nIndex
+			 * we must compute nIndex again
+			 */
+			return _ShinyManager_createNode(self, a_cache, a_zone);
+		}
+	}
+
+	/* Althouth nodeCount is not updated
+	 * it includes rootNode so it adds up.
+	 *
+	 * check if we need to grow the table
+	 * we keep it at most 1/2 full to be very fast
+	 */
+	if (self->_tableSize < 2 * self->nodeCount) {
+
+		_ShinyManager_resizeNodeTable(self, 2 * self->_tableSize);
+		_ShinyManager_resizeNodePool(self, self->nodeCount - 1);
+
+		/* resize has invalidated nIndex
+		 * we must compute nIndex again
+		 */
+		return _ShinyManager_createNode(self, a_cache, a_zone);
+	}
+	
+	self->nodeCount++;
+
+	{
+		ShinyNode* pNewNode = ShinyNodePool_newItem(self->_lastNodePool);
+		ShinyNode_init(pNewNode, self->_curNode, a_zone, a_cache);
+
+		self->_nodeTable[nIndex] = pNewNode;
+		return pNewNode;
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void _ShinyManager_insertNode(ShinyManager *self, ShinyNode* a_pNode) {
+	uint32_t nHash = hash_value(a_pNode->parent, a_pNode->zone);
+	uint32_t nIndex = nHash & self->_tableMask;
+
+	if (self->_nodeTable[nIndex]) {
+		uint32_t nStep = hash_offset(nHash);
+
+		while (self->_nodeTable[nIndex])
+			nIndex = (nIndex + nStep) & self->_tableMask;
+	}
+
+	self->_nodeTable[nIndex] = a_pNode;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+ShinyNode* _ShinyManager_createNode(ShinyManager *self, ShinyNodeCache* a_cache, ShinyZone* a_pZone) {
+	ShinyNode* pNewNode = ShinyNodePool_newItem(self->_lastNodePool);
+	ShinyNode_init(pNewNode, self->_curNode, a_pZone, a_cache);
+
+	self->nodeCount++;
+	_ShinyManager_insertNode(self, pNewNode);
+	return pNewNode;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void _ShinyManager_createNodePool(ShinyManager *self, uint32_t a_nCount) {
+	self->_firstNodePool = ShinyNodePool_create(a_nCount);
+	self->_lastNodePool = self->_firstNodePool;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void _ShinyManager_resizeNodePool(ShinyManager *self, uint32_t a_nCount) {
+	ShinyNodePool* pPool = ShinyNodePool_create(a_nCount);
+	self->_lastNodePool->nextPool = pPool;
+	self->_lastNodePool = pPool;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void _ShinyManager_createNodeTable(ShinyManager *self, uint32_t a_nCount) {
+	self->_tableSize = a_nCount;
+	self->_tableMask = a_nCount - 1;
+
+	self->_nodeTable = (ShinyNodeTable*)
+		malloc(sizeof(ShinyNode) * a_nCount);
+
+	memset(self->_nodeTable, 0, a_nCount * sizeof(ShinyNode*));
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void _ShinyManager_resizeNodeTable(ShinyManager *self, uint32_t a_nCount) {
+	ShinyNodePool* pPool;
+
+	free(self->_nodeTable);
+	_ShinyManager_createNodeTable(self, a_nCount);
+
+	pPool = self->_firstNodePool;
+	while (pPool) {
+
+		ShinyNode *pIter = ShinyNodePool_firstItem(pPool);
+
+		while (pIter != pPool->_nextItem)
+			_ShinyManager_insertNode(self, pIter++);
+
+		pPool = pPool->nextPool;
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyManager_resetZones(ShinyManager *self) {
+	ShinyZone_resetChain(&self->rootZone);
+	self->_lastZone = &self->rootZone;
+	self->zoneCount = 1;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyManager_destroyNodes(ShinyManager *self) {
+	if (self->_firstNodePool) {
+		ShinyNodePool_destroy(self->_firstNodePool);
+		self->_firstNodePool = NULL;
+	}
+
+	if (self->_nodeTable != _ShinyManager_dummyNodeTable) {
+		free(self->_nodeTable);
+
+		self->_nodeTable = _ShinyManager_dummyNodeTable;
+		self->_tableSize = 1;
+		self->_tableMask = 0;
+	}
+
+	self->_curNode = &self->rootNode;
+	self->nodeCount = 1;
+
+	_ShinyManager_init(self);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+const char* ShinyManager_getOutputErrorString(ShinyManager *self) {
+	if (self->_firstUpdate) return "!!! Profile data must first be updated !!!";
+	else if (!self->_initialized) return "!!! No profiles where executed !!!";
+	else return NULL;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+#if SHINY_COMPILER == SHINY_COMPILER_MSVC
+#	pragma warning (push)
+#	pragma warning (disable: 4996)
+#endif
+
+int ShinyManager_output(ShinyManager *self, const char *a_filename) {
+	if (!a_filename) {
+		ShinyManager_outputToStream(self, stdout);
+
+	} else {
+		FILE *file = fopen(a_filename, "w");
+		if (!file) return FALSE;
+		ShinyManager_outputToStream(self, file);
+		fclose(file);
+	}
+
+	return TRUE;
+}
+
+#if SHINY_COMPILER == SHINY_COMPILER_MSVC
+#	pragma warning (pop)
+#endif
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyManager_outputToStream(ShinyManager *self, FILE *a_stream) {
+	const char *error = ShinyManager_getOutputErrorString(self);
+
+	if (error) {
+		fwrite(error, 1, strlen(error), a_stream);
+		fwrite("\n\n", 1, 2, a_stream);
+		return;
+	}
+
+#if SHINY_OUTPUT_MODE & SHINY_OUTPUT_MODE_FLAT
+	ShinyManager_sortZones(self);
+
+	{
+		int size = ShinyPrintZonesSize(self->zoneCount);
+		char *buffer = (char*) malloc(size);
+		ShinyPrintZones(buffer, &self->rootZone);
+		fwrite(buffer, 1, size - 1, a_stream);
+		fwrite("\n\n", 1, 2, a_stream);
+		free(buffer);
+	}
+#endif
+
+#if SHINY_OUTPUT_MODE & SHINY_OUTPUT_MODE_TREE
+	{
+		int size = ShinyPrintNodesSize(self->nodeCount);
+		char *buffer = (char*) malloc(size);
+		ShinyPrintNodes(buffer, &self->rootNode);
+		fwrite(buffer, 1, size - 1, a_stream);
+		fwrite("\n\n", 1, 2, a_stream);
+		free(buffer);
+	}
+#endif
+}
+
+#endif /* SLIC3R_PROFILE */

src/Shiny/ShinyManager.h

@@ -0,0 +1,263 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_MANAGER_H
+#define SHINY_MANAGER_H
+
+#include "ShinyZone.h"
+#include "ShinyNode.h"
+#include "ShinyNodePool.h"
+#include "ShinyTools.h"
+#include "ShinyOutput.h"
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct {
+#ifdef SHINY_HAS_ENABLED
+	bool enabled;
+#endif
+
+	shinytick_t _lastTick;
+
+	ShinyNode* _curNode;
+
+	uint32_t _tableMask; /* = _tableSize - 1 */
+
+	ShinyNodeTable* _nodeTable;
+
+#ifdef SHINY_LOOKUP_RATE
+	uint64_t _lookupCount;
+	uint64_t _lookupSuccessCount;
+#endif
+
+	uint32_t _tableSize;
+
+	uint32_t nodeCount;
+	uint32_t zoneCount;
+
+	ShinyZone* _lastZone;
+
+	ShinyNodePool* _lastNodePool;
+	ShinyNodePool* _firstNodePool;
+
+	ShinyNode rootNode;
+	ShinyZone rootZone;
+
+	float damping;
+
+	int _initialized;
+	int _firstUpdate;
+} ShinyManager;
+
+
+/*---------------------------------------------------------------------------*/
+
+extern ShinyNode* _ShinyManager_dummyNodeTable[];
+
+extern ShinyManager Shiny_instance;
+
+
+/*---------------------------------------------------------------------------*/
+
+SHINY_INLINE void _ShinyManager_appendTicksToCurNode(ShinyManager *self) {
+	shinytick_t curTick;
+	ShinyGetTicks(&curTick);
+
+	ShinyNode_appendTicks(self->_curNode, curTick - self->_lastTick);
+	self->_lastTick = curTick;
+}
+
+SHINY_API ShinyNode* _ShinyManager_lookupNode(ShinyManager *self, ShinyNodeCache* a_cache, ShinyZone* a_zone);
+
+SHINY_API void _ShinyManager_createNodeTable(ShinyManager *self, uint32_t a_count);
+SHINY_API void _ShinyManager_resizeNodeTable(ShinyManager *self, uint32_t a_count);
+
+SHINY_API void _ShinyManager_createNodePool(ShinyManager *self, uint32_t a_count);
+SHINY_API void _ShinyManager_resizeNodePool(ShinyManager *self, uint32_t a_count);
+
+SHINY_API ShinyNode* _ShinyManager_createNode(ShinyManager *self, ShinyNodeCache* a_cache, ShinyZone* a_pZone);
+SHINY_API void _ShinyManager_insertNode(ShinyManager *self, ShinyNode* a_pNode);
+
+SHINY_INLINE void _ShinyManager_init(ShinyManager *self) {
+	self->_initialized = TRUE;
+
+	self->rootNode._last.entryCount = 1;
+	self->rootNode._last.selfTicks = 0;
+	ShinyGetTicks(&self->_lastTick);
+}
+
+SHINY_INLINE void _ShinyManager_uninit(ShinyManager *self) {
+	self->_initialized = FALSE;
+
+	ShinyNode_clear(&self->rootNode);
+	self->rootNode.parent = &self->rootNode;
+	self->rootNode.zone = &self->rootZone;
+}
+
+#ifdef SHINY_LOOKUP_RATE
+SHINY_INLINE void _ShinyManager_incLookup(ShinyManager *self) { self->_lookupCount++; }
+SHINY_INLINE void _ShinyManager_incLookupSuccess(ShinyManager *self) { self->_lookupSuccessCount++; }
+SHINY_INLINE float ShinyManager_lookupRate(const ShinyManager *self) { return ((float) self->_lookupSuccessCount) / ((float) self->_lookupCount); }
+
+#else
+SHINY_INLINE void _ShinyManager_incLookup(ShinyManager * self) { self = self; }
+SHINY_INLINE void _ShinyManager_incLookupSuccess(ShinyManager *  self) { self = self; }
+SHINY_INLINE float ShinyManager_lookupRate(const ShinyManager *  self) { self = self; return -1; }
+#endif
+
+SHINY_API void ShinyManager_resetZones(ShinyManager *self);
+SHINY_API void ShinyManager_destroyNodes(ShinyManager *self);
+
+SHINY_INLINE float ShinyManager_tableUsage(const ShinyManager *self)  {
+	return ((float) self->nodeCount) / ((float) self->_tableSize);
+}
+
+SHINY_INLINE uint32_t ShinyManager_allocMemInBytes(const ShinyManager *self) {
+	return self->_tableSize * sizeof(ShinyNode*)
+		 + (self->_firstNodePool)? ShinyNodePool_memoryUsageChain(self->_firstNodePool) : 0;
+}
+
+SHINY_INLINE void ShinyManager_beginNode(ShinyManager *self, ShinyNode* a_node) {
+	ShinyNode_beginEntry(a_node);
+
+	_ShinyManager_appendTicksToCurNode(self);
+	self->_curNode = a_node;
+}
+
+SHINY_INLINE void ShinyManager_lookupAndBeginNode(ShinyManager *self, ShinyNodeCache* a_cache, ShinyZone* a_zone) {
+#ifdef SHINY_HAS_ENABLED
+	if (!self->enabled) return;
+#endif
+
+	if (self->_curNode != (*a_cache)->parent)
+		*a_cache = _ShinyManager_lookupNode(self, a_cache, a_zone);
+
+	ShinyManager_beginNode(self, *a_cache);
+}
+
+SHINY_INLINE void ShinyManager_endCurNode(ShinyManager *self) {
+#ifdef SHINY_HAS_ENABLED
+	if (!self->enabled) return;
+#endif
+
+	_ShinyManager_appendTicksToCurNode(self);
+	self->_curNode = self->_curNode->parent;
+}
+
+/**/
+
+SHINY_API void ShinyManager_preLoad(ShinyManager *self);
+
+SHINY_API void ShinyManager_updateClean(ShinyManager *self);
+SHINY_API void ShinyManager_update(ShinyManager *self);
+
+SHINY_API void ShinyManager_clear(ShinyManager *self);
+SHINY_API void ShinyManager_destroy(ShinyManager *self);
+
+SHINY_INLINE void ShinyManager_sortZones(ShinyManager *self) {
+	if (self->rootZone.next)
+		self->_lastZone = ShinyZone_sortChain(&self->rootZone.next);
+}
+
+SHINY_API const char* ShinyManager_getOutputErrorString(ShinyManager *self);
+
+SHINY_API int ShinyManager_output(ShinyManager *self, const char *a_filename);
+SHINY_API void ShinyManager_outputToStream(ShinyManager *self, FILE *stream);
+
+#if __cplusplus
+} /* end of extern "C" */
+
+SHINY_INLINE std::string ShinyManager_outputTreeToString(ShinyManager *self) {
+	const char* error = ShinyManager_getOutputErrorString(self);
+	if (error) return error;
+	else return ShinyNodesToString(&self->rootNode, self->nodeCount);
+}
+
+SHINY_INLINE std::string ShinyManager_outputFlatToString(ShinyManager *self) {
+	const char* error = ShinyManager_getOutputErrorString(self);
+	if (error) return error;
+
+	ShinyManager_sortZones(self);
+	return ShinyZonesToString(&self->rootZone, self->zoneCount);
+}
+
+extern "C" { /* end of c++ */
+#endif
+
+SHINY_INLINE int ShinyManager_isZoneSelfTimeBelow(ShinyManager *self, ShinyZone* a_zone, float a_percentage) {
+	return a_percentage * (float) self->rootZone.data.childTicks.cur
+		<= (float) a_zone->data.selfTicks.cur; 
+}
+
+SHINY_INLINE int ShinyManager_isZoneTotalTimeBelow(ShinyManager *self, ShinyZone* a_zone, float a_percentage) {
+	return a_percentage * (float) self->rootZone.data.childTicks.cur
+		<= (float) ShinyData_totalTicksCur(&a_zone->data); 
+}
+
+/**/
+
+SHINY_INLINE void ShinyManager_enumerateNodes(ShinyManager *self, void (*a_func)(const ShinyNode*)) {
+	ShinyNode_enumerateNodes(&self->rootNode, a_func);
+}
+
+SHINY_INLINE void ShinyManager_enumerateZones(ShinyManager *self, void (*a_func)(const ShinyZone*)) {
+	ShinyZone_enumerateZones(&self->rootZone, a_func);
+}
+
+#if __cplusplus
+} /* end of extern "C" */
+
+template <class T> void ShinyManager_enumerateNodes(ShinyManager *self, T* a_this, void (T::*a_func)(const ShinyNode*)) {
+	ShinyNode_enumerateNodes(&self->rootNode, a_this, a_func);
+}
+
+template <class T> void ShinyManager_enumerateZones(ShinyManager *self, T* a_this, void (T::*a_func)(const ShinyZone*)) {
+	ShinyZone_enumerateZones(&self->rootZone, a_this, a_func);
+}
+
+extern "C" { /* end of c++ */
+#endif
+
+
+/*---------------------------------------------------------------------------*/
+
+#if __cplusplus
+} /* end of extern "C" */
+
+class ShinyEndNodeOnDestruction {
+public:
+
+	SHINY_INLINE ~ShinyEndNodeOnDestruction() {
+		ShinyManager_endCurNode(&Shiny_instance);
+	}
+};
+#endif
+
+#endif /* SHINY_MANAGER_H */

src/Shiny/ShinyNode.c

@@ -0,0 +1,129 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifdef SLIC3R_PROFILE
+
+#include "ShinyNode.h"
+#include "ShinyZone.h"
+#include "ShinyNodeState.h"
+
+#include <memory.h>
+
+/*---------------------------------------------------------------------------*/
+
+ShinyNode _ShinyNode_dummy = {
+	/* _last = */ { 0, 0 },
+	/* zone = */ NULL,
+	/* parent = */ NULL,
+	/* nextSibling = */ NULL,
+	/* firstChild = */ NULL,
+	/* lastChild = */ NULL
+};
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyNode_updateTree(ShinyNode* first, float a_damping) {
+	ShinyNodeState *top = NULL;
+	ShinyNode *node = first;
+
+	for (;;) {
+		do {
+			top = ShinyNodeState_push(top, node);
+			node = node->firstChild;
+		} while (node);
+
+		for (;;) {
+			node = ShinyNodeState_finishAndGetNext(top, a_damping);
+			top = ShinyNodeState_pop(top);
+
+			if (node) break;
+			else if (!top) return;
+		}
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyNode_updateTreeClean(ShinyNode* first) {
+	ShinyNodeState *top = NULL;
+	ShinyNode *node = first;
+
+	for (;;) {
+		do {
+			top = ShinyNodeState_push(top, node);
+			node = node->firstChild;
+		} while (node);
+
+		for (;;) {
+			node = ShinyNodeState_finishAndGetNextClean(top);
+			top = ShinyNodeState_pop(top);
+
+			if (node) break;
+			else if (!top) return;
+		}
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+const ShinyNode* ShinyNode_findNextInTree(const ShinyNode* self) {
+	if (self->firstChild) {
+		return self->firstChild;
+
+	} else if (self->nextSibling) {
+		return self->nextSibling;
+
+	} else {
+		ShinyNode* pParent = self->parent;
+
+		while (!ShinyNode_isRoot(pParent)) {
+			if (pParent->nextSibling) return pParent->nextSibling;
+			else pParent = pParent->parent;
+		}
+
+		return NULL;
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyNode_clear(ShinyNode* self) {
+	memset(self, 0, sizeof(ShinyNode));
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyNode_enumerateNodes(const ShinyNode* a_node, void (*a_func)(const ShinyNode*)) {
+	a_func(a_node);
+
+	if (a_node->firstChild) ShinyNode_enumerateNodes(a_node->firstChild, a_func);
+	if (a_node->nextSibling) ShinyNode_enumerateNodes(a_node->nextSibling, a_func);
+}
+
+#endif /* SLIC3R_PROFILE */

src/Shiny/ShinyNode.h

@@ -0,0 +1,133 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_NODE_H
+#define SHINY_NODE_H
+
+#include "ShinyData.h"
+#include "ShinyTools.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct _ShinyNode {
+
+	ShinyLastData _last;
+
+	struct _ShinyZone* zone;
+	struct _ShinyNode* parent;
+	struct _ShinyNode* nextSibling;
+
+	struct _ShinyNode* firstChild;
+	struct _ShinyNode* lastChild;
+
+	uint32_t childCount;
+	uint32_t entryLevel;
+
+	ShinyNodeCache* _cache;
+
+	ShinyData data;
+
+} ShinyNode;
+
+
+/*---------------------------------------------------------------------------*/
+
+extern ShinyNode _ShinyNode_dummy;
+
+
+/*---------------------------------------------------------------------------*/
+
+SHINY_INLINE void ShinyNode_addChild(ShinyNode* self,  ShinyNode* a_child) {
+	if (self->childCount++) {
+		self->lastChild->nextSibling = a_child;
+		self->lastChild = a_child;
+
+	} else {
+		self->lastChild = a_child;
+		self->firstChild = a_child;
+	}
+}
+
+SHINY_INLINE void ShinyNode_init(ShinyNode* self, ShinyNode* a_parent, struct _ShinyZone* a_zone, ShinyNodeCache* a_cache) {
+	/* NOTE: all member variables are assumed to be zero when allocated */
+
+	self->zone = a_zone;
+	self->parent = a_parent;
+
+	self->entryLevel = a_parent->entryLevel + 1;
+	ShinyNode_addChild(a_parent, self);
+
+	self->_cache = a_cache;
+}
+
+SHINY_API void ShinyNode_updateTree(ShinyNode* self, float a_damping);
+SHINY_API void ShinyNode_updateTreeClean(ShinyNode* self);
+
+SHINY_INLINE void ShinyNode_destroy(ShinyNode* self) {
+	*(self->_cache) = &_ShinyNode_dummy;
+}
+
+SHINY_INLINE void ShinyNode_appendTicks(ShinyNode* self, shinytick_t a_elapsedTicks) {
+	self->_last.selfTicks += a_elapsedTicks;
+}
+
+SHINY_INLINE void ShinyNode_beginEntry(ShinyNode* self) {
+	self->_last.entryCount++;
+}
+
+SHINY_INLINE int ShinyNode_isRoot(ShinyNode* self) {
+	return (self->entryLevel == 0);
+}
+
+SHINY_INLINE int ShinyNode_isDummy(ShinyNode* self) {
+	return (self == &_ShinyNode_dummy);
+}
+
+SHINY_INLINE int ShinyNode_isEqual(ShinyNode* self, const ShinyNode* a_parent, const struct _ShinyZone* a_zone) {
+	return (self->parent == a_parent && self->zone == a_zone);
+}
+
+SHINY_API const ShinyNode* ShinyNode_findNextInTree(const ShinyNode* self);
+
+SHINY_API void ShinyNode_clear(ShinyNode* self);
+
+SHINY_API void ShinyNode_enumerateNodes(const ShinyNode* a_node, void (*a_func)(const ShinyNode*));
+
+#if __cplusplus
+} /* end of extern "C" */
+
+template <class T>
+void ShinyNode_enumerateNodes(const ShinyNode* a_node, T* a_this, void (T::*a_func)(const ShinyNode*)) {
+	(a_this->*a_func)(a_node);
+
+	if (a_node->firstChild) ShinyNode_enumerateNodes(a_node->firstChild, a_this, a_func);
+	if (a_node->nextSibling) ShinyNode_enumerateNodes(a_node->nextSibling, a_this, a_func);
+}
+#endif /* __cplusplus */
+
+#endif /* SHINY_NODE_H */

src/Shiny/ShinyNodePool.c

@@ -0,0 +1,77 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifdef SLIC3R_PROFILE
+
+#include "ShinyNodePool.h"
+#include "ShinyTools.h"
+
+#include <memory.h>
+#include <malloc.h>
+
+/*---------------------------------------------------------------------------*/
+
+ShinyNodePool* ShinyNodePool_create(uint32_t a_items) {
+	ShinyNodePool* pPool = (ShinyNodePool*)
+		malloc(sizeof(ShinyNodePool) + sizeof(ShinyNode) * (a_items - 1));
+
+	pPool->nextPool = NULL;
+	pPool->_nextItem = &pPool->_items[0];
+	pPool->endOfItems = &pPool->_items[a_items];
+
+	memset(&pPool->_items[0], 0, a_items * sizeof(ShinyNode));
+	return pPool;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+uint32_t ShinyNodePool_memoryUsageChain(ShinyNodePool *first) {
+	uint32_t bytes = (uint32_t) ((char*) first->endOfItems - (char*) first);
+	ShinyNodePool *pool = first->nextPool;
+
+	while (pool) {
+		bytes += (uint32_t) ((char*) pool->endOfItems - (char*) pool);
+		pool = pool->nextPool;
+	}
+
+	return bytes;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyNodePool_destroy(ShinyNodePool *self) {
+	ShinyNode* firstNode = ShinyNodePool_firstItem(self);
+	ShinyNode* lastNode = self->_nextItem;
+
+	while (firstNode != lastNode)
+		ShinyNode_destroy(firstNode++);
+
+	/* TODO: make this into a loop or a tail recursion */
+	if (self->nextPool) ShinyNodePool_destroy(self->nextPool);
+	free(self);
+}
+
+#endif /* SLIC3R_PROFILE */

src/Shiny/ShinyNodePool.h

@@ -0,0 +1,67 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_NODE_POOL_H
+#define SHINY_NODE_POOL_H
+
+#include "ShinyNode.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct _ShinyNodePool {
+
+	struct _ShinyNodePool* nextPool;
+
+	ShinyNode *_nextItem;
+	ShinyNode *endOfItems;
+
+	ShinyNode _items[1];
+
+} ShinyNodePool;
+
+
+/*---------------------------------------------------------------------------*/
+
+SHINY_INLINE ShinyNode* ShinyNodePool_firstItem(ShinyNodePool *self) {
+	return &(self->_items[0]);
+}
+
+SHINY_INLINE ShinyNode* ShinyNodePool_newItem(ShinyNodePool *self) {
+	return self->_nextItem++;
+}
+
+ShinyNodePool* ShinyNodePool_create(uint32_t a_items);
+void ShinyNodePool_destroy(ShinyNodePool *self);
+
+uint32_t ShinyNodePool_memoryUsageChain(ShinyNodePool *first);
+
+#if __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* SHINY_NODE_POOL_H */

src/Shiny/ShinyNodeState.c

@@ -0,0 +1,108 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifdef SLIC3R_PROFILE
+
+#include "ShinyNodeState.h"
+#include "ShinyNode.h"
+#include "ShinyZone.h"
+
+#include <malloc.h>
+
+/*---------------------------------------------------------------------------*/
+
+ShinyNodeState* ShinyNodeState_push(ShinyNodeState *a_top, ShinyNode *a_node) {
+	ShinyZone *zone = a_node->zone;
+	ShinyNodeState *self = (ShinyNodeState*) malloc(sizeof(ShinyNodeState));
+	self->node = a_node;
+	self->_prev = a_top;
+
+	a_node->data.selfTicks.cur = a_node->_last.selfTicks;
+	a_node->data.entryCount.cur = a_node->_last.entryCount;
+
+	zone->data.selfTicks.cur += a_node->_last.selfTicks;
+	zone->data.entryCount.cur += a_node->_last.entryCount;
+	
+	a_node->data.childTicks.cur = 0;
+	a_node->_last.selfTicks = 0;
+	a_node->_last.entryCount = 0;
+
+	self->zoneUpdating = zone->_state != SHINY_ZONE_STATE_UPDATING;
+	if (self->zoneUpdating) {
+		zone->_state = SHINY_ZONE_STATE_UPDATING;
+	} else {
+		zone->data.childTicks.cur -= a_node->data.selfTicks.cur;
+	}
+
+	return self;
+}
+
+/*---------------------------------------------------------------------------*/
+
+ShinyNodeState* ShinyNodeState_pop(ShinyNodeState *a_top) {
+	ShinyNodeState *prev = a_top->_prev;
+	free(a_top);
+	return prev;
+}
+
+/*---------------------------------------------------------------------------*/
+
+ShinyNode* ShinyNodeState_finishAndGetNext(ShinyNodeState *self, float a_damping) {
+	ShinyNode *node = self->node;
+	ShinyZone *zone = node->zone;
+
+	if (self->zoneUpdating) {					
+		zone->data.childTicks.cur += node->data.childTicks.cur;
+		zone->_state = SHINY_ZONE_STATE_INITIALIZED;
+	}
+
+	ShinyData_computeAverage(&node->data, a_damping);
+
+	if (!ShinyNode_isRoot(node))
+		node->parent->data.childTicks.cur += node->data.selfTicks.cur + node->data.childTicks.cur;
+
+	return node->nextSibling;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+ShinyNode* ShinyNodeState_finishAndGetNextClean(ShinyNodeState *self) {
+	ShinyNode *node = self->node;
+	ShinyZone *zone = node->zone;
+
+	if (self->zoneUpdating) {					
+		zone->data.childTicks.cur += node->data.childTicks.cur;
+		zone->_state = SHINY_ZONE_STATE_INITIALIZED;
+	}
+
+	ShinyData_copyAverage(&node->data);
+
+	if (!ShinyNode_isRoot(node))
+		node->parent->data.childTicks.cur += node->data.selfTicks.cur + node->data.childTicks.cur;
+
+	return node->nextSibling;
+}
+
+#endif /* SLIC3R_PROFILE */

src/Shiny/ShinyNodeState.h

@@ -0,0 +1,56 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_NODE_STATE_H
+#define SHINY_NODE_STATE_H
+
+#include "ShinyNode.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct _ShinyNodeState {
+	ShinyNode *node;
+	int zoneUpdating;
+
+	struct _ShinyNodeState *_prev;
+} ShinyNodeState;
+
+
+/*---------------------------------------------------------------------------*/
+
+ShinyNodeState* ShinyNodeState_push(ShinyNodeState *a_top, ShinyNode *a_node);
+ShinyNodeState* ShinyNodeState_pop(ShinyNodeState *a_top);
+
+ShinyNode* ShinyNodeState_finishAndGetNext(ShinyNodeState *self, float a_damping);
+ShinyNode* ShinyNodeState_finishAndGetNextClean(ShinyNodeState *self);
+
+#if __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* SHINY_NODE_STATE_H */

src/Shiny/ShinyOutput.c

@@ -0,0 +1,189 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifdef SLIC3R_PROFILE
+
+#include "ShinyOutput.h"
+
+#include <stdio.h>
+
+#if SHINY_COMPILER == SHINY_COMPILER_MSVC
+#	pragma warning(disable: 4996)
+#	define snprintf		_snprintf
+#	define TRAILING		0
+
+#else
+#	define TRAILING		1
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+#define OUTPUT_WIDTH_CALL	6
+#define OUTPUT_WIDTH_TIME	(6+3)
+#define OUTPUT_WIDTH_PERC	(4+3)
+#define OUTPUT_WIDTH_SUM	120 
+
+#define OUTPUT_WIDTH_DATA	(1+OUTPUT_WIDTH_CALL + 1 + 2*(OUTPUT_WIDTH_TIME+4+OUTPUT_WIDTH_PERC+1) + 1)
+#define OUTPUT_WIDTH_NAME	(OUTPUT_WIDTH_SUM - OUTPUT_WIDTH_DATA)
+
+
+/*---------------------------------------------------------------------------*/
+
+SHINY_INLINE char* printHeader(char *output, const char *a_title) {
+	snprintf(output, OUTPUT_WIDTH_SUM + TRAILING,
+		"%-*s %*s %*s %*s",
+		OUTPUT_WIDTH_NAME, a_title,
+		OUTPUT_WIDTH_CALL, "calls",
+		OUTPUT_WIDTH_TIME+4+OUTPUT_WIDTH_PERC+1, "self time",
+		OUTPUT_WIDTH_TIME+4+OUTPUT_WIDTH_PERC+1, "total time");
+
+	return output + OUTPUT_WIDTH_SUM;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+SHINY_INLINE char* printData(char *output, const ShinyData *a_data, float a_topercent) {
+	float totalTicksAvg = ShinyData_totalTicksAvg(a_data);
+	const ShinyTimeUnit *selfUnit = ShinyGetTimeUnit(a_data->selfTicks.avg);
+	const ShinyTimeUnit *totalUnit = ShinyGetTimeUnit(totalTicksAvg);
+
+	snprintf(output, OUTPUT_WIDTH_DATA + TRAILING,
+		" %*.1f %*.2f %-2s %*.2f%% %*.2f %-2s %*.2f%%",
+		OUTPUT_WIDTH_CALL, a_data->entryCount.avg,
+		OUTPUT_WIDTH_TIME, a_data->selfTicks.avg * selfUnit->invTickFreq, selfUnit->suffix,
+		OUTPUT_WIDTH_PERC, a_data->selfTicks.avg * a_topercent,
+		OUTPUT_WIDTH_TIME, totalTicksAvg * totalUnit->invTickFreq, totalUnit->suffix,
+		OUTPUT_WIDTH_PERC, totalTicksAvg * a_topercent);
+
+	return output + OUTPUT_WIDTH_DATA;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+SHINY_INLINE char* printNode(char* output, const ShinyNode *a_node, float a_topercent) {
+	int offset = a_node->entryLevel * 2;
+
+	snprintf(output, OUTPUT_WIDTH_NAME + TRAILING, "%*s%-*s",
+		offset, "", OUTPUT_WIDTH_NAME - offset, a_node->zone->name);
+
+	output += OUTPUT_WIDTH_NAME;
+
+	output = printData(output, &a_node->data, a_topercent);
+	return output;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+SHINY_INLINE char* printZone(char* output, const ShinyZone *a_zone, float a_topercent) {
+	snprintf(output, OUTPUT_WIDTH_NAME + TRAILING, "%-*s",
+		OUTPUT_WIDTH_NAME, a_zone->name);
+
+	output += OUTPUT_WIDTH_NAME;
+
+	output = printData(output, &a_zone->data, a_topercent);
+	return output;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+int ShinyPrintNodesSize(uint32_t a_count) {
+	return (1 + a_count) * (OUTPUT_WIDTH_SUM + 1);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+int ShinyPrintZonesSize(uint32_t a_count) {
+	return (1 + a_count) * (OUTPUT_WIDTH_SUM + 1);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyPrintANode(char* output, const ShinyNode *a_node, const ShinyNode *a_root) {
+	float fTicksToPc = 100.0f / a_root->data.childTicks.avg;
+	output = printNode(output, a_node, fTicksToPc);
+	(*output++) = '\0';
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyPrintAZone(char* output, const ShinyZone *a_zone, const ShinyZone *a_root) {
+	float fTicksToPc = 100.0f / a_root->data.childTicks.avg;
+	output = printZone(output, a_zone, fTicksToPc);
+	(*output++) = '\0';
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyPrintNodes(char* output, const ShinyNode *a_root) {
+	float fTicksToPc = 100.0f / a_root->data.childTicks.avg;
+	const ShinyNode *node = a_root;
+
+	output = printHeader(output, "call tree");
+	(*output++) = '\n';
+
+	for (;;) {
+		output = printNode(output, node, fTicksToPc);
+
+		node = ShinyNode_findNextInTree(node);
+		if (node) {
+			(*output++) = '\n';
+		} else {
+			(*output++) = '\0';
+			return;
+		}
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyPrintZones(char* output, const ShinyZone *a_root) {
+	float fTicksToPc = 100.0f / a_root->data.childTicks.avg;
+	const ShinyZone *zone = a_root;
+
+	output = printHeader(output, "sorted list");
+	(*output++) = '\n';
+
+	for (;;) {
+		output = printZone(output, zone, fTicksToPc);
+
+		zone = zone->next;
+		if (zone) {
+			(*output++) = '\n';
+		} else {
+			(*output++) = '\0';
+			return;
+		}
+	}
+}
+
+#endif /* SLIC3R_PROFILE */

src/Shiny/ShinyOutput.h

@@ -0,0 +1,68 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_OUTPUT_H
+#define SHINY_OUTPUT_H
+
+#include "ShinyNode.h"
+#include "ShinyZone.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+SHINY_API int ShinyPrintNodesSize(uint32_t a_count);
+SHINY_API int ShinyPrintZonesSize(uint32_t a_count);
+
+SHINY_API void ShinyPrintANode(char* output, const ShinyNode *a_node, const ShinyNode *a_root);
+SHINY_API void ShinyPrintAZone(char* output, const ShinyZone *a_zone, const ShinyZone *a_root);
+
+SHINY_API void ShinyPrintNodes(char* output, const ShinyNode *a_root);
+SHINY_API void ShinyPrintZones(char* output, const ShinyZone *a_root);
+
+
+/*---------------------------------------------------------------------------*/
+
+#if __cplusplus
+} /* end of extern "C" */
+#include <string>
+
+SHINY_INLINE std::string ShinyNodesToString(const ShinyNode *a_root, uint32_t a_count) {
+	std::string str;
+	str.resize(ShinyPrintNodesSize(a_count) - 1);
+	ShinyPrintNodes(&str[0], a_root);
+	return str;
+}
+
+SHINY_INLINE std::string ShinyZonesToString(const ShinyZone *a_root, uint32_t a_count) {
+	std::string str;
+	str.resize(ShinyPrintZonesSize(a_count) - 1);
+	ShinyPrintZones(&str[0], a_root);
+	return str;
+}
+#endif /* __cplusplus */
+
+#endif /* SHINY_OUTPUT_H */

src/Shiny/ShinyPrereqs.h

@@ -0,0 +1,138 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_PREREQS_H
+#define SHINY_PREREQS_H
+
+
+#include <stdint.h>
+
+/*---------------------------------------------------------------------------*/
+
+#ifndef FALSE
+#define FALSE	0x0
+#endif
+
+#ifndef TRUE
+#define TRUE	0x1
+#endif
+
+#ifndef NULL
+#define NULL	0
+#endif
+
+#include "ShinyConfig.h"
+#include "ShinyVersion.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+#define SHINY_PLATFORM_WIN32	0x1
+#define SHINY_PLATFORM_POSIX	0x2
+
+#if defined (_WIN32)
+#   define SHINY_PLATFORM	SHINY_PLATFORM_WIN32
+
+#else /* ASSUME: POSIX-compliant OS */
+#   define SHINY_PLATFORM	SHINY_PLATFORM_POSIX
+#endif
+
+
+/*---------------------------------------------------------------------------*/
+
+#define SHINY_COMPILER_MSVC		0x1
+#define SHINY_COMPILER_GNUC		0x2
+#define SHINY_COMPILER_OTHER	0x3
+
+#if defined (_MSC_VER)
+#   define SHINY_COMPILER	SHINY_COMPILER_MSVC
+
+#elif defined (__GNUG__)
+#   define SHINY_COMPILER	SHINY_COMPILER_GNUC
+
+#else
+#   define SHINY_COMPILER	SHINY_COMPILER_OTHER
+#endif
+
+
+/*---------------------------------------------------------------------------*/
+
+#if SHINY_COMPILER == SHINY_COMPILER_GNUC
+#include <sys/types.h>
+#include <stdint.h>
+#endif
+
+
+/*---------------------------------------------------------------------------*/
+
+struct _ShinyNode;
+struct _ShinyZone;
+
+typedef struct _ShinyNode* ShinyNodeCache;
+typedef struct _ShinyNode* ShinyNodeTable;
+
+/*---------------------------------------------------------------------------*/
+
+#define SHINY_API
+
+/*---------------------------------------------------------------------------*/
+
+#if SHINY_COMPILER == SHINY_COMPILER_MSVC
+#	define SHINY_INLINE		__inline
+#	define SHINY_UNUSED
+#elif SHINY_COMPILER == SHINY_COMPILER_GNUC
+#	define SHINY_INLINE		inline
+#	define SHINY_UNUSED		__attribute__((unused))
+#elif SHINY_COMPILER == SHINY_COMPILER_OTHER
+#	define SHINY_INLINE		inline
+#	define SHINY_UNUSED
+#endif
+
+
+/*---------------------------------------------------------------------------*/
+
+#if SHINY_COMPILER == SHINY_COMPILER_MSVC
+	typedef int					int32_t;
+	typedef unsigned int		uint32_t;
+
+	typedef __int64				int64_t;
+	typedef unsigned __int64	uint64_t;
+
+/*
+#elif defined(__CYGWIN__)
+	typedef u_int32_t			uint32_t;
+	typedef u_int64_t			uint64_t;
+*/
+#endif
+
+	typedef uint64_t			shinytick_t;
+
+#if __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* SHINY_PREREQS_H */

src/Shiny/ShinyTools.c

@@ -0,0 +1,116 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifdef SLIC3R_PROFILE
+
+#include "ShinyTools.h"
+
+#if SHINY_PLATFORM == SHINY_PLATFORM_WIN32
+#define WIN32_LEAN_AND_MEAN
+#ifndef NOMINMAX
+	#define NOMINMAX
+#endif /* NOMINMAX */
+#include <windows.h>
+
+#elif SHINY_PLATFORM == SHINY_PLATFORM_POSIX
+#include <sys/time.h>
+#endif
+
+
+/*---------------------------------------------------------------------------*/
+
+const ShinyTimeUnit* ShinyGetTimeUnit(float ticks) {
+	static ShinyTimeUnit units[4] = { 0 };
+
+	if (units[0].tickFreq == 0) { /* auto initialize first time */
+		units[0].tickFreq = ShinyGetTickFreq() / 1.0f;
+		units[0].invTickFreq = ShinyGetTickInvFreq() * 1.0f;
+		units[0].suffix = "s";
+
+		units[1].tickFreq = ShinyGetTickFreq() / 1000.0f;
+		units[1].invTickFreq = ShinyGetTickInvFreq() * 1000.0f;
+		units[1].suffix = "ms";
+
+		units[2].tickFreq = ShinyGetTickFreq() / 1000000.0f;
+		units[2].invTickFreq = ShinyGetTickInvFreq() * 1000000.0f;
+		units[2].suffix = "us";
+
+		units[3].tickFreq = ShinyGetTickFreq() / 1000000000.0f;
+		units[3].invTickFreq = ShinyGetTickInvFreq() * 1000000000.0f;
+		units[3].suffix = "ns";
+	}
+
+	if (units[0].tickFreq < ticks) return &units[0];
+	else if (units[1].tickFreq < ticks) return &units[1];
+	else if (units[2].tickFreq < ticks) return &units[2];
+	else return &units[3];
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+#if SHINY_PLATFORM == SHINY_PLATFORM_WIN32
+
+void ShinyGetTicks(shinytick_t *p) {
+	QueryPerformanceCounter((LARGE_INTEGER*)(p));
+}
+
+shinytick_t ShinyGetTickFreq(void) {
+	static shinytick_t freq = 0;
+	if (freq == 0) QueryPerformanceFrequency((LARGE_INTEGER*)(&freq));
+	return freq;
+}
+
+float ShinyGetTickInvFreq(void) {
+	static float invfreq = 0;
+	if (invfreq == 0) invfreq = 1.0f / ShinyGetTickFreq();
+	return invfreq;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+#elif SHINY_PLATFORM == SHINY_PLATFORM_POSIX
+
+//#include <time.h>
+//#include <sys/time.h>
+
+void ShinyGetTicks(shinytick_t *p) {
+	struct timeval time;
+	gettimeofday(&time, NULL);
+
+	*p = time.tv_sec * 1000000 + time.tv_usec;
+}
+
+shinytick_t ShinyGetTickFreq(void) {
+	return 1000000;
+}
+
+float ShinyGetTickInvFreq(void) {
+	return 1.0f / 1000000.0f;
+}
+
+#endif
+
+#endif /* SLIC3R_PROFILE */

src/Shiny/ShinyTools.h

@@ -0,0 +1,57 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_TOOLS_H
+#define SHINY_TOOLS_H
+
+#include "ShinyPrereqs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct {
+	float tickFreq;
+	float invTickFreq;
+	const char* suffix;
+} ShinyTimeUnit;
+
+
+/*---------------------------------------------------------------------------*/
+
+SHINY_API const ShinyTimeUnit* ShinyGetTimeUnit(float ticks);
+
+SHINY_API void ShinyGetTicks(shinytick_t *p);
+
+SHINY_API shinytick_t ShinyGetTickFreq(void);
+
+SHINY_API float ShinyGetTickInvFreq(void);
+
+#if __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* SHINY_TOOLS_H */

src/Shiny/ShinyVersion.h

@@ -0,0 +1,37 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_VERSION_H
+#define SHINY_VERSION_H
+
+
+/*---------------------------------------------------------------------------*/
+
+#define SHINY_VERSION			"2.6 RC1"
+#define SHINY_SHORTNAME			"Shiny"
+#define SHINY_FULLNAME			"Shiny Profiler"
+#define SHINY_COPYRIGHT			"Copyright (C) 2007-2010 Aidin Abedi"
+#define SHINY_DESCRIPTION		"Shiny is a state of the art profiler designed to help finding bottlenecks in your project."
+
+#endif /* SHINY_VERSION_H */

src/Shiny/ShinyZone.c

@@ -0,0 +1,201 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifdef SLIC3R_PROFILE
+
+#include "ShinyZone.h"
+
+#include <memory.h>
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyZone_preUpdateChain(ShinyZone *first) {
+	ShinyZone* zone = first;
+
+	while (zone) {
+		ShinyData_clearCurrent(&(zone->data));
+		zone = zone->next;
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyZone_updateChain(ShinyZone *first, float a_damping) {
+	ShinyZone* zone = first;
+
+	do {
+		ShinyData_computeAverage(&(zone->data), a_damping);
+		zone = zone->next;
+	} while (zone);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyZone_updateChainClean(ShinyZone *first) {
+	ShinyZone* zone = first;
+
+	do {
+		ShinyData_copyAverage(&(zone->data));
+		zone = zone->next;
+	} while (zone);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyZone_resetChain(ShinyZone *first) {
+	ShinyZone* zone = first, *temp;
+
+	do {
+		zone->_state = SHINY_ZONE_STATE_HIDDEN;
+		temp = zone->next;
+		zone->next = NULL;
+		zone = temp;
+	} while (zone);
+}
+
+/*---------------------------------------------------------------------------*/
+
+/* A Linked-List Memory Sort
+   by Philip J. Erdelsky
+   pje@efgh.com
+   http://www.alumni.caltech.edu/~pje/
+
+   Modified by Aidin Abedi
+*/
+
+ShinyZone* ShinyZone_sortChain(ShinyZone **first) /* return ptr to last zone */
+{
+	ShinyZone *p = *first;
+
+	unsigned base;
+	unsigned long block_size;
+
+	struct tape
+	{
+		ShinyZone *first, *last;
+		unsigned long count;
+	} tape[4];
+
+	/* Distribute the records alternately to tape[0] and tape[1]. */
+
+	tape[0].count = tape[1].count = 0L;
+	tape[0].first = NULL;
+	base = 0;
+	while (p != NULL)
+	{
+		ShinyZone *next = p->next;
+		p->next = tape[base].first;
+		tape[base].first = p;
+		tape[base].count++;
+		p = next;
+		base ^= 1;
+	}
+
+	/* If the list is empty or contains only a single record, then */
+	/* tape[1].count == 0L and this part is vacuous.               */
+
+	for (base = 0, block_size = 1L; tape[base+1].count != 0L;
+		base ^= 2, block_size <<= 1)
+	{
+		int dest;
+		struct tape *tape0, *tape1;
+		tape0 = tape + base;
+		tape1 = tape + base + 1;
+		dest = base ^ 2;
+		tape[dest].count = tape[dest+1].count = 0;
+		for (; tape0->count != 0; dest ^= 1)
+		{
+			unsigned long n0, n1;
+			struct tape *output_tape = tape + dest;
+			n0 = n1 = block_size;
+			while (1)
+			{
+				ShinyZone *chosen_record;
+				struct tape *chosen_tape;
+				if (n0 == 0 || tape0->count == 0)
+				{
+					if (n1 == 0 || tape1->count == 0)
+						break;
+					chosen_tape = tape1;
+					n1--;
+				}
+				else if (n1 == 0 || tape1->count == 0)
+				{
+					chosen_tape = tape0;
+					n0--;
+				}
+				else if (ShinyZone_compare(tape1->first, tape0->first) > 0)
+				{
+					chosen_tape = tape1;
+					n1--;
+				}
+				else
+				{
+					chosen_tape = tape0;
+					n0--;
+				}
+				chosen_tape->count--;
+				chosen_record = chosen_tape->first;
+				chosen_tape->first = chosen_record->next;
+				if (output_tape->count == 0)
+					output_tape->first = chosen_record;
+				else
+					output_tape->last->next = chosen_record;
+				output_tape->last = chosen_record;
+				output_tape->count++;
+			}
+		}
+	}
+
+	if (tape[base].count > 1L) {
+		ShinyZone* last = tape[base].last;
+		*first = tape[base].first;
+		last->next = NULL;
+		return last;
+
+	} else {
+		return NULL;
+	}
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyZone_clear(ShinyZone* self) {
+	memset(self, 0, sizeof(ShinyZone));
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+void ShinyZone_enumerateZones(const ShinyZone* a_zone, void (*a_func)(const ShinyZone*)) {
+	a_func(a_zone);
+
+	if (a_zone->next) ShinyZone_enumerateZones(a_zone->next, a_func);
+}
+
+#endif /* SLIC3R_PROFILE */

src/Shiny/ShinyZone.h

@@ -0,0 +1,91 @@
+/*
+The MIT License
+
+Copyright (c) 2007-2010 Aidin Abedi http://code.google.com/p/shinyprofiler/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef SHINY_ZONE_H
+#define SHINY_ZONE_H
+
+#include "ShinyData.h"
+#include <memory.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+
+#define SHINY_ZONE_STATE_HIDDEN			0
+#define SHINY_ZONE_STATE_INITIALIZED	1
+#define SHINY_ZONE_STATE_UPDATING		2
+
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct _ShinyZone {
+	struct _ShinyZone* next;
+	int _state;
+	const char* name;
+	ShinyData data;
+} ShinyZone;
+
+
+/*---------------------------------------------------------------------------*/
+
+SHINY_INLINE void ShinyZone_init(ShinyZone *self, ShinyZone* a_prev) {
+	self->_state = SHINY_ZONE_STATE_INITIALIZED;
+	a_prev->next = self;
+}
+
+SHINY_INLINE void ShinyZone_uninit(ShinyZone *self) {
+	self->_state = SHINY_ZONE_STATE_HIDDEN;
+	self->next = NULL;
+}
+
+SHINY_API void ShinyZone_preUpdateChain(ShinyZone *first);
+SHINY_API void ShinyZone_updateChain(ShinyZone *first, float a_damping);
+SHINY_API void ShinyZone_updateChainClean(ShinyZone *first);
+
+SHINY_API void ShinyZone_resetChain(ShinyZone *first);
+
+SHINY_API ShinyZone* ShinyZone_sortChain(ShinyZone **first);
+
+SHINY_INLINE float ShinyZone_compare(ShinyZone *a, ShinyZone *b) {
+	return a->data.selfTicks.avg - b->data.selfTicks.avg;
+}
+
+SHINY_API void ShinyZone_clear(ShinyZone* self);
+
+SHINY_API void ShinyZone_enumerateZones(const ShinyZone* a_zone, void (*a_func)(const ShinyZone*));
+
+#if __cplusplus
+} /* end of extern "C" */
+
+template <class T>
+void ShinyZone_enumerateZones(const ShinyZone* a_zone, T* a_this, void (T::*a_func)(const ShinyZone*)) {
+	(a_this->*a_func)(a_zone);
+
+	if (a_zone->next) ShinyZone_enumerateZones(a_zone->next, a_this, a_func);
+}
+#endif /* __cplusplus */
+
+#endif /* SHINY_ZONE_H */

src/StackWalker.cpp

@@ -0,0 +1,538 @@
+#include "StackWalker.h"
+#include <strsafe.h>
+//#include <atlconv.h>
+#include <dbghelp.h>
+#pragma comment(lib, "version.lib")
+#pragma comment( lib, "dbghelp.lib" )
+
+CStackWalker::CStackWalker(HANDLE hProcess, WORD wPID, LPCTSTR lpSymbolPath):
+	m_hProcess(hProcess),
+	m_wPID(wPID),
+	m_bSymbolLoaded(FALSE),
+	m_lpszSymbolPath(NULL)
+{
+	if (NULL != lpSymbolPath)
+	{
+		size_t dwLength = 0;
+		StringCchLength(lpSymbolPath, MAX_SYMBOL_PATH, &dwLength);
+		m_lpszSymbolPath = new TCHAR[dwLength + 1];
+		ZeroMemory(m_lpszSymbolPath, sizeof(TCHAR) * (dwLength + 1));
+		StringCchCopy(m_lpszSymbolPath, dwLength, lpSymbolPath);
+	}
+
+}
+
+CStackWalker::~CStackWalker(void)
+{
+	if (NULL != m_lpszSymbolPath)
+	{
+		delete[] m_lpszSymbolPath;
+	}
+
+	if (m_bSymbolLoaded)
+	{
+		SymCleanup(m_hProcess);
+	}
+}
+
+BOOL CStackWalker::LoadSymbol()
+{
+	//USES_CONVERSION;
+	//只加载一次
+	if(m_bSymbolLoaded)
+	{
+		return m_bSymbolLoaded;
+	}
+
+	if (NULL != m_lpszSymbolPath)
+	{
+		
+		m_bSymbolLoaded = SymInitialize(m_hProcess, textconv_helper::T2A_(m_lpszSymbolPath), FALSE);
+		return m_bSymbolLoaded;
+	}
+	
+	//添加当前程序路径
+	TCHAR szSymbolPath[MAX_SYMBOL_PATH] = _T("");
+	StringCchCopy(szSymbolPath, MAX_SYMBOL_PATH, _T(".;"));
+
+	//添加程序所在目录
+	TCHAR szTemp[MAX_PATH] = _T("");
+	if (GetCurrentDirectory(MAX_PATH, szTemp) > 0)
+	{
+		StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
+		StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
+	}
+
+	//添加程序主模块所在路径
+	ZeroMemory(szTemp, MAX_PATH * sizeof(TCHAR));
+	if (GetModuleFileName(NULL, szTemp, MAX_PATH) > 0)
+	{
+		size_t sLength = 0;
+		StringCchLength(szTemp, MAX_PATH, &sLength);
+		for (int i = sLength; i >= 0; i--)
+		{
+			if (szTemp[i] == _T('\\') || szTemp[i] == _T('/') || szTemp[i] == _T(':'))
+			{
+				szTemp[i] = _T('\0');
+				break;
+			}
+		}
+	}
+
+	StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
+	StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
+	
+	ZeroMemory(szTemp, MAX_PATH * sizeof(TCHAR));
+	if (GetEnvironmentVariable(_T("_NT_SYMBOL_PATH"), szTemp, MAX_PATH) > 0)
+	{
+		StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
+		StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
+	}
+
+	ZeroMemory(szTemp, MAX_PATH * sizeof(TCHAR));
+	if (GetEnvironmentVariable(_T("_NT_ALTERNATE_SYMBOL_PATH"), szTemp, MAX_PATH) > 0)
+	{
+		StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
+		StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
+	}
+
+	ZeroMemory(szTemp, MAX_PATH * sizeof(TCHAR));
+	if (GetEnvironmentVariable(_T("SYSTEMROOT"), szTemp, MAX_PATH) > 0)
+	{
+		StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
+		StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
+		// also add the "system32"-directory:
+		StringCchCat(szTemp, MAX_PATH, _T("\\system32"));
+		StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
+		StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
+	}
+
+	ZeroMemory(szTemp, MAX_PATH * sizeof(TCHAR));
+	if (GetEnvironmentVariable(_T("SYSTEMDRIVE"), szTemp, MAX_PATH) > 0)
+	{
+			StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T("SRV*"));
+			StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
+			StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T("\\websymbols"));
+			StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T("*http://msdl.microsoft.com/download/symbols;"));
+	}
+	else
+	{
+		StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T("SRV*c:\\websymbols*http://msdl.microsoft.com/download/symbols;"));
+	}
+
+	size_t sLength = 0;
+	StringCchLength(szSymbolPath, MAX_SYMBOL_PATH, &sLength);
+	if (sLength > 0)
+	{
+		m_lpszSymbolPath = new TCHAR[sLength + 1];
+		ZeroMemory(m_lpszSymbolPath, sizeof(TCHAR) * (sLength + 1));
+		StringCchCopy(m_lpszSymbolPath, sLength, szSymbolPath);
+	}
+
+	if (NULL != m_lpszSymbolPath)
+	{
+		m_bSymbolLoaded = SymInitialize(m_hProcess, textconv_helper::T2A_(m_lpszSymbolPath), TRUE); //这里设置为TRUE，让它在初始化符号表的同时加载符号表
+	}
+
+	DWORD symOptions = SymGetOptions();
+	symOptions |= SYMOPT_LOAD_LINES;
+	symOptions |= SYMOPT_FAIL_CRITICAL_ERRORS;
+	symOptions |= SYMOPT_DEBUG;
+	SymSetOptions(symOptions);
+
+	return m_bSymbolLoaded;
+}
+
+LPMODULE_INFO CStackWalker::GetLoadModules()
+{
+	LPMODULE_INFO pHead = GetModulesTH32();
+	if (NULL == pHead)
+	{
+		pHead = GetModulesPSAPI();
+	}
+
+	return pHead;
+}
+
+void CStackWalker::FreeModuleInformations(LPMODULE_INFO pmi)
+{
+	LPMODULE_INFO head = pmi;
+	while (NULL != head)
+	{
+		pmi = pmi->pNext;
+		delete head;
+		head = pmi;
+	}
+}
+
+LPMODULE_INFO CStackWalker::GetModulesTH32()
+{
+	//这里为了防止加载Toolhelp.dll 影响最终结果，所以采用动态加载的方式
+	LPMODULE_INFO pHead = NULL;
+	LPMODULE_INFO pTail = pHead;
+
+	typedef HANDLE (WINAPI *pfnCreateToolhelp32Snapshot)(DWORD dwFlags, DWORD th32ProcessID);
+	typedef BOOL (WINAPI *pfnModule32First)(HANDLE hSnapshot, LPMODULEENTRY32 lpme );
+	typedef BOOL (WINAPI *pfnModule32Next)(HANDLE hSnapshot, LPMODULEENTRY32 lpme );
+
+	const TCHAR* dllname[] = {_T("kernel32.dll"), _T("tlhelp32.dll")};
+	HINSTANCE    hToolhelp = NULL;
+
+	pfnCreateToolhelp32Snapshot CreateToolhelp32Snapshot = NULL;
+	pfnModule32First Module32First = NULL;
+	pfnModule32Next Module32Next = NULL;
+
+	HANDLE        hSnap;
+	MODULEENTRY32 me;
+	me.dwSize = sizeof(me);
+	BOOL   keepGoing;
+	size_t i;
+
+	for (i = 0; i < (sizeof(dllname) / sizeof(dllname[0])); i++)
+	{
+		hToolhelp = LoadLibrary(dllname[i]);
+		if (hToolhelp == NULL)
+			continue;
+		CreateToolhelp32Snapshot = (pfnCreateToolhelp32Snapshot)GetProcAddress(hToolhelp, "CreateToolhelp32Snapshot");
+#ifdef UNICODE
+		Module32First = (pfnModule32First)GetProcAddress(hToolhelp, "Module32FirstW");
+		Module32Next = (pfnModule32Next)GetProcAddress(hToolhelp, "Module32NextW");
+#else
+		Module32First = (pfnModule32First)GetProcAddress(hToolhelp, "Module32FirstA");
+		Module32Next = (pfnModule32Next)GetProcAddress(hToolhelp, "Module32NextA");
+#endif
+
+		if ((CreateToolhelp32Snapshot != NULL) && (Module32First != NULL) && (Module32Next != NULL))
+			break;
+
+		FreeLibrary(hToolhelp);
+		hToolhelp = NULL;
+	}
+
+	if (hToolhelp == NULL)
+		return pHead;
+
+	hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, m_wPID);
+
+	if (hSnap == INVALID_HANDLE_VALUE)
+	{
+		FreeLibrary(hToolhelp);
+		return pHead;
+	}
+
+	keepGoing = Module32First(hSnap, &me);
+
+	while (keepGoing)
+	{
+		LPMODULE_INFO pmi = new MODULE_INFO;
+		ZeroMemory(pmi, sizeof(MODULE_INFO));
+
+		pmi->dwModSize = me.modBaseSize;
+		pmi->ModuleAddress = (DWORD64)me.modBaseAddr;
+		StringCchCopy(pmi->szModuleName, MAX_MODULE_NAME32, me.szModule);
+		StringCchCopy(pmi->szModulePath, MAX_PATH, me.szExePath);
+		GetModuleInformation(pmi);
+		if (pHead == NULL)
+		{
+			pHead = pmi;
+			pTail = pHead;
+		}else
+		{
+			pTail->pNext = pmi;
+			pTail = pmi;
+		}
+
+		keepGoing = Module32Next(hSnap, &me);
+	}
+
+	CloseHandle(hSnap);
+	FreeLibrary(hToolhelp);
+	return pHead;
+}
+
+LPMODULE_INFO CStackWalker::GetModulesPSAPI()
+{
+	LPMODULE_INFO pHead = NULL;
+	LPMODULE_INFO pTail = pHead;
+	typedef BOOL(WINAPI *pfnEnumProcessModules)(HANDLE hProcess, HMODULE * lphModule, DWORD cb,LPDWORD lpcbNeeded);
+	typedef DWORD(WINAPI *pfnGetModuleFileNameEx)(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize);
+	typedef DWORD(WINAPI *pfnGetModuleBaseName)(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize);
+	typedef BOOL(WINAPI *pfnGetModuleInformation)(HANDLE hProcess, HMODULE hModule, LPMODULEINFO pmi, DWORD nSize);
+
+	HINSTANCE hPsapi;
+	pfnEnumProcessModules EnumProcessModules = NULL;
+	pfnGetModuleFileNameEx GetModuleFileNameEx = NULL;
+	pfnGetModuleBaseName GetModuleBaseName = NULL;
+	pfnGetModuleInformation GetModuleInformation = NULL;
+
+	DWORD i;
+	//ModuleEntry e;
+	DWORD        cbNeeded;
+	MODULEINFO   mi;
+	HMODULE*     hMods = NULL;
+	TCHAR szModuleName[MAX_MODULE_NAME32 + 1] = _T("");
+	TCHAR szModulePath[MAX_PATH] = _T("");
+
+	hPsapi = LoadLibrary(_T("psapi.dll"));
+	if (hPsapi == NULL)
+	{
+		return pHead;
+	}
+
+	EnumProcessModules = (pfnEnumProcessModules)GetProcAddress(hPsapi, "EnumProcessModules");
+#ifdef UNICODE
+	GetModuleFileNameEx = (pfnGetModuleFileNameEx)GetProcAddress(hPsapi, "GetModuleFileNameExW");
+	GetModuleBaseName = (pfnGetModuleBaseName)GetProcAddress(hPsapi, "GetModuleBaseNameW");
+#else
+	GetModuleFileNameEx = (pfnGetModuleFileNameEx)GetProcAddress(hPsapi, "GetModuleFileNameExA");
+	GetModuleBaseName = (pfnGetModuleBaseName)GetProcAddress(hPsapi, "GetModuleBaseNameA");
+#endif
+	GetModuleInformation = (pfnGetModuleInformation)GetProcAddress(hPsapi, "GetModuleInformation");
+	if ((EnumProcessModules == NULL) || (GetModuleFileNameEx == NULL) || (GetModuleBaseName == NULL) || (GetModuleInformation == NULL))
+	{
+		FreeLibrary(hPsapi);
+		return pHead;
+	}
+	
+	EnumProcessModules(m_hProcess, hMods, 0, &cbNeeded);
+	hMods = new HMODULE[cbNeeded / sizeof(HMODULE)];
+	ASSERT(NULL != hMods);
+	ZeroMemory(hMods, cbNeeded);
+
+	if (!EnumProcessModules(m_hProcess, hMods, cbNeeded, &cbNeeded))
+	{
+		goto cleanup;
+	}
+
+	for (i = 0; i < cbNeeded / sizeof(HMODULE); i++)
+	{
+		GetModuleInformation(m_hProcess, hMods[i], &mi, sizeof(mi));
+		GetModuleFileNameEx(m_hProcess, hMods[i], szModulePath, MAX_PATH);
+		GetModuleBaseName(m_hProcess, hMods[i], szModuleName, MAX_MODULE_NAME32);
+		LPMODULE_INFO pmi = new MODULE_INFO;
+		ZeroMemory(pmi, sizeof(MODULE_INFO));
+		pmi->dwModSize = mi.SizeOfImage;
+		pmi->ModuleAddress = (DWORD64)mi.lpBaseOfDll;
+		StringCchCopy(pmi->szModuleName, MAX_MODULE_NAME32, szModuleName);
+		StringCchCopy(pmi->szModulePath, MAX_PATH, szModulePath);
+		this->GetModuleInformation(pmi);
+		if (pHead == NULL)
+		{
+			pHead = pmi;
+			pTail = pHead;
+		}else
+		{
+			pTail->pNext = pmi;
+			pTail = pmi;
+		}
+	}
+
+cleanup:
+	if (hPsapi != NULL)
+	{
+		FreeLibrary(hPsapi);
+	}
+	if (hMods != NULL)
+	{
+		delete[] hMods;
+	}
+
+	return pHead;
+}
+
+void CStackWalker::OutputString(LPCTSTR lpszFormat, ...)
+{
+	TCHAR szBuf[1024] = _T("");
+	va_list args;
+	va_start(args, lpszFormat);
+	_vsntprintf_s(szBuf, 1024, lpszFormat, args);
+	va_end(args);
+
+	OutputDebugString(szBuf);
+}
+
+void CStackWalker::GetModuleInformation(LPMODULE_INFO pmi)
+{
+	//USES_CONVERSION;
+	IMAGEHLP_MODULE64  im = {0};
+	im.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
+
+	VS_FIXEDFILEINFO* pvfi = NULL;
+	DWORD dwHandle = 0;
+	DWORD dwInfoSize = 0;
+	dwInfoSize = GetFileVersionInfoSize(pmi->szModulePath, &dwHandle);
+
+	if (dwInfoSize > 0)
+	{
+		LPVOID lpData = new byte[dwInfoSize];
+		ZeroMemory(lpData, dwInfoSize * sizeof(byte));
+
+		if (GetFileVersionInfo(pmi->szModulePath, dwHandle, dwInfoSize, lpData) > 0 )
+		{
+			TCHAR szBlock[] = _T("\\");
+			UINT  len;
+			if (VerQueryValue(lpData, szBlock, (LPVOID*)&pvfi, &len))
+			{
+				WORD v1 = HIWORD(pvfi->dwFileVersionMS);
+				WORD v2 = LOWORD(pvfi->dwFileVersionMS);
+				WORD v3 = HIWORD(pvfi->dwFileVersionLS);
+				WORD v4 = LOWORD(pvfi->dwFileVersionLS);
+ 				_stprintf_s(pmi->szVersion, MAX_VERSION_LENGTH, _T("%d.%d.%d.%d"), v1, v2, v3, v4);
+			}
+		}
+
+		delete[] lpData;
+	}
+
+	SymGetModuleInfo64(m_hProcess, pmi->ModuleAddress, &im);
+	StringCchCopy(pmi->szSymbolPath, MAX_PATH, textconv_helper::A2T_(im.LoadedPdbName));
+}
+
+LPSTACKINFO CStackWalker::StackWalker(HANDLE hThread, const CONTEXT* context)
+{
+	//USES_CONVERSION;
+	//加载符号表
+	LoadSymbol();
+
+	LPSTACKINFO pHead = NULL;
+	LPSTACKINFO pTail = pHead;
+
+	//获取当前线程的上下文环境
+	CONTEXT c = {0};
+	if (context == NULL)
+	{
+#if _WIN32_WINNT <= 0x0501
+		if (hThread == GetCurrentThread())
+#else
+		if (GetThreadId(hThread) == GetCurrentThreadId())
+#endif
+		{
+			GET_CURRENT_THREAD_CONTEXT(c, CONTEXT_FULL);
+		}
+		else
+		{
+			//如果不是当前线程，需要停止目标线程，以便取出正确的堆栈信息
+			SuspendThread(hThread);
+			memset(&c, 0, sizeof(CONTEXT));
+			c.ContextFlags = CONTEXT_FULL;
+			if (GetThreadContext(hThread, &c) == FALSE)
+			{
+				ResumeThread(hThread);
+				return NULL;
+			}
+		}
+	}
+	else
+		c = *context;
+
+	STACKFRAME64 sf = {0};
+	DWORD imageType;
+
+//intel X86
+#ifdef _M_IX86
+	imageType = IMAGE_FILE_MACHINE_I386;
+	sf.AddrPC.Offset = c.Eip;
+	sf.AddrPC.Mode = AddrModeFlat;
+	sf.AddrFrame.Offset = c.Ebp;
+	sf.AddrFrame.Mode = AddrModeFlat;
+	sf.AddrStack.Offset = c.Esp;
+	sf.AddrStack.Mode = AddrModeFlat;
+	// AMD
+#elif _M_X64
+	imageType = IMAGE_FILE_MACHINE_AMD64;
+	sf.AddrPC.Offset = c.Rip;
+	sf.AddrPC.Mode = AddrModeFlat;
+	sf.AddrFrame.Offset = c.Rsp;
+	sf.AddrFrame.Mode = AddrModeFlat;
+	sf.AddrStack.Offset = c.Rsp;
+	sf.AddrStack.Mode = AddrModeFlat;
+	////intel Itanium(安腾)
+#elif _M_IA64
+	imageType = IMAGE_FILE_MACHINE_IA64;
+	sf.AddrPC.Offset = c.StIIP;
+	sf.AddrPC.Mode = AddrModeFlat;
+	sf.AddrFrame.Offset = c.IntSp;
+	sf.AddrFrame.Mode = AddrModeFlat;
+	sf.AddrBStore.Offset = c.RsBSP;
+	sf.AddrBStore.Mode = AddrModeFlat;
+	sf.AddrStack.Offset = c.IntSp;
+	sf.AddrStack.Mode = AddrModeFlat;
+#else
+#error "Platform not supported!"
+#endif
+
+	
+	DWORD64 dwDisplayment = 0;
+	PIMAGEHLP_SYMBOL64 pSym = (PIMAGEHLP_SYMBOL64)new BYTE[sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN];
+	PIMAGEHLP_LINE64 pLine = new IMAGEHLP_LINE64;
+	while (StackWalk64(imageType, m_hProcess, hThread, &sf, &c, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL))
+	{
+		ZeroMemory(pSym, sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN);
+		ZeroMemory(pLine, sizeof(IMAGEHLP_LINE64));
+
+		pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
+		pSym->MaxNameLength = STACKWALK_MAX_NAMELEN;
+		pLine->SizeOfStruct = sizeof(IMAGEHLP_LINE64);
+
+		LPSTACKINFO pCallStack = new STACKINFO;
+		ZeroMemory(pCallStack, sizeof(STACKINFO));
+		pCallStack->szFncAddr = sf.AddrPC.Offset;
+		if (sf.AddrPC.Offset != 0)
+		{
+			if(SymGetSymFromAddr64(m_hProcess, sf.AddrPC.Offset, &dwDisplayment, pSym))
+			{
+				char szName[STACKWALK_MAX_NAMELEN] = "";
+				StringCchCopy(pCallStack->szFncName, STACKWALK_MAX_NAMELEN, textconv_helper::A2T_(pSym->Name));
+				UnDecorateSymbolName(pSym->Name, szName, STACKWALK_MAX_NAMELEN, UNDNAME_COMPLETE);
+				StringCchCopy(pCallStack->undFullName, STACKWALK_MAX_NAMELEN, textconv_helper::A2T_(szName));
+				ZeroMemory(szName, STACKWALK_MAX_NAMELEN * sizeof(char));
+				UnDecorateSymbolName(pSym->Name, szName, STACKWALK_MAX_NAMELEN, UNDNAME_NAME_ONLY);
+				StringCchCopy(pCallStack->undName, STACKWALK_MAX_NAMELEN, textconv_helper::A2T_(szName));
+			}else
+			{
+				//调用错误一般是487(地址无效或者没有访问的权限、在符号表中未找到指定地址的相关信息)
+				this->OutputString(_T("Call SymGetSymFromAddr64 ,Address %08x Error:%08x\r\n"), sf.AddrPC.Offset, GetLastError());
+				continue;
+			}
+
+			if (SymGetLineFromAddr64(m_hProcess, sf.AddrPC.Offset, (DWORD*)&dwDisplayment, pLine))
+			{
+				StringCchCopy(pCallStack->szFileName, MAX_PATH, textconv_helper::A2T_(pLine->FileName));
+				pCallStack->uFileNum = pLine->LineNumber;
+			}else
+			{
+				this->OutputString(_T("Call SymGetLineFromAddr64 ,Address %08x Error:%08x\r\n"), sf.AddrPC.Offset, GetLastError());
+				continue;
+			}
+			
+			//这里为了将获取函数信息失败的情况与正常的情况一起输出，防止用户在查看时出现误解
+			this->OutputString(_T("%08llx:%s [%s][%ld]\r\n"), pCallStack->szFncAddr, pCallStack->undFullName, pCallStack->szFileName, pCallStack->uFileNum);
+			if (NULL == pHead)
+			{
+				pHead = pCallStack;
+				pTail = pHead;
+			}else
+			{
+				pTail->pNext = pCallStack;
+				pTail = pCallStack;
+			}
+		}
+	}
+
+	delete[] pSym;
+	delete pLine;
+
+	return pHead;
+}
+
+void CStackWalker::FreeStackInformations(LPSTACKINFO psi)
+{
+	LPSTACKINFO head = psi;
+	while (NULL != head)
+	{
+		psi = psi->pNext;
+		delete head;
+		head = psi;
+	}
+
+}

src/StackWalker.h

@@ -0,0 +1,284 @@
+#pragma once
+#include <Windows.h>
+#include <tchar.h>
+#include <vector>
+
+namespace textconv_helper
+{
+	// Forward declarations of our classes. They are defined later.
+	class CA2A_;
+	class CA2W_;
+	class CW2A_;
+	class CW2W_;
+	class CA2BSTR_;
+	class CW2BSTR_;
+
+	// typedefs for the well known text conversions
+	typedef CA2W_ A2W_;
+	typedef CW2A_ W2A_;
+	//typedef CW2BSTR_ W2BSTR_;
+	//typedef CA2BSTR_ A2BSTR_;
+	typedef CW2A_ BSTR2A_;
+	typedef CW2W_ BSTR2W_;
+
+#ifdef _UNICODE
+	typedef CA2W_ A2T_;
+	typedef CW2A_ T2A_;
+	typedef CW2W_ T2W_;
+	typedef CW2W_ W2T_;
+	//typedef CW2BSTR_ T2BSTR_;
+	//typedef BSTR2W_ BSTR2T_;
+#else
+	typedef CA2A_ A2T_;
+	typedef CA2A_ T2A_;
+	typedef CA2W_ T2W_;
+	typedef CW2A_ W2T_;
+	typedef CA2BSTR_ T2BSTR_;
+	typedef BSTR2A_ BSTR2T_;
+#endif
+
+	typedef A2W_  A2OLE_;
+	typedef T2W_  T2OLE_;
+	typedef CW2W_ W2OLE_;
+	typedef W2A_  OLE2A_;
+	typedef W2T_  OLE2T_;
+	typedef CW2W_ OLE2W_;
+
+	class CA2W_
+	{
+	public:
+		CA2W_(LPCSTR pStr, UINT codePage = CP_ACP) : m_pStr(pStr)
+		{
+			if (pStr)
+			{
+				// Resize the vector and assign null WCHAR to each element
+				int length = MultiByteToWideChar(codePage, 0, pStr, -1, NULL, 0) + 1;
+				m_vWideArray.assign(length, L'\0');
+
+				// Fill our vector with the converted WCHAR array
+				MultiByteToWideChar(codePage, 0, pStr, -1, &m_vWideArray[0], length);
+			}
+		}
+		~CA2W_() {}
+		operator LPCWSTR() { return m_pStr ? &m_vWideArray[0] : NULL; }
+		//operator LPOLESTR() { return m_pStr ? (LPOLESTR)&m_vWideArray[0] : (LPOLESTR)NULL; }
+
+	private:
+		CA2W_(const CA2W_&);
+		CA2W_& operator= (const CA2W_&);
+		std::vector<wchar_t> m_vWideArray;
+		LPCSTR m_pStr;
+	};
+
+	class CW2A_
+	{
+	public:
+		CW2A_(LPCWSTR pWStr, UINT codePage = CP_ACP) : m_pWStr(pWStr)
+			// Usage:
+			//   CW2A_ ansiString(L"Some Text");
+			//   CW2A_ utf8String(L"Some Text", CP_UTF8);
+			//
+			// or
+			//   SetWindowTextA( W2A(L"Some Text") ); The ANSI version of SetWindowText
+		{
+			// Resize the vector and assign null char to each element
+			int length = WideCharToMultiByte(codePage, 0, pWStr, -1, NULL, 0, NULL, NULL) + 1;
+			m_vAnsiArray.assign(length, '\0');
+
+			// Fill our vector with the converted char array
+			WideCharToMultiByte(codePage, 0, pWStr, -1, &m_vAnsiArray[0], length, NULL, NULL);
+		}
+
+		~CW2A_()
+		{
+			m_pWStr = 0;
+		}
+		operator LPCSTR() { return m_pWStr ? &m_vAnsiArray[0] : NULL; }
+
+	private:
+		CW2A_(const CW2A_&);
+		CW2A_& operator= (const CW2A_&);
+		std::vector<char> m_vAnsiArray;
+		LPCWSTR m_pWStr;
+	};
+
+	class CW2W_
+	{
+	public:
+		CW2W_(LPCWSTR pWStr) : m_pWStr(pWStr) {}
+		operator LPCWSTR() { return const_cast<LPWSTR>(m_pWStr); }
+		//operator LPOLESTR() { return const_cast<LPOLESTR>(m_pWStr); }
+
+	private:
+		CW2W_(const CW2W_&);
+		CW2W_& operator= (const CW2W_&);
+
+		LPCWSTR m_pWStr;
+	};
+
+	class CA2A_
+	{
+	public:
+		CA2A_(LPCSTR pStr) : m_pStr(pStr) {}
+		operator LPCSTR() { return (LPSTR)m_pStr; }
+
+	private:
+		CA2A_(const CA2A_&);
+		CA2A_& operator= (const CA2A_&);
+
+		LPCSTR m_pStr;
+	};
+
+	/*class CW2BSTR_
+	{
+	public:
+		CW2BSTR_(LPCWSTR pWStr) { m_bstrString = ::SysAllocString(pWStr); }
+		~CW2BSTR_() { ::SysFreeString(m_bstrString); }
+		operator BSTR() { return m_bstrString; }
+
+	private:
+		CW2BSTR_(const CW2BSTR_&);
+		CW2BSTR_& operator= (const CW2BSTR_&);
+		BSTR m_bstrString;
+	};
+
+	class CA2BSTR_
+	{
+	public:
+		CA2BSTR_(LPCSTR pStr) { m_bstrString = ::SysAllocString(textconv_helper::CA2W_(pStr)); }
+		~CA2BSTR_() { ::SysFreeString(m_bstrString); }
+		operator BSTR() { return m_bstrString; }
+
+	private:
+		CA2BSTR_(const CA2BSTR_&);
+		CA2BSTR_& operator= (const CA2BSTR_&);
+		BSTR m_bstrString;
+	};*/
+}
+
+#define MAX_SYMBOL_PATH 1024
+#define MAX_MODULE_NAME32 255
+#define TH32CS_SNAPMODULE 0x00000008
+#define MAX_VERSION_LENGTH 512
+#define STACKWALK_MAX_NAMELEN 1024
+
+#define ASSERT(judge)\
+	{\
+		if(!(judge))\
+		{\
+			DebugBreak();\
+		}\
+	}
+
+typedef struct tagMODULEENTRY32
+{
+	DWORD   dwSize;
+	DWORD   th32ModuleID;  // This module
+	DWORD   th32ProcessID; // owning process
+	DWORD   GlblcntUsage;  // Global usage count on the module
+	DWORD   ProccntUsage;  // Module usage count in th32ProcessID's context
+	BYTE*   modBaseAddr;   // Base address of module in th32ProcessID's context
+	DWORD   modBaseSize;   // Size in bytes of module starting at modBaseAddr
+	HMODULE hModule;       // The hModule of this module in th32ProcessID's context
+	TCHAR   szModule[MAX_MODULE_NAME32 + 1];
+	TCHAR   szExePath[MAX_PATH];
+} MODULEENTRY32;
+
+typedef struct _MODULEINFO
+{
+	LPVOID lpBaseOfDll;
+	DWORD  SizeOfImage;
+	LPVOID EntryPoint;
+} MODULEINFO, *LPMODULEINFO;
+
+typedef MODULEENTRY32* PMODULEENTRY32;
+typedef MODULEENTRY32* LPMODULEENTRY32;
+
+typedef struct _tag_MODULE_INFO 
+{
+	DWORD64 ModuleAddress;
+	DWORD dwModSize;
+	TCHAR szModuleName[MAX_MODULE_NAME32 + 1];
+	TCHAR szModulePath[MAX_PATH];
+	TCHAR szSymbolPath[MAX_PATH];
+	TCHAR szVersion[MAX_VERSION_LENGTH];
+	struct _tag_MODULE_INFO* pNext;
+}MODULE_INFO, *LPMODULE_INFO;
+
+typedef struct tagSTACKINFO
+{
+	DWORD64 szFncAddr;
+	TCHAR szFileName[MAX_PATH];
+	TCHAR szFncName[MAX_PATH];
+	unsigned long uFileNum;
+	TCHAR    undName[STACKWALK_MAX_NAMELEN];
+	TCHAR    undFullName[STACKWALK_MAX_NAMELEN];
+	tagSTACKINFO *pNext;
+}STACKINFO, *LPSTACKINFO;
+
+class CStackWalker
+{
+public:
+	CStackWalker(HANDLE hProcess = GetCurrentProcess(), WORD wPID = GetCurrentProcessId(), LPCTSTR lpSymbolPath = NULL);
+	~CStackWalker(void);
+	BOOL LoadSymbol();
+	LPMODULE_INFO GetLoadModules();
+	void GetModuleInformation(LPMODULE_INFO pmi);
+
+	void FreeModuleInformations(LPMODULE_INFO pmi);
+	virtual void OutputString(LPCTSTR lpszFormat, ...);
+
+	LPSTACKINFO StackWalker(HANDLE hThread = GetCurrentThread(), const CONTEXT* context = NULL);
+	void FreeStackInformations(LPSTACKINFO psi);
+
+protected:
+	LPMODULE_INFO GetModulesTH32();
+	LPMODULE_INFO GetModulesPSAPI();
+protected:
+	HANDLE m_hProcess;
+	WORD m_wPID;
+	LPTSTR m_lpszSymbolPath;
+	BOOL m_bSymbolLoaded;
+};
+
+#if defined(_M_IX86)
+#ifdef CURRENT_THREAD_VIA_EXCEPTION
+#define GET_CURRENT_THREAD_CONTEXT(c, contextFlags)\
+do\
+{\
+	memset(&c, 0, sizeof(CONTEXT));\
+	EXCEPTION_POINTERS* pExp = NULL;\
+	__try\
+	{\
+		throw 0;\
+	}\
+	__except (((pExp = GetExceptionInformation()) ? EXCEPTION_EXECUTE_HANDLER:EXCEPTION_EXECUTE_HANDLER))\
+	{\
+	}\
+	if (pExp != NULL)\
+		memcpy(&c, pExp->ContextRecord, sizeof(CONTEXT));\
+	c.ContextFlags = contextFlags;\
+} while (0);
+#else
+#define GET_CURRENT_THREAD_CONTEXT(c, contextFlags) \
+	do\
+	{\
+		memset(&c, 0, sizeof(CONTEXT));\
+		c.ContextFlags = contextFlags;\
+		__asm    call $+5\
+		__asm    pop eax\
+		__asm    mov c.Eip, eax\
+		__asm    mov c.Ebp, ebp\
+		__asm    mov c.Esp, esp\
+} while (0)
+#endif
+
+#else
+#define GET_CURRENT_THREAD_CONTEXT(c, contextFlags) \
+	do\
+	{ \
+		memset(&c, 0, sizeof(CONTEXT));\
+		c.ContextFlags = contextFlags;\
+		RtlCaptureContext(&c);\
+} while (0);
+#endif

src/admesh/CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 2.8.12)
+project(admesh)
+
+add_library(admesh STATIC
+    connect.cpp
+    normals.cpp
+    shared.cpp
+    stl.h
+    stl_io.cpp
+    stlinit.cpp
+    util.cpp
+)
+
+target_link_libraries(admesh PRIVATE boost_headeronly)

src/admesh/connect.cpp

@@ -0,0 +1,743 @@
+/*  ADMesh -- process triangulated solid meshes
+ *  Copyright (C) 1995, 1996  Anthony D. Martin <amartin@engr.csulb.edu>
+ *  Copyright (C) 2013, 2014  several contributors, see AUTHORS
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Questions, comments, suggestions, etc to
+ *           https://github.com/admesh/admesh/issues
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include <algorithm>
+#include <vector>
+
+#include <boost/predef/other/endian.h>
+#include <boost/log/trivial.hpp>
+// Boost pool: Don't use mutexes to synchronize memory allocation.
+#define BOOST_POOL_NO_MT
+#include <boost/pool/object_pool.hpp>
+
+#include "stl.h"
+
+struct HashEdge {
+	// Key of a hash edge: sorted vertices of the edge.
+	uint32_t       key[6];
+	// Compare two keys.
+	bool operator==(const HashEdge &rhs) const { return memcmp(key, rhs.key, sizeof(key)) == 0; }
+	bool operator!=(const HashEdge &rhs) const { return ! (*this == rhs); }
+	int  hash(int M) const { return ((key[0] / 11 + key[1] / 7 + key[2] / 3) ^ (key[3] / 11  + key[4] / 7 + key[5] / 3)) % M; }
+
+	// Index of a facet owning this edge.
+	int        facet_number;
+	// Index of this edge inside the facet with an index of facet_number.
+	// If this edge is stored backwards, which_edge is increased by 3.
+	int        which_edge;
+	HashEdge  *next;
+
+	void load_exact(stl_file *stl, const stl_vertex *a, const stl_vertex *b)
+	{
+		{
+	    	stl_vertex diff = (*a - *b).cwiseAbs();
+	    	float max_diff = std::max(diff(0), std::max(diff(1), diff(2)));
+	    	stl->stats.shortest_edge = std::min(max_diff, stl->stats.shortest_edge);
+	  	}
+
+	  	// Ensure identical vertex ordering of equal edges.
+	  	// This method is numerically robust.
+	  	if (vertex_lower(*a, *b)) {
+	  	} else {
+	  		// This edge is loaded backwards.
+		    std::swap(a, b);
+		    this->which_edge += 3;
+	  	}
+	  	memcpy(&this->key[0], a->data(), sizeof(stl_vertex));
+	  	memcpy(&this->key[3], b->data(), sizeof(stl_vertex));
+	  	// Switch negative zeros to positive zeros, so memcmp will consider them to be equal.
+	  	for (size_t i = 0; i < 6; ++ i) {
+	    	unsigned char *p = (unsigned char*)(this->key + i);
+	#if BOOST_ENDIAN_LITTLE_BYTE
+	    	if (p[0] == 0 && p[1] == 0 && p[2] == 0 && p[3] == 0x80)
+	      		// Negative zero, switch to positive zero.
+	      		p[3] = 0;
+	#else /* BOOST_ENDIAN_LITTLE_BYTE */
+	    	if (p[0] == 0x80 && p[1] == 0 && p[2] == 0 && p[3] == 0)
+	      		// Negative zero, switch to positive zero.
+	      		p[0] = 0;
+	#endif /* BOOST_ENDIAN_LITTLE_BYTE */
+	  	}
+	}
+
+	bool load_nearby(const stl_file *stl, const stl_vertex &a, const stl_vertex &b, float tolerance)
+	{
+		// Index of a grid cell spaced by tolerance.
+		typedef Eigen::Matrix<int32_t,  3, 1, Eigen::DontAlign> Vec3i;
+		Vec3i vertex1 = ((a - stl->stats.min) / tolerance).cast<int32_t>();
+		Vec3i vertex2 = ((b - stl->stats.min) / tolerance).cast<int32_t>();
+		static_assert(sizeof(Vec3i) == 12, "size of Vec3i incorrect");
+
+		if (vertex1 == vertex2)
+			// Both vertices hash to the same value
+			return false;
+
+		// Ensure identical vertex ordering of edges, which vertices land into equal grid cells.
+		// This method is numerically robust.
+		if ((vertex1[0] != vertex2[0]) ? 
+		    (vertex1[0] < vertex2[0]) : 
+		    ((vertex1[1] != vertex2[1]) ? 
+		        (vertex1[1] < vertex2[1]) : 
+		        (vertex1[2] < vertex2[2]))) {
+			memcpy(&this->key[0], vertex1.data(), sizeof(stl_vertex));
+			memcpy(&this->key[3], vertex2.data(), sizeof(stl_vertex));
+		} else {
+			memcpy(&this->key[0], vertex2.data(), sizeof(stl_vertex));
+			memcpy(&this->key[3], vertex1.data(), sizeof(stl_vertex));
+			this->which_edge += 3; /* this edge is loaded backwards */
+		}
+		return true;
+	}
+
+private:
+	inline bool vertex_lower(const stl_vertex &a, const stl_vertex &b) {
+	  	return (a(0) != b(0)) ? (a(0) < b(0)) :
+	           ((a(1) != b(1)) ? (a(1) < b(1)) : (a(2) < b(2)));
+	}
+};
+
+struct HashTableEdges {
+	HashTableEdges(size_t number_of_faces) {
+		this->M = (int)hash_size_from_nr_faces(number_of_faces);
+		this->heads.assign(this->M, nullptr);
+		this->tail = pool.construct();
+		this->tail->next = this->tail;
+		for (int i = 0; i < this->M; ++ i)
+			this->heads[i] = this->tail;
+	}
+	~HashTableEdges() {
+#ifndef NDEBUG
+		for (int i = 0; i < this->M; ++ i)
+	    	for (HashEdge *temp = this->heads[i]; temp != this->tail; temp = temp->next)
+	        	++ this->freed;
+		this->tail = nullptr;
+#endif /* NDEBUG */
+	}
+
+	void insert_edge_exact(stl_file *stl, const HashEdge &edge)
+	{
+		this->insert_edge(stl, edge, [stl](const HashEdge& edge1, const HashEdge& edge2) { record_neighbors(stl, edge1, edge2); });
+	}
+
+	void insert_edge_nearby(stl_file *stl, const HashEdge &edge)
+	{
+		this->insert_edge(stl, edge, [stl](const HashEdge& edge1, const HashEdge& edge2) { match_neighbors_nearby(stl, edge1, edge2); });
+	}
+
+	// Hash table on edges
+	std::vector<HashEdge*> 	heads;
+	HashEdge* 				tail;
+	int           			M;
+	boost::object_pool<HashEdge> pool;
+
+#ifndef NDEBUG
+	size_t 					malloced   	= 0;
+	size_t 					freed 	  	= 0;
+	size_t 					collisions 	= 0;
+#endif /* NDEBUG */
+
+private:
+	static inline size_t hash_size_from_nr_faces(const size_t nr_faces)
+	{
+		// Good primes for addressing a cca. 30 bit space.
+		// https://planetmath.org/goodhashtableprimes
+		static std::vector<uint32_t> primes{ 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469, 12582917, 25165843, 50331653, 100663319, 201326611, 402653189, 805306457, 1610612741 };
+		// Find a prime number for 50% filling of the shared triangle edges in the mesh.
+		auto it = std::upper_bound(primes.begin(), primes.end(), nr_faces * 3 * 2 - 1);
+		return (it == primes.end()) ? primes.back() : *it;
+	}
+
+
+	// MatchNeighbors(stl_file *stl, const HashEdge &edge_a, const HashEdge &edge_b)
+	template<typename MatchNeighbors>
+	void insert_edge(stl_file *stl, const HashEdge &edge, MatchNeighbors match_neighbors)
+	{
+		int       chain_number = edge.hash(this->M);
+		HashEdge *link         = this->heads[chain_number];
+		if (link == this->tail) {
+			// This list doesn't have any edges currently in it.  Add this one.
+			HashEdge *new_edge = pool.construct(edge);
+#ifndef NDEBUG
+			++ this->malloced;
+#endif /* NDEBUG */
+			new_edge->next = this->tail;
+			this->heads[chain_number] = new_edge;
+		} else if (edges_equal(edge, *link)) {
+			// This is a match.  Record result in neighbors list.
+			match_neighbors(edge, *link);
+			// Delete the matched edge from the list.
+			this->heads[chain_number] = link->next;
+			// pool.destroy(link);
+#ifndef NDEBUG
+			++ this->freed;
+#endif /* NDEBUG */
+		} else {
+			// Continue through the rest of the list.
+			for (;;) {
+				if (link->next == this->tail) {
+					// This is the last item in the list. Insert a new edge.
+					HashEdge *new_edge = pool.construct();
+#ifndef NDEBUG
+					++ this->malloced;
+#endif /* NDEBUG */
+					*new_edge = edge;
+					new_edge->next = this->tail;
+					link->next = new_edge;
+#ifndef NDEBUG
+					++ this->collisions;
+#endif /* NDEBUG */
+					break;
+				}
+				if (edges_equal(edge, *link->next)) {
+					// This is a match.  Record result in neighbors list.
+					match_neighbors(edge, *link->next);
+					// Delete the matched edge from the list.
+					HashEdge *temp = link->next;
+					link->next = link->next->next;
+					// pool.destroy(temp);
+#ifndef NDEBUG
+					++ this->freed;
+#endif /* NDEBUG */
+					break;
+				}
+				// This is not a match.  Go to the next link.
+				link = link->next;
+#ifndef NDEBUG
+				++ this->collisions;
+#endif /* NDEBUG */
+			}
+		}
+	}
+
+	// Edges equal for hashing. Edgesof different facet are allowed to be matched.
+	static inline bool edges_equal(const HashEdge &edge_a, const HashEdge &edge_b)
+	{
+	    return edge_a.facet_number != edge_b.facet_number && edge_a == edge_b;
+	}
+
+	// Connect edge_a with edge_b, update edge connection statistics.
+	static void record_neighbors(stl_file *stl, const HashEdge &edge_a, const HashEdge &edge_b)
+	{
+		// Facet a's neighbor is facet b
+		stl->neighbors_start[edge_a.facet_number].neighbor[edge_a.which_edge % 3] = edge_b.facet_number;	/* sets the .neighbor part */
+		stl->neighbors_start[edge_a.facet_number].which_vertex_not[edge_a.which_edge % 3] = (edge_b.which_edge + 2) % 3; /* sets the .which_vertex_not part */
+
+		// Facet b's neighbor is facet a
+		stl->neighbors_start[edge_b.facet_number].neighbor[edge_b.which_edge % 3] = edge_a.facet_number;	/* sets the .neighbor part */
+		stl->neighbors_start[edge_b.facet_number].which_vertex_not[edge_b.which_edge % 3] = (edge_a.which_edge + 2) % 3; /* sets the .which_vertex_not part */
+
+		if ((edge_a.which_edge < 3 && edge_b.which_edge < 3) || (edge_a.which_edge > 2 && edge_b.which_edge > 2)) {
+			// These facets are oriented in opposite directions, their normals are probably messed up.
+			stl->neighbors_start[edge_a.facet_number].which_vertex_not[edge_a.which_edge % 3] += 3;
+			stl->neighbors_start[edge_b.facet_number].which_vertex_not[edge_b.which_edge % 3] += 3;
+		}
+
+		// Count successful connects:
+		// Total connects:
+		stl->stats.connected_edges += 2;
+		// Count individual connects:
+		switch (stl->neighbors_start[edge_a.facet_number].num_neighbors()) {
+		case 1:	++ stl->stats.connected_facets_1_edge; break;
+		case 2: ++ stl->stats.connected_facets_2_edge; break;
+		case 3: ++ stl->stats.connected_facets_3_edge; break;
+		default: assert(false);
+		}
+		switch (stl->neighbors_start[edge_b.facet_number].num_neighbors()) {
+		case 1:	++ stl->stats.connected_facets_1_edge; break;
+		case 2: ++ stl->stats.connected_facets_2_edge; break;
+		case 3: ++ stl->stats.connected_facets_3_edge; break;
+		default: assert(false);
+		}
+	}
+
+	static void match_neighbors_nearby(stl_file *stl, const HashEdge &edge_a, const HashEdge &edge_b)
+	{
+		record_neighbors(stl, edge_a, edge_b);
+
+		// Which vertices to change
+		int facet1 = -1;
+		int facet2 = -1;
+		int vertex1, vertex2;
+		stl_vertex new_vertex1, new_vertex2;
+		{
+			int v1a; // pair 1, facet a
+			int v1b; // pair 1, facet b
+			int v2a; // pair 2, facet a
+			int v2b; // pair 2, facet b
+			// Find first pair.
+			if (edge_a.which_edge < 3) {
+				v1a = edge_a.which_edge;
+				v2a = (edge_a.which_edge + 1) % 3;
+			} else {
+				v2a = edge_a.which_edge % 3;
+				v1a = (edge_a.which_edge + 1) % 3;
+			}
+			if (edge_b.which_edge < 3) {
+				v1b = edge_b.which_edge;
+				v2b = (edge_b.which_edge + 1) % 3;
+			} else {
+				v2b = edge_b.which_edge % 3;
+				v1b = (edge_b.which_edge + 1) % 3;
+			}
+
+			// Of the first pair, which vertex, if any, should be changed
+			if (stl->facet_start[edge_a.facet_number].vertex[v1a] != stl->facet_start[edge_b.facet_number].vertex[v1b]) {
+				// These facets are different.
+				if (   (stl->neighbors_start[edge_a.facet_number].neighbor[v1a] == -1)
+			        && (stl->neighbors_start[edge_a.facet_number].neighbor[(v1a + 2) % 3] == -1)) {
+			  		// This vertex has no neighbors.  This is a good one to change.
+			  		facet1 = edge_a.facet_number;
+			  		vertex1 = v1a;
+			  		new_vertex1 = stl->facet_start[edge_b.facet_number].vertex[v1b];
+				} else {
+				  	facet1 = edge_b.facet_number;
+			  		vertex1 = v1b;
+			  		new_vertex1 = stl->facet_start[edge_a.facet_number].vertex[v1a];
+				}
+			}
+
+			// Of the second pair, which vertex, if any, should be changed.
+			if (stl->facet_start[edge_a.facet_number].vertex[v2a] != stl->facet_start[edge_b.facet_number].vertex[v2b]) {
+				// These facets are different.
+				if (  (stl->neighbors_start[edge_a.facet_number].neighbor[v2a] == -1)
+			       && (stl->neighbors_start[edge_a.facet_number].neighbor[(v2a + 2) % 3] == -1)) {
+			  		// This vertex has no neighbors.  This is a good one to change.
+			  		facet2 = edge_a.facet_number;
+			  		vertex2 = v2a;
+			  		new_vertex2 = stl->facet_start[edge_b.facet_number].vertex[v2b];
+				} else {
+			  		facet2 = edge_b.facet_number;
+			  		vertex2 = v2b;
+			  		new_vertex2 = stl->facet_start[edge_a.facet_number].vertex[v2a];
+				}
+			}
+		}
+
+		auto change_vertices = [stl](int facet_num, int vnot, stl_vertex new_vertex)
+		{
+			int first_facet = facet_num;
+			bool direction = false;
+
+			for (;;) {
+				int pivot_vertex;
+				int next_edge;
+				if (vnot > 2) {
+					if (direction) {
+						pivot_vertex = (vnot + 1) % 3;
+						next_edge = vnot % 3;
+					}
+					else {
+						pivot_vertex = (vnot + 2) % 3;
+						next_edge = pivot_vertex;
+					}
+					direction = !direction;
+				}
+				else {
+					if (direction) {
+						pivot_vertex = (vnot + 2) % 3;
+						next_edge = pivot_vertex;
+					}
+					else {
+						pivot_vertex = (vnot + 1) % 3;
+						next_edge = vnot;
+					}
+				}
+	#if 0
+				if (stl->facet_start[facet_num].vertex[pivot_vertex](0) == new_vertex(0) &&
+					stl->facet_start[facet_num].vertex[pivot_vertex](1) == new_vertex(1) &&
+					stl->facet_start[facet_num].vertex[pivot_vertex](2) == new_vertex(2))
+					printf("Changing vertex %f,%f,%f: Same !!!\r\n", new_vertex(0), new_vertex(1), new_vertex(2));
+				else {
+					if (stl->facet_start[facet_num].vertex[pivot_vertex](0) != new_vertex(0))
+						printf("Changing coordinate x, vertex %e (0x%08x) to %e(0x%08x)\r\n",
+							stl->facet_start[facet_num].vertex[pivot_vertex](0),
+							*reinterpret_cast<const int*>(&stl->facet_start[facet_num].vertex[pivot_vertex](0)),
+							new_vertex(0),
+							*reinterpret_cast<const int*>(&new_vertex(0)));
+					if (stl->facet_start[facet_num].vertex[pivot_vertex](1) != new_vertex(1))
+						printf("Changing coordinate x, vertex %e (0x%08x) to %e(0x%08x)\r\n",
+							stl->facet_start[facet_num].vertex[pivot_vertex](1),
+							*reinterpret_cast<const int*>(&stl->facet_start[facet_num].vertex[pivot_vertex](1)),
+							new_vertex(1),
+							*reinterpret_cast<const int*>(&new_vertex(1)));
+					if (stl->facet_start[facet_num].vertex[pivot_vertex](2) != new_vertex(2))
+						printf("Changing coordinate x, vertex %e (0x%08x) to %e(0x%08x)\r\n",
+							stl->facet_start[facet_num].vertex[pivot_vertex](2),
+							*reinterpret_cast<const int*>(&stl->facet_start[facet_num].vertex[pivot_vertex](2)),
+							new_vertex(2),
+							*reinterpret_cast<const int*>(&new_vertex(2)));
+				}
+	#endif
+				stl->facet_start[facet_num].vertex[pivot_vertex] = new_vertex;
+				vnot = stl->neighbors_start[facet_num].which_vertex_not[next_edge];
+				facet_num = stl->neighbors_start[facet_num].neighbor[next_edge];
+				if (facet_num == -1)
+					break;
+
+				if (facet_num == first_facet) {
+					// back to the beginning
+					BOOST_LOG_TRIVIAL(info) << "Back to the first facet changing vertices: probably a mobius part. Try using a smaller tolerance or don't do a nearby check.";
+					return;
+				}
+			}
+		};
+
+		if (facet1 != -1) {
+			int vnot1 = (facet1 == edge_a.facet_number) ? 
+		  		(edge_a.which_edge + 2) % 3 :
+				(edge_b.which_edge + 2) % 3;
+			if (((vnot1 + 2) % 3) == vertex1)
+		  		vnot1 += 3;
+			change_vertices(facet1, vnot1, new_vertex1);
+		}
+		if (facet2 != -1) {
+			int vnot2 = (facet2 == edge_a.facet_number) ?
+		  		(edge_a.which_edge + 2) % 3 :
+				(edge_b.which_edge + 2) % 3;
+			if (((vnot2 + 2) % 3) == vertex2)
+		  		vnot2 += 3;
+			change_vertices(facet2, vnot2, new_vertex2);
+		}
+		stl->stats.edges_fixed += 2;
+	}
+};
+
+// This function builds the neighbors list.  No modifications are made
+// to any of the facets.  The edges are said to match only if all six
+// floats of the first edge matches all six floats of the second edge.
+void stl_check_facets_exact(stl_file *stl)
+{
+	assert(stl->facet_start.size() == stl->neighbors_start.size());
+
+  	stl->stats.connected_edges         = 0;
+  	stl->stats.connected_facets_1_edge = 0;
+  	stl->stats.connected_facets_2_edge = 0;
+  	stl->stats.connected_facets_3_edge = 0;
+
+  	// If any two of the three vertices are found to be exactally the same, call them degenerate and remove the facet.
+  	// Do it before the next step, as the next step stores references to the face indices in the hash tables and removing a facet
+  	// will break the references.
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets;) {
+		stl_facet &facet = stl->facet_start[i];
+	  	if (facet.vertex[0] == facet.vertex[1] || facet.vertex[1] == facet.vertex[2] || facet.vertex[0] == facet.vertex[2]) {
+		  	// Remove the degenerate facet.
+		  	facet = stl->facet_start[-- stl->stats.number_of_facets];
+			stl->facet_start.pop_back();
+			stl->neighbors_start.pop_back();
+		  	stl->stats.facets_removed += 1;
+		  	stl->stats.degenerate_facets += 1;
+	  	} else
+		  	++ i;
+  	}
+
+  	// Initialize hash table.
+  	HashTableEdges hash_table(stl->stats.number_of_facets);
+	for (auto &neighbor : stl->neighbors_start)
+		neighbor.reset();
+
+  	// Connect neighbor edges.
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+		const stl_facet &facet = stl->facet_start[i];
+		for (int j = 0; j < 3; ++ j) {
+			HashEdge edge;
+			edge.facet_number = i;
+			edge.which_edge = j;
+			edge.load_exact(stl, &facet.vertex[j], &facet.vertex[(j + 1) % 3]);
+			hash_table.insert_edge_exact(stl, edge);
+		}
+	}
+
+#if 0
+	printf("Number of faces: %d, number of manifold edges: %d, number of connected edges: %d, number of unconnected edges: %d\r\n", 
+    	stl->stats.number_of_facets, stl->stats.number_of_facets * 3, 
+    	stl->stats.connected_edges, stl->stats.number_of_facets * 3 - stl->stats.connected_edges);
+#endif
+}
+
+void stl_check_facets_nearby(stl_file *stl, float tolerance)
+{
+	assert(stl->stats.connected_facets_3_edge <= stl->stats.connected_facets_2_edge);
+	assert(stl->stats.connected_facets_2_edge <= stl->stats.connected_facets_1_edge);
+	assert(stl->stats.connected_facets_1_edge <= stl->stats.number_of_facets);
+
+  	if (stl->stats.connected_facets_3_edge == stl->stats.number_of_facets)
+    	// No need to check any further.  All facets are connected.
+    	return;
+
+  	HashTableEdges hash_table(stl->stats.number_of_facets);
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+    	//FIXME is the copy necessary?
+    	stl_facet facet = stl->facet_start[i];
+    	for (int j = 0; j < 3; j++) {
+      		if (stl->neighbors_start[i].neighbor[j] == -1) {
+        		HashEdge edge;
+        		edge.facet_number = i;
+        		edge.which_edge = j;
+        		if (edge.load_nearby(stl, facet.vertex[j], facet.vertex[(j + 1) % 3], tolerance))
+          			// Only insert edges that have different keys.
+          			hash_table.insert_edge_nearby(stl, edge);
+      		}
+    	}
+  	}
+}
+
+void stl_remove_unconnected_facets(stl_file *stl)
+{
+	// A couple of things need to be done here.  One is to remove any completely unconnected facets (0 edges connected) since these are
+	// useless and could be completely wrong.   The second thing that needs to be done is to remove any degenerate facets that were created during
+	// stl_check_facets_nearby().
+	auto remove_facet = [stl](int facet_number)
+	{
+		++ stl->stats.facets_removed;
+		/* Update list of connected edges */
+		stl_neighbors &neighbors = stl->neighbors_start[facet_number];
+		// Update statistics on unconnected triangle edges.
+		switch (neighbors.num_neighbors()) {
+		case 3: -- stl->stats.connected_facets_3_edge; // fall through
+		case 2: -- stl->stats.connected_facets_2_edge; // fall through
+		case 1: -- stl->stats.connected_facets_1_edge; // fall through
+		case 0: break;
+		default: assert(false);
+		}
+
+	  	if (facet_number < int(-- stl->stats.number_of_facets)) {
+	  		// Removing a face, which was not the last one.
+		  	// Copy the face and neighborship from the last face to facet_number.
+		  	stl->facet_start[facet_number] = stl->facet_start[stl->stats.number_of_facets];
+		  	neighbors = stl->neighbors_start[stl->stats.number_of_facets];
+		  	// Update neighborship of faces, which used to point to the last face, now moved to facet_number.
+		  	for (int i = 0; i < 3; ++ i)
+		    	if (neighbors.neighbor[i] != -1) {
+			    	int &other_face_idx = stl->neighbors_start[neighbors.neighbor[i]].neighbor[(neighbors.which_vertex_not[i] + 1) % 3];
+			  		if (other_face_idx != stl->stats.number_of_facets) {
+			  			BOOST_LOG_TRIVIAL(info) << "in remove_facet: neighbor = " << other_face_idx << " numfacets = " << stl->stats.number_of_facets << " this is wrong";
+			    		return;
+			  		}
+			  		other_face_idx = facet_number;
+		  		}
+		}
+
+	  	stl->facet_start.pop_back();
+	  	stl->neighbors_start.pop_back();
+	};
+
+	auto remove_degenerate = [stl, remove_facet](int facet)
+	{
+		// Update statistics on face connectivity after one edge was disconnected on the facet "facet_num".
+		auto update_connects_remove_1 = [stl](int facet_num) {
+			switch (stl->neighbors_start[facet_num].num_neighbors()) {
+			case 0: assert(false); break;
+			case 1: -- stl->stats.connected_facets_1_edge; break;
+			case 2: -- stl->stats.connected_facets_2_edge; break;
+			case 3: -- stl->stats.connected_facets_3_edge; break;
+			default: assert(false);
+		  	}
+		};
+
+		int edge_to_collapse = 0;
+	   	if (stl->facet_start[facet].vertex[0] == stl->facet_start[facet].vertex[1]) {
+			if (stl->facet_start[facet].vertex[1] == stl->facet_start[facet].vertex[2]) {
+				// All 3 vertices are equal. Collapse the edge with no neighbor if it exists.
+				const int *nbr = stl->neighbors_start[facet].neighbor;
+				edge_to_collapse = (nbr[0] == -1) ? 0 : (nbr[1] == -1) ? 1 : 2;
+			} else {
+				edge_to_collapse = 0;
+			}
+	  	} else if (stl->facet_start[facet].vertex[1] == stl->facet_start[facet].vertex[2]) {
+			edge_to_collapse = 1;
+	  	} else if (stl->facet_start[facet].vertex[2] == stl->facet_start[facet].vertex[0]) {
+			edge_to_collapse = 2;
+	  	} else {
+	    	// No degenerate. Function shouldn't have been called.
+	    	return;
+	  	}
+
+		int edge[3] = { (edge_to_collapse + 1) % 3, (edge_to_collapse + 2) % 3, edge_to_collapse };
+		int neighbor[] = {
+			stl->neighbors_start[facet].neighbor[edge[0]],
+			stl->neighbors_start[facet].neighbor[edge[1]],
+			stl->neighbors_start[facet].neighbor[edge[2]]
+		};
+		int vnot[] = {
+			stl->neighbors_start[facet].which_vertex_not[edge[0]],
+			stl->neighbors_start[facet].which_vertex_not[edge[1]],
+			stl->neighbors_start[facet].which_vertex_not[edge[2]]
+		};
+
+		// Update statistics on edge connectivity.
+		if ((neighbor[0] == -1) && (neighbor[1] != -1))
+			update_connects_remove_1(neighbor[1]);
+		if ((neighbor[1] == -1) && (neighbor[0] != -1))
+			update_connects_remove_1(neighbor[0]);
+
+	  	if (neighbor[0] >= 0) {
+			if (neighbor[1] >= 0) {
+				// Adjust the "flip" flag for the which_vertex_not values.
+				if (vnot[0] > 2) {
+					if (vnot[1] > 2) {
+						// The face to be removed has its normal flipped compared to the left & right neighbors, therefore after removing this face
+						// the two remaining neighbors will be oriented correctly.
+						vnot[0] -= 3;
+						vnot[1] -= 3;
+					} else
+						// One neighbor has its normal inverted compared to the face to be removed, the other is oriented equally.
+						// After removal, the two neighbors will have their normals flipped.
+						vnot[1] += 3;
+				} else if (vnot[1] > 2)
+					// One neighbor has its normal inverted compared to the face to be removed, the other is oriented equally.
+					// After removal, the two neighbors will have their normals flipped.
+					vnot[0] += 3;
+			}
+			stl->neighbors_start[neighbor[0]].neighbor[(vnot[0] + 1) % 3] = (neighbor[0] == neighbor[1]) ? -1 : neighbor[1];
+	    	stl->neighbors_start[neighbor[0]].which_vertex_not[(vnot[0] + 1) % 3] = vnot[1];
+	  	}
+	  	if (neighbor[1] >= 0) {
+			stl->neighbors_start[neighbor[1]].neighbor[(vnot[1] + 1) % 3] = (neighbor[0] == neighbor[1]) ? -1 : neighbor[0];
+	    	stl->neighbors_start[neighbor[1]].which_vertex_not[(vnot[1] + 1) % 3] = vnot[0];
+	  	}
+		if (neighbor[2] >= 0) {
+			update_connects_remove_1(neighbor[2]);
+			stl->neighbors_start[neighbor[2]].neighbor[(vnot[2] + 1) % 3] = -1;
+		}
+
+	  	remove_facet(facet);
+	};
+
+	// remove degenerate facets
+	for (uint32_t i = 0; i < stl->stats.number_of_facets;)
+		if (stl->facet_start[i].vertex[0] == stl->facet_start[i].vertex[1] ||
+			stl->facet_start[i].vertex[0] == stl->facet_start[i].vertex[2] ||
+			stl->facet_start[i].vertex[1] == stl->facet_start[i].vertex[2]) {
+			remove_degenerate(i);
+//			assert(stl_validate(stl));
+		} else
+			++ i;
+
+	if (stl->stats.connected_facets_1_edge < (int)stl->stats.number_of_facets) {
+		// There are some faces with no connected edge at all. Remove completely unconnected facets.
+		for (uint32_t i = 0; i < stl->stats.number_of_facets;)
+			if (stl->neighbors_start[i].num_neighbors() == 0) {
+				// This facet is completely unconnected.  Remove it.
+				remove_facet(i);
+				assert(stl_validate(stl));
+			} else
+				++ i;
+	}
+}
+
+void stl_fill_holes(stl_file *stl)
+{
+	// Insert all unconnected edges into hash list.
+	HashTableEdges hash_table(stl->stats.number_of_facets);
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+  		stl_facet facet = stl->facet_start[i];
+		for (int j = 0; j < 3; ++ j) {
+	  		if(stl->neighbors_start[i].neighbor[j] != -1)
+	  			continue;
+			HashEdge edge;
+	  		edge.facet_number = i;
+	  		edge.which_edge = j;
+	  		edge.load_exact(stl, &facet.vertex[j], &facet.vertex[(j + 1) % 3]);
+	  		hash_table.insert_edge_exact(stl, edge);
+		}
+	}
+
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+		stl_facet facet = stl->facet_start[i];
+		int neighbors_initial[3] = { stl->neighbors_start[i].neighbor[0], stl->neighbors_start[i].neighbor[1], stl->neighbors_start[i].neighbor[2] };
+		int first_facet = i;
+		for (int j = 0; j < 3; ++ j) {
+	  		if (stl->neighbors_start[i].neighbor[j] != -1)
+	  			continue;
+
+  			stl_facet new_facet;
+	  		new_facet.vertex[0] = facet.vertex[j];
+	  		new_facet.vertex[1] = facet.vertex[(j + 1) % 3];
+		  	bool direction = neighbors_initial[(j + 2) % 3] == -1;
+  			int facet_num = i;
+		  	int vnot = (j + 2) % 3;
+
+	  		for (;;) {
+				int pivot_vertex = 0;
+				int next_edge = 0;
+	    		if (vnot > 2) {
+	      			if (direction) {
+	        			pivot_vertex = (vnot + 1) % 3;
+	        			next_edge = vnot % 3;
+	      			} else {
+	        			pivot_vertex = (vnot + 2) % 3;
+	        			next_edge = pivot_vertex;
+	      			}
+	      			direction = ! direction;
+	    		} else {
+	      			if(direction == 0) {
+	        			pivot_vertex = (vnot + 1) % 3;
+	        			next_edge = vnot;
+	      			} else {
+	        			pivot_vertex = (vnot + 2) % 3;
+	        			next_edge = pivot_vertex;
+	      			}
+	    		}
+
+	    		int next_facet = stl->neighbors_start[facet_num].neighbor[next_edge];
+	    		if (next_facet == -1) {
+	      			new_facet.vertex[2] = stl->facet_start[facet_num].vertex[vnot % 3];
+				    stl_add_facet(stl, &new_facet);
+	      			for (int k = 0; k < 3; ++ k) {
+	      				HashEdge edge;
+	        			edge.facet_number = stl->stats.number_of_facets - 1;
+	        			edge.which_edge = k;
+	        			edge.load_exact(stl, &new_facet.vertex[k], &new_facet.vertex[(k + 1) % 3]);
+	        			hash_table.insert_edge_exact(stl, edge);
+	      			}
+	      			break;
+	    		}
+
+	      		vnot = stl->neighbors_start[facet_num].which_vertex_not[next_edge];
+	      		facet_num = next_facet;
+
+	    		if (facet_num == first_facet) {
+	      			// back to the beginning
+		  			BOOST_LOG_TRIVIAL(info) << "Back to the first facet filling holes: probably a mobius part. Try using a smaller tolerance or don't do a nearby check.";
+	      			return;
+	    		}
+	  		}
+		}
+	}
+}
+
+void stl_add_facet(stl_file *stl, const stl_facet *new_facet)
+{
+	assert(stl->facet_start.size() == stl->stats.number_of_facets);
+	assert(stl->neighbors_start.size() == stl->stats.number_of_facets);
+	stl->facet_start.emplace_back(*new_facet);
+  	// note that the normal vector is not set here, just initialized to 0.
+  	stl->facet_start[stl->stats.number_of_facets].normal = stl_normal::Zero();
+  	stl->neighbors_start.emplace_back();
+	++ stl->stats.facets_added;
+	++ stl->stats.number_of_facets;
+}

src/admesh/normals.cpp

@@ -0,0 +1,239 @@
+/*  ADMesh -- process triangulated solid meshes
+ *  Copyright (C) 1995, 1996  Anthony D. Martin <amartin@engr.csulb.edu>
+ *  Copyright (C) 2013, 2014  several contributors, see AUTHORS
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Questions, comments, suggestions, etc to
+ *           https://github.com/admesh/admesh/issues
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+// Boost pool: Don't use mutexes to synchronize memory allocation.
+#define BOOST_POOL_NO_MT
+#include <boost/pool/object_pool.hpp>
+
+#include "stl.h"
+
+static void reverse_facet(stl_file *stl, int facet_num)
+{
+	++ stl->stats.facets_reversed;
+
+	int neighbor[3] = { stl->neighbors_start[facet_num].neighbor[0], stl->neighbors_start[facet_num].neighbor[1], stl->neighbors_start[facet_num].neighbor[2] };
+	int vnot[3] = { stl->neighbors_start[facet_num].which_vertex_not[0], stl->neighbors_start[facet_num].which_vertex_not[1], stl->neighbors_start[facet_num].which_vertex_not[2] };
+
+	// reverse the facet
+	stl_vertex tmp_vertex = stl->facet_start[facet_num].vertex[0];
+	stl->facet_start[facet_num].vertex[0] = stl->facet_start[facet_num].vertex[1];
+	stl->facet_start[facet_num].vertex[1] = tmp_vertex;
+
+	// fix the vnots of the neighboring facets
+	if (neighbor[0] != -1)
+		stl->neighbors_start[neighbor[0]].which_vertex_not[(vnot[0] + 1) % 3] = (stl->neighbors_start[neighbor[0]].which_vertex_not[(vnot[0] + 1) % 3] + 3) % 6;
+	if (neighbor[1] != -1)
+		stl->neighbors_start[neighbor[1]].which_vertex_not[(vnot[1] + 1) % 3] = (stl->neighbors_start[neighbor[1]].which_vertex_not[(vnot[1] + 1) % 3] + 4) % 6;
+	if (neighbor[2] != -1)
+		stl->neighbors_start[neighbor[2]].which_vertex_not[(vnot[2] + 1) % 3] = (stl->neighbors_start[neighbor[2]].which_vertex_not[(vnot[2] + 1) % 3] + 2) % 6;
+
+	// swap the neighbors of the facet that is being reversed
+	stl->neighbors_start[facet_num].neighbor[1] = neighbor[2];
+	stl->neighbors_start[facet_num].neighbor[2] = neighbor[1];
+
+	// swap the vnots of the facet that is being reversed 
+	stl->neighbors_start[facet_num].which_vertex_not[1] = vnot[2];
+	stl->neighbors_start[facet_num].which_vertex_not[2] = vnot[1];
+
+	// reverse the values of the vnots of the facet that is being reversed
+	stl->neighbors_start[facet_num].which_vertex_not[0] = (stl->neighbors_start[facet_num].which_vertex_not[0] + 3) % 6;
+	stl->neighbors_start[facet_num].which_vertex_not[1] = (stl->neighbors_start[facet_num].which_vertex_not[1] + 3) % 6;
+	stl->neighbors_start[facet_num].which_vertex_not[2] = (stl->neighbors_start[facet_num].which_vertex_not[2] + 3) % 6;
+}
+
+// Returns true if the normal was flipped.
+static bool check_normal_vector(stl_file *stl, int facet_num, int normal_fix_flag)
+{
+	stl_facet *facet = &stl->facet_start[facet_num];
+
+	stl_normal normal;
+	stl_calculate_normal(normal, facet);
+	stl_normalize_vector(normal);
+	stl_normal normal_dif = (normal - facet->normal).cwiseAbs();
+
+	const float eps = 0.001f;
+	if (normal_dif(0) < eps && normal_dif(1) < eps && normal_dif(2) < eps) {
+		// Normal is within tolerance. It is not really necessary to change the values here, but just for consistency, I will.
+		facet->normal = normal;
+		return false;
+	}
+
+	stl_normal test_norm = facet->normal;
+	stl_normalize_vector(test_norm);
+	normal_dif = (normal - test_norm).cwiseAbs();
+	if (normal_dif(0) < eps && normal_dif(1) < eps && normal_dif(2) < eps) {
+		// The normal is not within tolerance, but direction is OK.
+		if (normal_fix_flag) {
+	  		facet->normal = normal;
+	  		++ stl->stats.normals_fixed;
+		}
+		return false;
+	}
+
+	test_norm *= -1.f;
+	normal_dif = (normal - test_norm).cwiseAbs();
+	if (normal_dif(0) < eps && normal_dif(1) < eps && normal_dif(2) < eps) {
+		// The normal is not within tolerance and backwards.
+		if (normal_fix_flag) {
+	  		facet->normal = normal;
+	  		++ stl->stats.normals_fixed;
+		}
+		return true;
+	}
+	if (normal_fix_flag) {
+		facet->normal = normal;
+		++ stl->stats.normals_fixed;
+	}
+	// Status is unknown.
+	return false;
+}
+
+void stl_fix_normal_directions(stl_file *stl)
+{
+ 	// This may happen for malformed models
+  	if (stl->stats.number_of_facets == 0)
+  		return;
+
+	struct stl_normal {
+    	int         facet_num;
+    	stl_normal *next;
+  	};
+
+  	// Initialize linked list.
+  	boost::object_pool<stl_normal> pool;
+   	stl_normal *head = pool.construct();
+  	stl_normal *tail = pool.construct();
+	head->next = tail;
+	tail->next = tail;
+
+	// Initialize list that keeps track of already fixed facets.
+	std::vector<char> norm_sw(stl->stats.number_of_facets, 0);
+	// Initialize list that keeps track of reversed facets.
+    std::vector<int>  reversed_ids;
+    reversed_ids.reserve(stl->stats.number_of_facets);
+
+  	int facet_num = 0;
+  	// If normal vector is not within tolerance and backwards:
+    // Arbitrarily starts at face 0.  If this one is wrong, we're screwed. Thankfully, the chances
+    // of it being wrong randomly are low if most of the triangles are right:
+  	if (check_normal_vector(stl, 0, 0)) {
+    	reverse_facet(stl, 0);
+      	reversed_ids.emplace_back(0);
+  	}
+
+  	// Say that we've fixed this facet:
+  	norm_sw[facet_num] = 1;
+	int checked = 1;
+
+  	for (;;) {
+    	// Add neighbors_to_list. Add unconnected neighbors to the list.
+    	bool force_exit = false;
+    	for (int j = 0; j < 3; ++ j) {
+      		// Reverse the neighboring facets if necessary.
+      		if (stl->neighbors_start[facet_num].which_vertex_not[j] > 2) {
+        		// If the facet has a neighbor that is -1, it means that edge isn't shared by another facet
+        		if (stl->neighbors_start[facet_num].neighbor[j] != -1) {
+            		if (norm_sw[stl->neighbors_start[facet_num].neighbor[j]] == 1) {
+                		// trying to modify a facet already marked as fixed, revert all changes made until now and exit (fixes: #716, #574, #413, #269, #262, #259, #230, #228, #206)
+                		for (int id = int(reversed_ids.size()) - 1; id >= 0; -- id)
+                    		reverse_facet(stl, reversed_ids[id]);
+                		force_exit = true;
+                		break;
+            		}
+            		reverse_facet(stl, stl->neighbors_start[facet_num].neighbor[j]);
+            		reversed_ids.emplace_back(stl->neighbors_start[facet_num].neighbor[j]);
+        		}
+      		}
+      		// If this edge of the facet is connected:
+      		if (stl->neighbors_start[facet_num].neighbor[j] != -1) {
+        		// If we haven't fixed this facet yet, add it to the list:
+        		if (norm_sw[stl->neighbors_start[facet_num].neighbor[j]] != 1) {
+	          		// Add node to beginning of list.
+	          		stl_normal *newn = pool.construct();
+	          		newn->facet_num = stl->neighbors_start[facet_num].neighbor[j];
+	          		newn->next = head->next;
+	          		head->next = newn;
+	        	}
+	      	}
+	    }
+
+    	// an error occourred, quit the for loop and exit
+    	if (force_exit)
+    		break;
+
+    	// Get next facet to fix from top of list.
+    	if (head->next != tail) {
+      		facet_num = head->next->facet_num;
+            assert(facet_num < stl->stats.number_of_facets);
+      		if (norm_sw[facet_num] != 1) { // If facet is in list mutiple times
+        		norm_sw[facet_num] = 1; // Record this one as being fixed.
+        		++ checked;
+      		}
+      		stl_normal *temp = head->next;	// Delete this facet from the list.
+      		head->next = head->next->next;
+      		// pool.destroy(temp);
+    	} else { // If we ran out of facets to fix: All of the facets in this part have been fixed.
+      		++ stl->stats.number_of_parts;
+      		if (checked >= int(stl->stats.number_of_facets))
+        		// All of the facets have been checked.  Bail out.
+        		break;
+    		// There is another part here.  Find it and continue.
+    		for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
+      			if (norm_sw[i] == 0) {
+        			// This is the first facet of the next part.
+        			facet_num = i;
+        			if (check_normal_vector(stl, i, 0)) {
+            			reverse_facet(stl, i);
+            			reversed_ids.emplace_back(i);
+        			}
+        			norm_sw[facet_num] = 1;
+        			++ checked;
+        			break;
+      			}
+    	}
+  	}
+
+	// pool.destroy(head);
+	// pool.destroy(tail);
+}
+
+void stl_fix_normal_values(stl_file *stl)
+{
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
+    	check_normal_vector(stl, i, 1);
+}
+
+void stl_reverse_all_facets(stl_file *stl)
+{
+	stl_normal normal;
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+    	reverse_facet(stl, i);
+    	stl_calculate_normal(normal, &stl->facet_start[i]);
+    	stl_normalize_vector(normal);
+    	stl->facet_start[i].normal = normal;
+  	}
+}

src/admesh/shared.cpp

@@ -0,0 +1,263 @@
+/*  ADMesh -- process triangulated solid meshes
+ *  Copyright (C) 1995, 1996  Anthony D. Martin <amartin@engr.csulb.edu>
+ *  Copyright (C) 2013, 2014  several contributors, see AUTHORS
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Questions, comments, suggestions, etc to
+ *           https://github.com/admesh/admesh/issues
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <vector>
+
+#include <boost/log/trivial.hpp>
+#include <boost/nowide/cstdio.hpp>
+
+#include "stl.h"
+
+#include "libslic3r/LocalesUtils.hpp"
+
+void stl_generate_shared_vertices(stl_file *stl, indexed_triangle_set &its)
+{
+	// 3 indices to vertex per face
+	its.indices.assign(stl->stats.number_of_facets, stl_triangle_vertex_indices(-1, -1, -1));
+	// Shared vertices (3D coordinates)
+	its.vertices.clear();
+	its.vertices.reserve(stl->stats.number_of_facets / 2);
+
+	// A degenerate mesh may contain loops: Traversing a fan will end up in an endless loop
+	// while never reaching the starting face. To avoid these endless loops, traversed faces at each fan traversal
+	// are marked with a unique fan_traversal_stamp.
+	unsigned int			  fan_traversal_stamp = 0;
+	std::vector<unsigned int> fan_traversal_facet_visited(stl->stats.number_of_facets, 0);
+
+	for (uint32_t facet_idx = 0; facet_idx < stl->stats.number_of_facets; ++ facet_idx) {
+		for (int j = 0; j < 3; ++ j) {
+			if (its.indices[facet_idx][j] != -1)
+				// Shared vertex was already assigned.
+				continue;
+			// Create a new shared vertex.
+			its.vertices.emplace_back(stl->facet_start[facet_idx].vertex[j]);
+			// Traverse the fan around the j-th vertex of the i-th face, assign the newly created shared vertex index to all the neighboring triangles in the triangle fan.
+			int  facet_in_fan_idx 	= facet_idx;
+			bool edge_direction 	= false;
+			bool traversal_reversed = false;
+			int  vnot      			= (j + 2) % 3;
+			// Increase the 
+			++ fan_traversal_stamp;
+			for (;;) {
+				// Next edge on facet_in_fan_idx to be traversed. The edge is indexed by its starting vertex index.
+				int next_edge    = 0;
+				// Vertex index in facet_in_fan_idx, which is being pivoted around, and which is being assigned a new shared vertex.
+				int pivot_vertex = 0;
+				if (vnot > 2) {
+					// The edge of facet_in_fan_idx opposite to vnot is equally oriented, therefore
+					// the neighboring facet is flipped.
+			  		if (! edge_direction) {
+			    		pivot_vertex = (vnot + 2) % 3;
+			    		next_edge    = pivot_vertex;			    		
+			  		} else {
+			    		pivot_vertex = (vnot + 1) % 3;
+			    		next_edge    = vnot % 3;
+			  		}
+			  		edge_direction = ! edge_direction;
+				} else {
+					// The neighboring facet is correctly oriented.
+			  		if (! edge_direction) {
+			    		pivot_vertex = (vnot + 1) % 3;
+			    		next_edge    = vnot;
+			  		} else {
+			    		pivot_vertex = (vnot + 2) % 3;
+			    		next_edge    = pivot_vertex;
+			  		}
+				}
+				its.indices[facet_in_fan_idx][pivot_vertex] = its.vertices.size() - 1;
+				fan_traversal_facet_visited[facet_in_fan_idx] = fan_traversal_stamp;
+
+				// next_edge is an index of the starting vertex of the edge, not an index of the opposite vertex to the edge!
+				int next_facet = stl->neighbors_start[facet_in_fan_idx].neighbor[next_edge];
+				if (next_facet == -1) {
+					// No neighbor going in the current direction.
+					if (traversal_reversed) {
+						// Went to one limit, then turned back and reached the other limit. Quit the fan traversal.
+					    break;
+					} else {
+						// Reached the first limit. Now try to reverse and traverse up to the other limit.
+					    edge_direction        = true;
+					    vnot 	         	  = (j + 1) % 3;
+					    traversal_reversed    = true;
+				    	facet_in_fan_idx      = facet_idx;
+					}
+				} else if (next_facet == facet_idx) {
+					// Traversed a closed fan all around.
+//					assert(! traversal_reversed);
+					break;
+				} else if (next_facet >= (int)stl->stats.number_of_facets) {
+					// The mesh is not valid!
+					// assert(false);
+					break;
+				} else if (fan_traversal_facet_visited[next_facet] == fan_traversal_stamp) {
+					// Traversed a closed fan all around, but did not reach the starting face.
+					// This indicates an invalid geometry (non-manifold).
+					//assert(false);
+					break;
+				} else {
+					// Continue traversal.
+					// next_edge is an index of the starting vertex of the edge, not an index of the opposite vertex to the edge!
+					vnot = stl->neighbors_start[facet_in_fan_idx].which_vertex_not[next_edge];
+					facet_in_fan_idx = next_facet;
+				}
+			}
+		}
+	}
+}
+
+bool its_write_off(const indexed_triangle_set &its, const char *file)
+{
+    Slic3r::CNumericLocalesSetter locales_setter;
+	/* Open the file */
+	FILE *fp = boost::nowide::fopen(file, "w");
+	if (fp == nullptr) {
+		BOOST_LOG_TRIVIAL(error) << "stl_write_ascii: Couldn't open " << file << " for writing";
+		return false;
+	}
+
+	fprintf(fp, "OFF\n");
+	fprintf(fp, "%d %d 0\n", (int)its.vertices.size(), (int)its.indices.size());
+	for (int i = 0; i < its.vertices.size(); ++ i)
+		fprintf(fp, "\t%f %f %f\n", its.vertices[i](0), its.vertices[i](1), its.vertices[i](2));
+	for (uint32_t i = 0; i < its.indices.size(); ++ i)
+		fprintf(fp, "\t3 %d %d %d\n", its.indices[i][0], its.indices[i][1], its.indices[i][2]);
+	fclose(fp);
+	return true;
+}
+
+bool its_write_vrml(const indexed_triangle_set &its, const char *file)
+{
+    Slic3r::CNumericLocalesSetter locales_setter;
+	/* Open the file */
+  	FILE *fp = boost::nowide::fopen(file, "w");
+	if (fp == nullptr) {
+		BOOST_LOG_TRIVIAL(error) << "stl_write_vrml: Couldn't open " << file << " for writing";
+		return false;
+	}
+
+	fprintf(fp, "#VRML V1.0 ascii\n\n");
+	fprintf(fp, "Separator {\n");
+	fprintf(fp, "\tDEF STLShape ShapeHints {\n");
+	fprintf(fp, "\t\tvertexOrdering COUNTERCLOCKWISE\n");
+	fprintf(fp, "\t\tfaceType CONVEX\n");
+	fprintf(fp, "\t\tshapeType SOLID\n");
+	fprintf(fp, "\t\tcreaseAngle 0.0\n");
+	fprintf(fp, "\t}\n");
+	fprintf(fp, "\tDEF STLModel Separator {\n");
+	fprintf(fp, "\t\tDEF STLColor Material {\n");
+	fprintf(fp, "\t\t\temissiveColor 0.700000 0.700000 0.000000\n");
+	fprintf(fp, "\t\t}\n");
+	fprintf(fp, "\t\tDEF STLVertices Coordinate3 {\n");
+	fprintf(fp, "\t\t\tpoint [\n");
+
+	int i = 0;
+	for (; i + 1 < its.vertices.size(); ++ i)
+		fprintf(fp, "\t\t\t\t%f %f %f,\n", its.vertices[i](0), its.vertices[i](1), its.vertices[i](2));
+	fprintf(fp, "\t\t\t\t%f %f %f]\n", its.vertices[i](0), its.vertices[i](1), its.vertices[i](2));
+	fprintf(fp, "\t\t}\n");
+	fprintf(fp, "\t\tDEF STLTriangles IndexedFaceSet {\n");
+	fprintf(fp, "\t\t\tcoordIndex [\n");
+
+	for (size_t i = 0; i + 1 < its.indices.size(); ++ i)
+		fprintf(fp, "\t\t\t\t%d, %d, %d, -1,\n", its.indices[i][0], its.indices[i][1], its.indices[i][2]);
+	fprintf(fp, "\t\t\t\t%d, %d, %d, -1]\n", its.indices[i][0], its.indices[i][1], its.indices[i][2]);
+	fprintf(fp, "\t\t}\n");
+	fprintf(fp, "\t}\n");
+	fprintf(fp, "}\n");
+	fclose(fp);
+	return true;
+}
+
+bool its_write_obj(const indexed_triangle_set &its, const char *file)
+{
+    Slic3r::CNumericLocalesSetter locales_setter;
+  	FILE *fp = boost::nowide::fopen(file, "w");
+  	if (fp == nullptr) {
+		BOOST_LOG_TRIVIAL(error) << "stl_write_obj: Couldn't open " << file << " for writing";
+    	return false;
+  	}
+
+	for (size_t i = 0; i < its.vertices.size(); ++ i)
+    	fprintf(fp, "v %f %f %f\n", its.vertices[i](0), its.vertices[i](1), its.vertices[i](2));
+  	for (size_t i = 0; i < its.indices.size(); ++ i)
+    	fprintf(fp, "f %d %d %d\n", its.indices[i][0]+1, its.indices[i][1]+1, its.indices[i][2]+1);
+  	fclose(fp);
+  	return true;
+}
+
+
+// Check validity of the mesh, assert on error.
+bool stl_validate(const stl_file *stl, const indexed_triangle_set &its)
+{
+	assert(! stl->facet_start.empty());
+	assert(stl->facet_start.size() == stl->stats.number_of_facets);
+	assert(stl->neighbors_start.size() == stl->stats.number_of_facets);
+	assert(stl->facet_start.size() == stl->neighbors_start.size());
+	assert(! stl->neighbors_start.empty());
+	assert((its.indices.empty()) == (its.vertices.empty()));
+	assert(stl->stats.number_of_facets > 0);
+	assert(its.vertices.empty() || its.indices.size() == stl->stats.number_of_facets);
+
+#ifdef _DEBUG
+    // Verify validity of neighborship data.
+    for (int facet_idx = 0; facet_idx < (int)stl->stats.number_of_facets; ++ facet_idx) {
+        const stl_neighbors &nbr 		= stl->neighbors_start[facet_idx];
+        const int 			*vertices 	= its.indices.empty() ? nullptr : its.indices[facet_idx].data();
+        for (int nbr_idx = 0; nbr_idx < 3; ++ nbr_idx) {
+            int nbr_face = stl->neighbors_start[facet_idx].neighbor[nbr_idx];
+            assert(nbr_face < (int)stl->stats.number_of_facets);
+            if (nbr_face != -1) {
+            	int nbr_vnot = nbr.which_vertex_not[nbr_idx];
+				assert(nbr_vnot >= 0 && nbr_vnot < 6);
+				// Neighbor of the neighbor is the original face.
+				assert(stl->neighbors_start[nbr_face].neighbor[(nbr_vnot + 1) % 3] == facet_idx);
+				int vnot_back = stl->neighbors_start[nbr_face].which_vertex_not[(nbr_vnot + 1) % 3];
+				assert(vnot_back >= 0 && vnot_back < 6);
+				assert((nbr_vnot < 3) == (vnot_back < 3));
+				assert(vnot_back % 3 == (nbr_idx + 2) % 3);
+				if (vertices != nullptr) {
+					// Has shared vertices.
+	            	if (nbr_vnot < 3) {
+	            		// Faces facet_idx and nbr_face share two vertices accross the common edge. Faces are correctly oriented.
+						assert((its.indices[nbr_face][(nbr_vnot + 1) % 3] == vertices[(nbr_idx + 1) % 3] && its.indices[nbr_face][(nbr_vnot + 2) % 3] == vertices[nbr_idx]));
+					} else {
+	            		// Faces facet_idx and nbr_face share two vertices accross the common edge. Faces are incorrectly oriented, one of them is flipped.
+						assert((its.indices[nbr_face][(nbr_vnot + 2) % 3] == vertices[(nbr_idx + 1) % 3] && its.indices[nbr_face][(nbr_vnot + 1) % 3] == vertices[nbr_idx]));
+					}
+				}
+            }
+        }
+    }
+#endif /* _DEBUG */
+
+	return true;
+}
+
+// Check validity of the mesh, assert on error.
+bool stl_validate(const stl_file *stl)
+{
+	indexed_triangle_set its;
+	return stl_validate(stl, its);
+}

src/admesh/stl.h

@@ -0,0 +1,410 @@
+/*  ADMesh -- process triangulated solid meshes
+ *  Copyright (C) 1995, 1996  Anthony D. Martin <amartin@engr.csulb.edu>
+ *  Copyright (C) 2013, 2014  several contributors, see AUTHORS
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Questions, comments, suggestions, etc to
+ *           https://github.com/admesh/admesh/issues
+ */
+
+#ifndef __admesh_stl__
+#define __admesh_stl__
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#include <vector>
+#include <Eigen/Geometry> 
+
+// Size of the binary STL header, free form.
+#define LABEL_SIZE             80
+// Binary STL, length of the "number of faces" counter.
+#define NUM_FACET_SIZE         4
+// Binary STL, sizeof header + number of faces.
+#define HEADER_SIZE            84
+#define STL_MIN_FILE_SIZE      284
+#define ASCII_LINES_PER_FACET  7
+
+typedef Eigen::Matrix<float, 3, 1, Eigen::DontAlign> stl_vertex;
+typedef Eigen::Matrix<float, 3, 1, Eigen::DontAlign> stl_normal;
+typedef Eigen::Matrix<int,   3, 1, Eigen::DontAlign> stl_triangle_vertex_indices;
+static_assert(sizeof(stl_vertex) == 12, "size of stl_vertex incorrect");
+static_assert(sizeof(stl_normal) == 12, "size of stl_normal incorrect");
+
+typedef enum {
+    eNormal,  // normal face
+    eSmallOverhang,  // small overhang
+    eSmallHole,      // face with small hole
+    eExteriorAppearance,  // exterior appearance
+    eMaxNumFaceTypes
+}EnumFaceTypes;
+
+struct stl_facet {
+	stl_normal normal;
+	stl_vertex vertex[3];
+	char       extra[2];
+
+	stl_facet  rotated(const Eigen::Quaternion<float, Eigen::DontAlign> &rot) const {
+		stl_facet out;
+		out.normal    = rot * this->normal;
+		out.vertex[0] = rot * this->vertex[0];
+		out.vertex[1] = rot * this->vertex[1];
+		out.vertex[2] = rot * this->vertex[2];
+		return out;
+	}
+};
+
+#define SIZEOF_STL_FACET       50
+
+static_assert(offsetof(stl_facet, normal) == 0, "stl_facet.normal has correct offset");
+static_assert(offsetof(stl_facet, vertex) == 12, "stl_facet.vertex has correct offset");
+static_assert(offsetof(stl_facet, extra ) == 48, "stl_facet.extra has correct offset");
+static_assert(sizeof(stl_facet) >= SIZEOF_STL_FACET, "size of stl_facet incorrect");
+
+typedef enum {binary, ascii, inmemory} stl_type;
+
+struct stl_neighbors {
+  	stl_neighbors() { reset(); }
+  	void reset() {
+  		neighbor[0] = -1;
+  		neighbor[1] = -1;
+  		neighbor[2] = -1;
+  		which_vertex_not[0] = -1;
+  		which_vertex_not[1] = -1;
+  		which_vertex_not[2] = -1;
+  	}
+  	int num_neighbors() const { return 3 - ((this->neighbor[0] == -1) + (this->neighbor[1] == -1) + (this->neighbor[2] == -1)); }
+
+  	// Index of a neighbor facet.
+  	int   neighbor[3];
+  	// Index of an opposite vertex at the neighbor face.
+  	char  which_vertex_not[3];
+};
+
+struct stl_stats {
+    stl_stats() { memset(&header, 0, 81); }
+    char          header[81];
+    stl_type      type                      = (stl_type)0;
+    // Should always match the number of facets stored inside stl_file::facet_start.
+    uint32_t      number_of_facets          = 0;
+    // Bounding box.
+    stl_vertex    max                       = stl_vertex::Zero();
+    stl_vertex    min                       = stl_vertex::Zero();
+    stl_vertex    size                      = stl_vertex::Zero();
+    float         bounding_diameter         = 0.f;
+    float         shortest_edge             = 0.f;
+    // After repair, the volume shall always be positive.
+    float         volume                    = -1.f;
+    // Number of face edges connected to another face.
+    // Don't use this statistics after repair, use the connected_facets_1/2/3_edge instead!
+    int           connected_edges           = 0;
+    // Faces with >=1, >=2 and 3 edges connected to another face.
+    int           connected_facets_1_edge   = 0;
+    int           connected_facets_2_edge   = 0;
+    int           connected_facets_3_edge   = 0;
+    // Faces with 1, 2 and 3 open edges after exact chaining, but before repair.
+    int           facets_w_1_bad_edge       = 0;
+    int           facets_w_2_bad_edge       = 0;
+    int           facets_w_3_bad_edge       = 0;
+    // Number of faces read form an STL file.
+    int           original_num_facets       = 0;
+    // Number of edges connected one to another by snapping their end vertices.
+    int           edges_fixed               = 0;
+    // Number of faces removed because they were degenerated.
+    int           degenerate_facets         = 0;
+    // Total number of facets removed: Degenerate faces and unconnected faces.
+    int           facets_removed            = 0;
+    // Number of faces added by hole filling.
+    int           facets_added              = 0;
+    // Number of faces reversed because of negative volume or because one patch was connected to another patch with incompatible normals.
+    int           facets_reversed           = 0;
+    // Number of incompatible edges remaining after the patches were connected together and possibly their normals flipped.
+    int           backwards_edges           = 0;
+    // Number of triangles, which were flipped during the fixing process.
+    int           normals_fixed             = 0;
+    // Number of connected triangle patches.
+    int           number_of_parts           = 0;
+
+    void clear() { *this = stl_stats(); }
+};
+
+struct stl_file {
+	stl_file() {}
+
+	void clear() {
+		this->facet_start.clear();
+		this->neighbors_start.clear();
+        this->stats.clear();
+	}
+
+	size_t memsize() const {
+		return sizeof(*this) + sizeof(stl_facet) * facet_start.size() + sizeof(stl_neighbors) * neighbors_start.size();
+	}
+
+	std::vector<stl_facet>     		facet_start;
+	std::vector<stl_neighbors> 		neighbors_start;
+	// Statistics
+	stl_stats     					stats;
+};
+
+struct FaceProperty
+{   // triangle face property
+    EnumFaceTypes type;
+    double area;
+    // stl_normal normal;
+
+    std::string to_string() const
+    {
+        std::string str;
+        // skip normal type facet to improve performance 
+        if (type > eNormal && type < eMaxNumFaceTypes) {
+            str += std::to_string(type);
+            if (area != 0.f)
+                str += " " + std::to_string(area);
+        }
+        return str;
+    }
+
+    void from_string(const std::string& str)
+    {
+        std::string val_str, area_str;
+        do {
+            if (str.empty())
+                break;
+
+            this->type = (EnumFaceTypes)std::atoi(str.c_str());
+            if (this->type <= eNormal || this->type >= eMaxNumFaceTypes)
+                break;
+
+            size_t type_end_pos = str.find(" ");
+            if (type_end_pos == std::string::npos) {
+                this->area = 0.f;
+                return;
+            }
+
+            area_str = str.substr(type_end_pos + 1);
+            if (!area_str.empty())
+                this->area = std::atof(area_str.c_str());
+            else
+                this->area = 0.f;
+            return;
+        } while (0);
+
+        this->type = eNormal;
+        this->area = 0.f;
+    }
+};
+
+struct indexed_triangle_set
+{
+    indexed_triangle_set(std::vector<stl_triangle_vertex_indices>    indices_,
+        std::vector<stl_vertex>                     vertices_) :indices(indices_), vertices(vertices_) {
+        properties.resize(indices_.size());
+    }
+    indexed_triangle_set() {}
+
+    void clear() { indices.clear(); vertices.clear(); properties.clear(); }
+
+    size_t memsize() const {
+        return sizeof(*this) + (sizeof(stl_triangle_vertex_indices) + sizeof(FaceProperty)) * indices.size() + sizeof(stl_vertex) * vertices.size();
+    }
+
+    std::vector<stl_triangle_vertex_indices>    indices;
+    std::vector<stl_vertex>                     vertices;
+    std::vector<FaceProperty>                   properties;
+
+    bool empty() const { return indices.empty() || vertices.empty(); }
+    stl_vertex get_vertex(int facet_idx, int vertex_idx) const{
+        return vertices[indices[facet_idx][vertex_idx]];
+    }
+    float facet_area(int facet_idx) const {
+        return std::abs((get_vertex(facet_idx, 0) - get_vertex(facet_idx, 1))
+            .cross(get_vertex(facet_idx, 0) - get_vertex(facet_idx, 2)).norm()) / 2;
+    }
+    FaceProperty& get_property(int face_idx) {
+        if (properties.size() != indices.size()) {
+            properties.clear();
+            properties.resize(indices.size());
+        }
+        return properties[face_idx];
+    }
+};
+
+extern bool stl_open(stl_file *stl, const char *file);
+extern void stl_stats_out(stl_file *stl, FILE *file, char *input_file);
+extern bool stl_print_neighbors(stl_file *stl, char *file);
+extern bool stl_write_ascii(stl_file *stl, const char *file, const char *label);
+extern bool stl_write_binary(stl_file *stl, const char *file, const char *label);
+extern void stl_check_facets_exact(stl_file *stl);
+extern void stl_check_facets_nearby(stl_file *stl, float tolerance);
+extern void stl_remove_unconnected_facets(stl_file *stl);
+extern void stl_write_vertex(stl_file *stl, int facet, int vertex);
+extern void stl_write_facet(stl_file *stl, char *label, int facet);
+extern void stl_write_neighbor(stl_file *stl, int facet);
+extern bool stl_write_quad_object(stl_file *stl, char *file);
+extern void stl_verify_neighbors(stl_file *stl);
+extern void stl_fill_holes(stl_file *stl);
+extern void stl_fix_normal_directions(stl_file *stl);
+extern void stl_fix_normal_values(stl_file *stl);
+extern void stl_reverse_all_facets(stl_file *stl);
+extern void stl_translate(stl_file *stl, float x, float y, float z);
+extern void stl_translate_relative(stl_file *stl, float x, float y, float z);
+extern void stl_scale_versor(stl_file *stl, const stl_vertex &versor);
+inline void stl_scale(stl_file *stl, float factor) { stl_scale_versor(stl, stl_vertex(factor, factor, factor)); }
+extern void stl_rotate_x(stl_file *stl, float angle);
+extern void stl_rotate_y(stl_file *stl, float angle);
+extern void stl_rotate_z(stl_file *stl, float angle);
+extern void stl_mirror_xy(stl_file *stl);
+extern void stl_mirror_yz(stl_file *stl);
+extern void stl_mirror_xz(stl_file *stl);
+
+extern float get_area(stl_facet* facet);
+
+extern void stl_get_size(stl_file *stl);
+
+// the following function is not used
+/*
+template<typename T>
+extern void stl_transform(stl_file *stl, T *trafo3x4)
+{
+    Eigen::Matrix<T, 3, 3, Eigen::DontAlign> trafo3x3;
+    for (int i = 0; i < 3; ++i)
+    {
+        for (int j = 0; j < 3; ++j)
+        {
+            trafo3x3(i, j) = (i * 4) + j;
+        }
+    }
+    Eigen::Matrix<T, 3, 3, Eigen::DontAlign> r = trafo3x3.inverse().transpose();
+    for (uint32_t i_face = 0; i_face < stl->stats.number_of_facets; ++ i_face) {
+		stl_facet &face = stl->facet_start[i_face];
+		for (int i_vertex = 0; i_vertex < 3; ++ i_vertex) {
+			stl_vertex &v_dst = face.vertex[i_vertex];
+			stl_vertex  v_src = v_dst;
+			v_dst(0) = T(trafo3x4[0] * v_src(0) + trafo3x4[1] * v_src(1) + trafo3x4[2]  * v_src(2) + trafo3x4[3]);
+			v_dst(1) = T(trafo3x4[4] * v_src(0) + trafo3x4[5] * v_src(1) + trafo3x4[6]  * v_src(2) + trafo3x4[7]);
+			v_dst(2) = T(trafo3x4[8] * v_src(0) + trafo3x4[9] * v_src(1) + trafo3x4[10] * v_src(2) + trafo3x4[11]);
+		}
+        face.normal = (r * face.normal.template cast<T>()).template cast<float>().eval();
+    }
+
+	stl_get_size(stl);
+}
+*/
+
+template<typename T>
+inline void stl_transform(stl_file *stl, const Eigen::Transform<T, 3, Eigen::Affine, Eigen::DontAlign>& t)
+{
+    const Eigen::Matrix<T, 3, 3, Eigen::DontAlign> r = t.matrix().template block<3, 3>(0, 0).inverse().transpose();
+    for (size_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+		stl_facet &f = stl->facet_start[i];
+		for (size_t j = 0; j < 3; ++j)
+			f.vertex[j] = (t * f.vertex[j].template cast<T>()).template cast<float>().eval();
+		f.normal = (r * f.normal.template cast<T>()).template cast<float>().eval();
+	}
+
+	stl_get_size(stl);
+}
+
+template<typename T>
+inline void stl_transform(stl_file *stl, const Eigen::Matrix<T, 3, 3, Eigen::DontAlign>& m)
+{
+    const Eigen::Matrix<T, 3, 3, Eigen::DontAlign> r = m.inverse().transpose();
+    for (size_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+		stl_facet &f = stl->facet_start[i];
+		for (size_t j = 0; j < 3; ++j)
+			f.vertex[j] = (m * f.vertex[j].template cast<T>()).template cast<float>().eval();
+        f.normal = (r * f.normal.template cast<T>()).template cast<float>().eval();
+    }
+
+	stl_get_size(stl);
+}
+
+template<typename V>
+inline void its_translate(indexed_triangle_set &its, const V v)
+{
+  for (stl_vertex &v_dst : its.vertices)
+    v_dst += v;
+}
+
+template<typename T>
+inline void its_transform(indexed_triangle_set &its, T *trafo3x4)
+{
+	for (stl_vertex &v_dst : its.vertices) {
+		stl_vertex  v_src = v_dst;
+		v_dst(0) = T(trafo3x4[0] * v_src(0) + trafo3x4[1] * v_src(1) + trafo3x4[2]  * v_src(2) + trafo3x4[3]);
+		v_dst(1) = T(trafo3x4[4] * v_src(0) + trafo3x4[5] * v_src(1) + trafo3x4[6]  * v_src(2) + trafo3x4[7]);
+		v_dst(2) = T(trafo3x4[8] * v_src(0) + trafo3x4[9] * v_src(1) + trafo3x4[10] * v_src(2) + trafo3x4[11]);
+	}
+}
+
+template<typename T>
+inline void its_transform(indexed_triangle_set &its, const Eigen::Transform<T, 3, Eigen::Affine, Eigen::DontAlign>& t, bool fix_left_handed = false)
+{
+	//const Eigen::Matrix<double, 3, 3, Eigen::DontAlign> r = t.matrix().template block<3, 3>(0, 0);
+	for (stl_vertex &v : its.vertices)
+		v = (t * v.template cast<T>()).template cast<float>().eval();
+  if (fix_left_handed && t.matrix().block(0, 0, 3, 3).determinant() < 0.)
+    for (stl_triangle_vertex_indices &i : its.indices)
+      std::swap(i[0], i[1]);
+}
+
+template<typename T>
+inline void its_transform(indexed_triangle_set &its, const Eigen::Matrix<T, 3, 3, Eigen::DontAlign>& m, bool fix_left_handed = false)
+{
+  for (stl_vertex &v : its.vertices)
+		v = (m * v.template cast<T>()).template cast<float>().eval();
+  if (fix_left_handed && m.determinant() < 0.)
+    for (stl_triangle_vertex_indices &i : its.indices)
+      std::swap(i[0], i[1]);
+}
+
+extern void its_rotate_x(indexed_triangle_set &its, float angle);
+extern void its_rotate_y(indexed_triangle_set &its, float angle);
+extern void its_rotate_z(indexed_triangle_set &its, float angle);
+
+extern void stl_generate_shared_vertices(stl_file *stl, indexed_triangle_set &its);
+extern bool its_write_obj(const indexed_triangle_set &its, const char *file);
+extern bool its_write_off(const indexed_triangle_set &its, const char *file);
+extern bool its_write_vrml(const indexed_triangle_set &its, const char *file);
+
+extern bool stl_write_dxf(stl_file *stl, const char *file, char *label);
+inline void stl_calculate_normal(stl_normal &normal, stl_facet *facet) {
+  normal = (facet->vertex[1] - facet->vertex[0]).cross(facet->vertex[2] - facet->vertex[0]);
+}
+inline void stl_normalize_vector(stl_normal &normal) {
+  double length = normal.cast<double>().norm();
+  if (length < 0.000000000001)
+    normal = stl_normal::Zero();
+  else
+    normal *= float(1.0 / length);
+}
+extern void stl_calculate_volume(stl_file *stl);
+
+extern void stl_repair(stl_file *stl, bool fixall_flag, bool exact_flag, bool tolerance_flag, float tolerance, bool increment_flag, float increment, bool nearby_flag, int iterations, bool remove_unconnected_flag, bool fill_holes_flag, bool normal_directions_flag, bool normal_values_flag, bool reverse_all_flag, bool verbose_flag);
+
+extern void stl_allocate(stl_file *stl);
+extern void stl_read(stl_file *stl, int first_facet, bool first);
+extern void stl_facet_stats(stl_file *stl, stl_facet facet, bool &first);
+extern void stl_reallocate(stl_file *stl);
+extern void stl_add_facet(stl_file *stl, const stl_facet *new_facet);
+
+// Validate the mesh, assert on error.
+extern bool stl_validate(const stl_file *stl);
+extern bool stl_validate(const stl_file *stl, const indexed_triangle_set &its);
+
+#endif

src/admesh/stl_io.cpp

@@ -0,0 +1,251 @@
+/*  ADMesh -- process triangulated solid meshes
+ *  Copyright (C) 1995, 1996  Anthony D. Martin <amartin@engr.csulb.edu>
+ *  Copyright (C) 2013, 2014  several contributors, see AUTHORS
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Questions, comments, suggestions, etc to
+ *           https://github.com/admesh/admesh/issues
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <boost/log/trivial.hpp>
+#include <boost/nowide/cstdio.hpp>
+#include <boost/predef/other/endian.h>
+
+#include "stl.h"
+
+void stl_stats_out(stl_file *stl, FILE *file, char *input_file)
+{
+  	// This is here for Slic3r, without our config.h it won't use this part of the code anyway.
+#ifndef VERSION
+#define VERSION "unknown"
+#endif
+  	fprintf(file, "\n================= Results produced by ADMesh version " VERSION " ================\n");
+  	fprintf(file, "Input file         : %s\n", input_file);
+  	if (stl->stats.type == binary)
+    	fprintf(file, "File type          : Binary STL file\n");
+  	else
+    	fprintf(file, "File type          : ASCII STL file\n");
+  	fprintf(file, "Header             : %s\n", stl->stats.header);
+  	fprintf(file, "============== Size ==============\n");
+  	fprintf(file, "Min X = % f, Max X = % f\n", stl->stats.min(0), stl->stats.max(0));
+  	fprintf(file, "Min Y = % f, Max Y = % f\n", stl->stats.min(1), stl->stats.max(1));
+  	fprintf(file, "Min Z = % f, Max Z = % f\n", stl->stats.min(2), stl->stats.max(2));
+  	fprintf(file, "========= Facet Status ========== Original ============ Final ====\n");
+  	fprintf(file, "Number of facets                 : %5d               %5d\n", stl->stats.original_num_facets, stl->stats.number_of_facets);
+  	fprintf(file, "Facets with 1 disconnected edge  : %5d               %5d\n", 
+  		stl->stats.facets_w_1_bad_edge, stl->stats.connected_facets_2_edge - stl->stats.connected_facets_3_edge);
+  	fprintf(file, "Facets with 2 disconnected edges : %5d               %5d\n",
+    	stl->stats.facets_w_2_bad_edge, stl->stats.connected_facets_1_edge - stl->stats.connected_facets_2_edge);
+  	fprintf(file, "Facets with 3 disconnected edges : %5d               %5d\n",
+        stl->stats.facets_w_3_bad_edge, stl->stats.number_of_facets - stl->stats.connected_facets_1_edge);
+  	fprintf(file, "Total disconnected facets        : %5d               %5d\n",
+		stl->stats.facets_w_1_bad_edge + stl->stats.facets_w_2_bad_edge + stl->stats.facets_w_3_bad_edge, stl->stats.number_of_facets - stl->stats.connected_facets_3_edge);
+  	fprintf(file, "=== Processing Statistics ===     ===== Other Statistics =====\n");
+  	fprintf(file, "Number of parts       : %5d        Volume   : %f\n", stl->stats.number_of_parts, stl->stats.volume);
+  	fprintf(file, "Degenerate facets     : %5d\n", stl->stats.degenerate_facets);
+  	fprintf(file, "Edges fixed           : %5d\n", stl->stats.edges_fixed);
+  	fprintf(file, "Facets removed        : %5d\n", stl->stats.facets_removed);
+  	fprintf(file, "Facets added          : %5d\n", stl->stats.facets_added);
+  	fprintf(file, "Facets reversed       : %5d\n", stl->stats.facets_reversed);
+  	fprintf(file, "Backwards edges       : %5d\n", stl->stats.backwards_edges);
+  	fprintf(file, "Normals fixed         : %5d\n", stl->stats.normals_fixed);
+}
+
+bool stl_write_ascii(stl_file *stl, const char *file, const char *label)
+{
+	FILE *fp = boost::nowide::fopen(file, "w");
+  	if (fp == nullptr) {
+		BOOST_LOG_TRIVIAL(error) << "stl_write_ascii: Couldn't open " << file << " for writing";
+    	return false;
+  	}
+
+	fprintf(fp, "solid  %s\n", label);
+
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+		fprintf(fp, "  facet normal % .8E % .8E % .8E\n", stl->facet_start[i].normal(0), stl->facet_start[i].normal(1), stl->facet_start[i].normal(2));
+		fprintf(fp, "    outer loop\n");
+		fprintf(fp, "      vertex % .8E % .8E % .8E\n", stl->facet_start[i].vertex[0](0), stl->facet_start[i].vertex[0](1), stl->facet_start[i].vertex[0](2));
+		fprintf(fp, "      vertex % .8E % .8E % .8E\n", stl->facet_start[i].vertex[1](0), stl->facet_start[i].vertex[1](1), stl->facet_start[i].vertex[1](2));
+		fprintf(fp, "      vertex % .8E % .8E % .8E\n", stl->facet_start[i].vertex[2](0), stl->facet_start[i].vertex[2](1), stl->facet_start[i].vertex[2](2));
+		fprintf(fp, "    endloop\n");
+		fprintf(fp, "  endfacet\n");
+	}
+
+  	fprintf(fp, "endsolid  %s\n", label);
+  	fclose(fp);
+  	return true;
+}
+
+bool stl_print_neighbors(stl_file *stl, char *file)
+{
+	FILE *fp = boost::nowide::fopen(file, "w");
+	if (fp == nullptr) {
+		BOOST_LOG_TRIVIAL(error) << "stl_print_neighbors: Couldn't open " << file << " for writing";
+    	return false;
+  	}
+
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+    	fprintf(fp, "%d, %d,%d, %d,%d, %d,%d\n",
+            i,
+            stl->neighbors_start[i].neighbor[0],
+            (int)stl->neighbors_start[i].which_vertex_not[0],
+            stl->neighbors_start[i].neighbor[1],
+            (int)stl->neighbors_start[i].which_vertex_not[1],
+            stl->neighbors_start[i].neighbor[2],
+            (int)stl->neighbors_start[i].which_vertex_not[2]);
+  	}
+  	fclose(fp);
+  	return true;
+}
+
+#if BOOST_ENDIAN_BIG_BYTE
+// Swap a buffer of 32bit data from little endian to big endian and vice versa.
+void stl_internal_reverse_quads(char *buf, size_t cnt)
+{
+	for (size_t i = 0; i < cnt; i += 4) {
+		std::swap(buf[i], buf[i+3]);
+		std::swap(buf[i+1], buf[i+2]);
+	}
+}
+#endif
+
+bool stl_write_binary(stl_file *stl, const char *file, const char *label)
+{
+	FILE *fp = boost::nowide::fopen(file, "wb");
+	if (fp == nullptr) {
+		BOOST_LOG_TRIVIAL(error) << "stl_write_binary: Couldn't open " << file << " for writing";
+    	return false;
+  	}
+
+	fprintf(fp, "%s", label);
+	for (size_t i = strlen(label); i < LABEL_SIZE; ++ i)
+		putc(0, fp);
+
+#if !defined(SEEK_SET)
+	#define SEEK_SET 0
+#endif
+	fseek(fp, LABEL_SIZE, SEEK_SET);
+#if BOOST_ENDIAN_LITTLE_BYTE
+	fwrite(&stl->stats.number_of_facets, 4, 1, fp);
+	for (const stl_facet &facet : stl->facet_start)
+	  	fwrite(&facet, SIZEOF_STL_FACET, 1, fp);
+#else /* BOOST_ENDIAN_LITTLE_BYTE */
+	char buffer[50];
+	// Convert the number of facets to little endian.
+	memcpy(buffer, &stl->stats.number_of_facets, 4);
+	stl_internal_reverse_quads(buffer, 4);
+	fwrite(buffer, 4, 1, fp);
+	for (const stl_facet &facet : stl->facet_start) {
+		memcpy(buffer, &facet, 50);
+		// Convert to little endian.
+		stl_internal_reverse_quads(buffer, 48);
+		fwrite(buffer, SIZEOF_STL_FACET, 1, fp);
+	}
+#endif /* BOOST_ENDIAN_LITTLE_BYTE */
+	fclose(fp);
+	return true;
+}
+
+void stl_write_vertex(stl_file *stl, int facet, int vertex)
+{
+  	printf("  vertex %d/%d % .8E % .8E % .8E\n", vertex, facet,
+         stl->facet_start[facet].vertex[vertex](0),
+         stl->facet_start[facet].vertex[vertex](1),
+         stl->facet_start[facet].vertex[vertex](2));
+}
+
+void stl_write_facet(stl_file *stl, char *label, int facet)
+{
+	printf("facet (%d)/ %s\n", facet, label);
+	stl_write_vertex(stl, facet, 0);
+	stl_write_vertex(stl, facet, 1);
+	stl_write_vertex(stl, facet, 2);
+}
+
+void stl_write_neighbor(stl_file *stl, int facet)
+{
+	printf("Neighbors %d: %d, %d, %d ;  %d, %d, %d\n", facet,
+		stl->neighbors_start[facet].neighbor[0],
+		stl->neighbors_start[facet].neighbor[1],
+		stl->neighbors_start[facet].neighbor[2],
+		stl->neighbors_start[facet].which_vertex_not[0],
+		stl->neighbors_start[facet].which_vertex_not[1],
+		stl->neighbors_start[facet].which_vertex_not[2]);
+}
+
+bool stl_write_quad_object(stl_file *stl, char *file)
+{
+	stl_vertex connect_color = stl_vertex::Zero();
+	stl_vertex uncon_1_color = stl_vertex::Zero();
+	stl_vertex uncon_2_color = stl_vertex::Zero();
+	stl_vertex uncon_3_color = stl_vertex::Zero();
+	stl_vertex color;
+
+	FILE *fp = boost::nowide::fopen(file, "w");
+	if (fp == nullptr) {
+		BOOST_LOG_TRIVIAL(error) << "stl_write_quad_object: Couldn't open " << file << " for writing";
+		return false;
+	}
+
+  	fprintf(fp, "CQUAD\n");
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+  		switch (stl->neighbors_start[i].num_neighbors()) {
+    		case 0:
+    		default: color = uncon_3_color; break;
+    		case 1:  color = uncon_2_color; break;
+    		case 2:  color = uncon_1_color; break;
+  		case 3:  color = connect_color; break;
+	    }
+	    fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[0](0), stl->facet_start[i].vertex[0](1), stl->facet_start[i].vertex[0](2), color(0), color(1), color(2));
+    	fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[1](0), stl->facet_start[i].vertex[1](1), stl->facet_start[i].vertex[1](2), color(0), color(1), color(2));
+    	fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[2](0), stl->facet_start[i].vertex[2](1), stl->facet_start[i].vertex[2](2), color(0), color(1), color(2));
+    	fprintf(fp, "%f %f %f    %1.1f %1.1f %1.1f 1\n", stl->facet_start[i].vertex[2](0), stl->facet_start[i].vertex[2](1), stl->facet_start[i].vertex[2](2), color(0), color(1), color(2));
+  }
+  fclose(fp);
+  return true;
+}
+
+bool stl_write_dxf(stl_file *stl, const char *file, char *label) 
+{
+	FILE *fp = boost::nowide::fopen(file, "w");
+	if (fp == nullptr) {
+		BOOST_LOG_TRIVIAL(error) << "stl_write_quad_object: Couldn't open " << file << " for writing";
+    	return false;
+  	}
+
+	fprintf(fp, "999\n%s\n", label);
+	fprintf(fp, "0\nSECTION\n2\nHEADER\n0\nENDSEC\n");
+	fprintf(fp, "0\nSECTION\n2\nTABLES\n0\nTABLE\n2\nLAYER\n70\n1\n\
+	0\nLAYER\n2\n0\n70\n0\n62\n7\n6\nCONTINUOUS\n0\nENDTAB\n0\nENDSEC\n");
+	fprintf(fp, "0\nSECTION\n2\nBLOCKS\n0\nENDSEC\n");
+
+	fprintf(fp, "0\nSECTION\n2\nENTITIES\n");
+
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+		fprintf(fp, "0\n3DFACE\n8\n0\n");
+		fprintf(fp, "10\n%f\n20\n%f\n30\n%f\n", stl->facet_start[i].vertex[0](0), stl->facet_start[i].vertex[0](1), stl->facet_start[i].vertex[0](2));
+		fprintf(fp, "11\n%f\n21\n%f\n31\n%f\n", stl->facet_start[i].vertex[1](0), stl->facet_start[i].vertex[1](1), stl->facet_start[i].vertex[1](2));
+		fprintf(fp, "12\n%f\n22\n%f\n32\n%f\n", stl->facet_start[i].vertex[2](0), stl->facet_start[i].vertex[2](1), stl->facet_start[i].vertex[2](2));
+		fprintf(fp, "13\n%f\n23\n%f\n33\n%f\n", stl->facet_start[i].vertex[2](0), stl->facet_start[i].vertex[2](1), stl->facet_start[i].vertex[2](2));
+	}
+
+  	fprintf(fp, "0\nENDSEC\n0\nEOF\n");
+  	fclose(fp);
+  	return true;
+}

src/admesh/stlinit.cpp

@@ -0,0 +1,281 @@
+/*  ADMesh -- process triangulated solid meshes
+ *  Copyright (C) 1995, 1996  Anthony D. Martin <amartin@engr.csulb.edu>
+ *  Copyright (C) 2013, 2014  several contributors, see AUTHORS
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Questions, comments, suggestions, etc to
+ *           https://github.com/admesh/admesh/issues
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+
+#include <boost/log/trivial.hpp>
+#include <boost/nowide/cstdio.hpp>
+#include <boost/predef/other/endian.h>
+
+#include "stl.h"
+
+#include "libslic3r/LocalesUtils.hpp"
+
+#ifndef SEEK_SET
+#error "SEEK_SET not defined"
+#endif
+
+#if BOOST_ENDIAN_BIG_BYTE
+extern void stl_internal_reverse_quads(char *buf, size_t cnt);
+#endif /* BOOST_ENDIAN_BIG_BYTE */
+
+static FILE* stl_open_count_facets(stl_file *stl, const char *file) 
+{
+  	// Open the file in binary mode first.
+  	FILE *fp = boost::nowide::fopen(file, "rb");
+  	if (fp == nullptr) {
+		BOOST_LOG_TRIVIAL(error) << "stl_open_count_facets: Couldn't open " << file << " for reading";
+    	return nullptr;
+  	}
+  	// Find size of file.
+  	fseek(fp, 0, SEEK_END);
+  	long file_size = ftell(fp);
+
+  	// Check for binary or ASCII file.
+  	fseek(fp, HEADER_SIZE, SEEK_SET);
+	unsigned char chtest[128];
+  	if (! fread(chtest, sizeof(chtest), 1, fp)) {
+		BOOST_LOG_TRIVIAL(error) << "stl_open_count_facets: The input is an empty file: " << file;
+    	fclose(fp);
+    	return nullptr;
+  	}
+  	stl->stats.type = ascii;
+  	for (size_t s = 0; s < sizeof(chtest); s++) {
+    	if (chtest[s] > 127) {
+      		stl->stats.type = binary;
+      		break;
+    	}
+  	}
+  	rewind(fp);
+
+  	uint32_t num_facets = 0;
+
+  	// Get the header and the number of facets in the .STL file.
+  	// If the .STL file is binary, then do the following:
+  	if (stl->stats.type == binary) {
+    	// Test if the STL file has the right size.
+    	if (((file_size - HEADER_SIZE) % SIZEOF_STL_FACET != 0) || (file_size < STL_MIN_FILE_SIZE)) {
+			BOOST_LOG_TRIVIAL(error) << "stl_open_count_facets: The file " << file << " has the wrong size.";
+      		fclose(fp);
+      		return nullptr;
+    	}
+    	num_facets = (file_size - HEADER_SIZE) / SIZEOF_STL_FACET;
+
+    	// Read the header.
+    	if (fread(stl->stats.header, LABEL_SIZE, 1, fp) > 79)
+      		stl->stats.header[80] = '\0';
+
+    	// Read the int following the header.  This should contain # of facets.
+	  	uint32_t header_num_facets;
+    	bool header_num_faces_read = fread(&header_num_facets, sizeof(uint32_t), 1, fp) != 0;
+#if BOOST_ENDIAN_BIG_BYTE
+    	// Convert from little endian to big endian.
+    	stl_internal_reverse_quads((char*)&header_num_facets, 4);
+#endif /* BOOST_ENDIAN_BIG_BYTE */
+    	if (! header_num_faces_read || num_facets != header_num_facets)
+			BOOST_LOG_TRIVIAL(info) << "stl_open_count_facets: Warning: File size doesn't match number of facets in the header: " << file;
+  	}
+  	// Otherwise, if the .STL file is ASCII, then do the following:
+  	else
+  	{
+    	// Reopen the file in text mode (for getting correct newlines on Windows)
+    	// fix to silence a warning about unused return value.
+    	// obviously if it fails we have problems....
+    	fp = boost::nowide::freopen(file, "r", fp);
+
+		// do another null check to be safe
+    	if (fp == nullptr) {
+			BOOST_LOG_TRIVIAL(error) << "stl_open_count_facets: Couldn't open " << file << " for reading";
+      		fclose(fp);
+      		return nullptr;
+    	}
+    
+    	// Find the number of facets.
+		char linebuf[100];
+		int num_lines = 1;
+		while (fgets(linebuf, 100, fp) != nullptr) {
+		    // Don't count short lines.
+		    if (strlen(linebuf) <= 4)
+		    	continue;
+		    // Skip solid/endsolid lines as broken STL file generators may put several of them.
+		    if (strncmp(linebuf, "solid", 5) == 0 || strncmp(linebuf, "endsolid", 8) == 0)
+		    	continue;
+		    ++ num_lines;
+		}
+
+    	rewind(fp);
+    
+    	// Get the header.
+		int i = 0;
+    	for (; i < 80 && (stl->stats.header[i] = getc(fp)) != '\n'; ++ i) ;
+    	stl->stats.header[i] = '\0'; // Lose the '\n'
+    	stl->stats.header[80] = '\0';
+
+    	num_facets = num_lines / ASCII_LINES_PER_FACET;
+  	}
+
+  	stl->stats.number_of_facets += num_facets;
+  	stl->stats.original_num_facets = stl->stats.number_of_facets;
+  	return fp;
+}
+
+/* Reads the contents of the file pointed to by fp into the stl structure,
+   starting at facet first_facet.  The second argument says if it's our first
+   time running this for the stl and therefore we should reset our max and min stats. */
+static bool stl_read(stl_file *stl, FILE *fp, int first_facet, bool first)
+{
+	if (stl->stats.type == binary)
+    	fseek(fp, HEADER_SIZE, SEEK_SET);
+  	else
+    	rewind(fp);
+
+  	char normal_buf[3][32];
+  	for (uint32_t i = first_facet; i < stl->stats.number_of_facets; ++ i) {
+  	  	stl_facet facet;
+
+    	if (stl->stats.type == binary) {
+      		// Read a single facet from a binary .STL file. We assume little-endian architecture!
+      		if (fread(&facet, 1, SIZEOF_STL_FACET, fp) != SIZEOF_STL_FACET)
+      			return false;
+#if BOOST_ENDIAN_BIG_BYTE
+      		// Convert the loaded little endian data to big endian.
+      		stl_internal_reverse_quads((char*)&facet, 48);
+#endif /* BOOST_ENDIAN_BIG_BYTE */
+    	} else {
+			// Read a single facet from an ASCII .STL file
+			// skip solid/endsolid
+			// (in this order, otherwise it won't work when they are paired in the middle of a file)
+			fscanf(fp, " endsolid%*[^\n]\n");
+			fscanf(fp, " solid%*[^\n]\n");  // name might contain spaces so %*s doesn't work and it also can be empty (just "solid")
+			// Leading space in the fscanf format skips all leading white spaces including numerous new lines and tabs.
+			int res_normal     = fscanf(fp, " facet normal %31s %31s %31s", normal_buf[0], normal_buf[1], normal_buf[2]);
+			assert(res_normal == 3);
+			int res_outer_loop = fscanf(fp, " outer loop");
+			assert(res_outer_loop == 0);
+			int res_vertex1    = fscanf(fp, " vertex %f %f %f", &facet.vertex[0](0), &facet.vertex[0](1), &facet.vertex[0](2));
+			assert(res_vertex1 == 3);
+			int res_vertex2    = fscanf(fp, " vertex %f %f %f", &facet.vertex[1](0), &facet.vertex[1](1), &facet.vertex[1](2));
+			assert(res_vertex2 == 3);
+			// Trailing whitespace is there to eat all whitespaces and empty lines up to the next non-whitespace.
+			int res_vertex3    = fscanf(fp, " vertex %f %f %f ", &facet.vertex[2](0), &facet.vertex[2](1), &facet.vertex[2](2));
+			assert(res_vertex3 == 3);
+			// Some G-code generators tend to produce text after "endloop" and "endfacet". Just ignore it.
+			char buf[2048];
+			fgets(buf, 2047, fp);
+			bool endloop_ok = strncmp(buf, "endloop", 7) == 0 && (buf[7] == '\r' || buf[7] == '\n' || buf[7] == ' ' || buf[7] == '\t');
+			assert(endloop_ok);
+			// Skip the trailing whitespaces and empty lines.
+			fscanf(fp, " ");
+			fgets(buf, 2047, fp);
+			bool endfacet_ok = strncmp(buf, "endfacet", 8) == 0 && (buf[8] == '\r' || buf[8] == '\n' || buf[8] == ' ' || buf[8] == '\t');
+			assert(endfacet_ok);
+			if (res_normal != 3 || res_outer_loop != 0 || res_vertex1 != 3 || res_vertex2 != 3 || res_vertex3 != 3 || ! endloop_ok || ! endfacet_ok) {
+				BOOST_LOG_TRIVIAL(error) << "Something is syntactically very wrong with this ASCII STL! ";
+				return false;
+			}
+
+			// The facet normal has been parsed as a single string as to workaround for not a numbers in the normal definition.
+			if (sscanf(normal_buf[0], "%f", &facet.normal(0)) != 1 ||
+			    sscanf(normal_buf[1], "%f", &facet.normal(1)) != 1 ||
+			    sscanf(normal_buf[2], "%f", &facet.normal(2)) != 1) {
+			    // Normal was mangled. Maybe denormals or "not a number" were stored?
+			  	// Just reset the normal and silently ignore it.
+			  	memset(&facet.normal, 0, sizeof(facet.normal));
+			}
+		}
+
+#if 0
+		// Report close to zero vertex coordinates. Due to the nature of the floating point numbers,
+		// close to zero values may be represented with singificantly higher precision than the rest of the vertices.
+		// It may be worth to round these numbers to zero during loading to reduce the number of errors reported
+		// during the STL import.
+		for (size_t j = 0; j < 3; ++ j) {
+		if (facet.vertex[j](0) > -1e-12f && facet.vertex[j](0) < 1e-12f)
+		    printf("stl_read: facet %d(0) = %e\r\n", j, facet.vertex[j](0));
+		if (facet.vertex[j](1) > -1e-12f && facet.vertex[j](1) < 1e-12f)
+		    printf("stl_read: facet %d(1) = %e\r\n", j, facet.vertex[j](1));
+		if (facet.vertex[j](2) > -1e-12f && facet.vertex[j](2) < 1e-12f)
+		    printf("stl_read: facet %d(2) = %e\r\n", j, facet.vertex[j](2));
+		}
+#endif
+
+		// Write the facet into memory.
+		stl->facet_start[i] = facet;
+		stl_facet_stats(stl, facet, first);
+  	}
+  
+  	stl->stats.size = stl->stats.max - stl->stats.min;
+  	stl->stats.bounding_diameter = stl->stats.size.norm();
+  	return true;
+}
+
+bool stl_open(stl_file *stl, const char *file)
+{
+    Slic3r::CNumericLocalesSetter locales_setter;
+	stl->clear();
+	FILE *fp = stl_open_count_facets(stl, file);
+	if (fp == nullptr)
+		return false;
+	stl_allocate(stl);
+	bool result = stl_read(stl, fp, 0, true);
+  	fclose(fp);
+  	return result;
+}
+
+void stl_allocate(stl_file *stl) 
+{
+  	//  Allocate memory for the entire .STL file.
+  	stl->facet_start.assign(stl->stats.number_of_facets, stl_facet());
+  	// Allocate memory for the neighbors list.
+  	stl->neighbors_start.assign(stl->stats.number_of_facets, stl_neighbors());
+}
+
+void stl_reallocate(stl_file *stl) 
+{
+	stl->facet_start.resize(stl->stats.number_of_facets);
+	stl->neighbors_start.resize(stl->stats.number_of_facets);
+}
+
+void stl_facet_stats(stl_file *stl, stl_facet facet, bool &first)
+{
+	// While we are going through all of the facets, let's find the
+	// maximum and minimum values for x, y, and z
+
+	if (first) {
+		// Initialize the max and min values the first time through
+		stl->stats.min = facet.vertex[0];
+		stl->stats.max = facet.vertex[0];
+		stl_vertex diff = (facet.vertex[1] - facet.vertex[0]).cwiseAbs();
+		stl->stats.shortest_edge = std::max(diff(0), std::max(diff(1), diff(2)));
+		first = false;
+	}
+
+	// Now find the max and min values.
+	for (size_t i = 0; i < 3; ++ i) {
+		stl->stats.min = stl->stats.min.cwiseMin(facet.vertex[i]);
+		stl->stats.max = stl->stats.max.cwiseMax(facet.vertex[i]);
+	}
+}

src/admesh/util.cpp

@@ -0,0 +1,399 @@
+/*  ADMesh -- process triangulated solid meshes
+ *  Copyright (C) 1995, 1996  Anthony D. Martin <amartin@engr.csulb.edu>
+ *  Copyright (C) 2013, 2014  several contributors, see AUTHORS
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Questions, comments, suggestions, etc to
+ *           https://github.com/admesh/admesh/issues
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include <boost/log/trivial.hpp>
+
+#include "stl.h"
+
+void stl_verify_neighbors(stl_file *stl)
+{
+	stl->stats.backwards_edges = 0;
+
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+		for (int j = 0; j < 3; ++ j) {
+			struct stl_edge {
+				stl_vertex p1;
+				stl_vertex p2;
+				int        facet_number;
+			};
+			stl_edge edge_a;
+			edge_a.p1 = stl->facet_start[i].vertex[j];
+			edge_a.p2 = stl->facet_start[i].vertex[(j + 1) % 3];
+			int neighbor = stl->neighbors_start[i].neighbor[j];
+			if (neighbor == -1)
+				continue; // this edge has no neighbor... Continue.
+			int vnot = stl->neighbors_start[i].which_vertex_not[j];
+			stl_edge edge_b;
+			if (vnot < 3) {
+				edge_b.p1 = stl->facet_start[neighbor].vertex[(vnot + 2) % 3];
+				edge_b.p2 = stl->facet_start[neighbor].vertex[(vnot + 1) % 3];
+			} else {
+				stl->stats.backwards_edges += 1;
+				edge_b.p1 = stl->facet_start[neighbor].vertex[(vnot + 1) % 3];
+				edge_b.p2 = stl->facet_start[neighbor].vertex[(vnot + 2) % 3];
+			}
+			if (edge_a.p1 != edge_b.p1 || edge_a.p2 != edge_b.p2) {
+				// These edges should match but they don't.  Print results.
+				BOOST_LOG_TRIVIAL(info) << "edge " << j << " of facet " << i << " doesn't match edge " << (vnot + 1) << " of facet " << neighbor;
+				stl_write_facet(stl, (char*)"first facet", i);
+				stl_write_facet(stl, (char*)"second facet", neighbor);
+			}
+		}
+	}
+}
+
+void stl_translate(stl_file *stl, float x, float y, float z)
+{
+	stl_vertex new_min(x, y, z);
+	stl_vertex shift = new_min - stl->stats.min;
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
+		for (int j = 0; j < 3; ++ j)
+	  		stl->facet_start[i].vertex[j] += shift;
+	stl->stats.min = new_min;
+	stl->stats.max += shift;
+}
+
+/* Translates the stl by x,y,z, relatively from wherever it is currently */
+void stl_translate_relative(stl_file *stl, float x, float y, float z)
+{
+	stl_vertex shift(x, y, z);
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
+		for (int j = 0; j < 3; ++ j)
+	  		stl->facet_start[i].vertex[j] += shift;
+	stl->stats.min += shift;
+	stl->stats.max += shift;
+}
+
+void stl_scale_versor(stl_file *stl, const stl_vertex &versor)
+{
+	// Scale extents.
+	auto s = versor.array();
+	stl->stats.min.array() *= s;
+	stl->stats.max.array() *= s;
+	// Scale size.
+	stl->stats.size.array() *= s;
+	// Scale volume.
+	if (stl->stats.volume > 0.0)
+		stl->stats.volume *= versor(0) * versor(1) * versor(2);
+	// Scale the mesh.
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
+		for (int j = 0; j < 3; ++ j)
+	  		stl->facet_start[i].vertex[j].array() *= s;
+}
+
+static void calculate_normals(stl_file *stl) 
+{
+	stl_normal normal;
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+		stl_calculate_normal(normal, &stl->facet_start[i]);
+		stl_normalize_vector(normal);
+		stl->facet_start[i].normal = normal;
+	}
+}
+
+static inline void rotate_point_2d(float &x, float &y, const double c, const double s)
+{
+	double xold = x;
+	double yold = y;
+	x = float(c * xold - s * yold);
+	y = float(s * xold + c * yold);
+}
+
+void stl_rotate_x(stl_file *stl, float angle)
+{
+	double radian_angle = (angle / 180.0) * M_PI;
+	double c = cos(radian_angle);
+	double s = sin(radian_angle);
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
+    	for (int j = 0; j < 3; ++ j)
+      		rotate_point_2d(stl->facet_start[i].vertex[j](1), stl->facet_start[i].vertex[j](2), c, s);
+  	stl_get_size(stl);
+  	calculate_normals(stl);
+}
+
+void stl_rotate_y(stl_file *stl, float angle)
+{
+	double radian_angle = (angle / 180.0) * M_PI;
+	double c = cos(radian_angle);
+	double s = sin(radian_angle);
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
+    	for (int j = 0; j < 3; ++ j)
+			rotate_point_2d(stl->facet_start[i].vertex[j](2), stl->facet_start[i].vertex[j](0), c, s);
+  	stl_get_size(stl);
+  	calculate_normals(stl);
+}
+
+void stl_rotate_z(stl_file *stl, float angle)
+{
+	double radian_angle = (angle / 180.0) * M_PI;
+	double c = cos(radian_angle);
+	double s = sin(radian_angle);
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
+    	for (int j = 0; j < 3; ++ j)
+      		rotate_point_2d(stl->facet_start[i].vertex[j](0), stl->facet_start[i].vertex[j](1), c, s);
+  	stl_get_size(stl);
+  	calculate_normals(stl);
+}
+
+void its_rotate_x(indexed_triangle_set &its, float angle)
+{
+	double radian_angle = (angle / 180.0) * M_PI;
+	double c = cos(radian_angle);
+	double s = sin(radian_angle);
+	for (stl_vertex &v : its.vertices)
+		rotate_point_2d(v(1), v(2), c, s);
+}
+
+void its_rotate_y(indexed_triangle_set& its, float angle)
+{
+	double radian_angle = (angle / 180.0) * M_PI;
+	double c = cos(radian_angle);
+	double s = sin(radian_angle);
+	for (stl_vertex& v : its.vertices)
+		rotate_point_2d(v(2), v(0), c, s);
+}
+
+void its_rotate_z(indexed_triangle_set& its, float angle)
+{
+	double radian_angle = (angle / 180.0) * M_PI;
+	double c = cos(radian_angle);
+	double s = sin(radian_angle);
+	for (stl_vertex& v : its.vertices)
+		rotate_point_2d(v(0), v(1), c, s);
+}
+
+void stl_get_size(stl_file *stl)
+{
+  	if (stl->stats.number_of_facets == 0)
+  		return;
+  	stl->stats.min = stl->facet_start[0].vertex[0];
+  	stl->stats.max = stl->stats.min;
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+  		const stl_facet &face = stl->facet_start[i];
+    	for (int j = 0; j < 3; ++ j) {
+      		stl->stats.min = stl->stats.min.cwiseMin(face.vertex[j]);
+      		stl->stats.max = stl->stats.max.cwiseMax(face.vertex[j]);
+    	}
+  	}
+  	stl->stats.size = stl->stats.max - stl->stats.min;
+  	stl->stats.bounding_diameter = stl->stats.size.norm();
+}
+
+void stl_mirror_xy(stl_file *stl)
+{
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
+    	for (int j = 0; j < 3; ++ j)
+      		stl->facet_start[i].vertex[j](2) *= -1.0;
+	float temp_size = stl->stats.min(2);
+	stl->stats.min(2) = stl->stats.max(2);
+	stl->stats.max(2) = temp_size;
+	stl->stats.min(2) *= -1.0;
+	stl->stats.max(2) *= -1.0;
+	stl_reverse_all_facets(stl);
+	stl->stats.facets_reversed -= stl->stats.number_of_facets;  /* for not altering stats */
+}
+
+void stl_mirror_yz(stl_file *stl)
+{
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
+    	for (int j = 0; j < 3; j++)
+      		stl->facet_start[i].vertex[j](0) *= -1.0;
+	float temp_size = stl->stats.min(0);
+	stl->stats.min(0) = stl->stats.max(0);
+	stl->stats.max(0) = temp_size;
+	stl->stats.min(0) *= -1.0;
+	stl->stats.max(0) *= -1.0;
+	stl_reverse_all_facets(stl);
+	stl->stats.facets_reversed -= stl->stats.number_of_facets;  /* for not altering stats */
+}
+
+void stl_mirror_xz(stl_file *stl)
+{
+	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i)
+		for (int j = 0; j < 3; ++ j)
+			stl->facet_start[i].vertex[j](1) *= -1.0;
+	float temp_size = stl->stats.min(1);
+	stl->stats.min(1) = stl->stats.max(1);
+	stl->stats.max(1) = temp_size;
+	stl->stats.min(1) *= -1.0;
+	stl->stats.max(1) *= -1.0;
+	stl_reverse_all_facets(stl);
+	stl->stats.facets_reversed -= stl->stats.number_of_facets;  // for not altering stats
+}
+
+float get_area(stl_facet *facet)
+{
+	/* cast to double before calculating cross product because large coordinates
+	 can result in overflowing product
+	(bad area is responsible for bad volume and bad facets reversal) */
+	double cross[3][3];
+	for (int i = 0; i < 3; i++) {
+		cross[i][0]=(((double)facet->vertex[i](1) * (double)facet->vertex[(i + 1) % 3](2)) -
+	             	 ((double)facet->vertex[i](2) * (double)facet->vertex[(i + 1) % 3](1)));
+		cross[i][1]=(((double)facet->vertex[i](2) * (double)facet->vertex[(i + 1) % 3](0)) -
+	             	 ((double)facet->vertex[i](0) * (double)facet->vertex[(i + 1) % 3](2)));
+		cross[i][2]=(((double)facet->vertex[i](0) * (double)facet->vertex[(i + 1) % 3](1)) -
+	             	 ((double)facet->vertex[i](1) * (double)facet->vertex[(i + 1) % 3](0)));
+	}
+
+	stl_normal sum;
+	sum(0) = cross[0][0] + cross[1][0] + cross[2][0];
+	sum(1) = cross[0][1] + cross[1][1] + cross[2][1];
+	sum(2) = cross[0][2] + cross[1][2] + cross[2][2];
+
+	// This should already be done.  But just in case, let's do it again.
+	//FIXME this is questionable. the "sum" normal should be accurate, while the normal "n" may be calculated with a low accuracy.
+	stl_normal n;
+	stl_calculate_normal(n, facet);
+	stl_normalize_vector(n);
+	return 0.5f * n.dot(sum);
+}
+
+static float get_volume(stl_file *stl)
+{
+  	// Choose a point, any point as the reference.
+  	stl_vertex p0 = stl->facet_start[0].vertex[0];
+  	float volume = 0.f;
+  	for (uint32_t i = 0; i < stl->stats.number_of_facets; ++ i) {
+    	// Do dot product to get distance from point to plane.
+    	float height = stl->facet_start[i].normal.dot(stl->facet_start[i].vertex[0] - p0);
+    	float area   = get_area(&stl->facet_start[i]);
+    	volume += (area * height) / 3.0f;
+  	}
+  	return volume;
+}
+
+void stl_calculate_volume(stl_file *stl)
+{
+  	stl->stats.volume = get_volume(stl);
+  	if (stl->stats.volume < 0.0) {
+    	stl_reverse_all_facets(stl);
+    	stl->stats.volume = -stl->stats.volume;
+  	}
+}
+
+void stl_repair(
+	stl_file *stl,
+	bool fixall_flag,
+	bool exact_flag,
+	bool tolerance_flag,
+	float tolerance,
+	bool increment_flag,
+	float increment,
+	bool nearby_flag,
+	int iterations,
+	bool remove_unconnected_flag,
+	bool fill_holes_flag,
+	bool normal_directions_flag,
+	bool normal_values_flag,
+	bool reverse_all_flag,
+	bool verbose_flag)
+{
+	if (exact_flag || fixall_flag || nearby_flag || remove_unconnected_flag || fill_holes_flag || normal_directions_flag) {
+		if (verbose_flag)
+		  	printf("Checking exact...\n");
+		exact_flag = true;
+		stl_check_facets_exact(stl);
+		stl->stats.facets_w_1_bad_edge = (stl->stats.connected_facets_2_edge - stl->stats.connected_facets_3_edge);
+		stl->stats.facets_w_2_bad_edge = (stl->stats.connected_facets_1_edge - stl->stats.connected_facets_2_edge);
+		stl->stats.facets_w_3_bad_edge = (stl->stats.number_of_facets - stl->stats.connected_facets_1_edge);
+	}
+
+  	if (nearby_flag || fixall_flag) {
+    	if (! tolerance_flag)
+      		tolerance = stl->stats.shortest_edge;
+ 	   	if (! increment_flag)
+      		increment = stl->stats.bounding_diameter / 10000.0;
+    }
+
+	if (stl->stats.connected_facets_3_edge < int(stl->stats.number_of_facets)) {
+	  	int last_edges_fixed = 0;
+	  	for (int i = 0; i < iterations; ++ i) {
+	    	if (stl->stats.connected_facets_3_edge < int(stl->stats.number_of_facets)) {
+	      		if (verbose_flag)
+	        		printf("Checking nearby. Tolerance= %f Iteration=%d of %d...", tolerance, i + 1, iterations);
+	      		stl_check_facets_nearby(stl, tolerance);
+	      		if (verbose_flag)
+	        		printf("  Fixed %d edges.\n", stl->stats.edges_fixed - last_edges_fixed);
+	      		last_edges_fixed = stl->stats.edges_fixed;
+	      		tolerance += increment;
+	    	} else {
+	    		if (verbose_flag)
+	        		printf("All facets connected.  No further nearby check necessary.\n");
+		      	break;
+		    }
+	  	}
+	} else if (verbose_flag)
+	    printf("All facets connected.  No nearby check necessary.\n");
+
+	if (remove_unconnected_flag || fixall_flag || fill_holes_flag) {
+		if (stl->stats.connected_facets_3_edge < int(stl->stats.number_of_facets)) {
+	  		if (verbose_flag)
+	    		printf("Removing unconnected facets...\n");
+	  		stl_remove_unconnected_facets(stl);
+		} else if (verbose_flag)
+	    	printf("No unconnected need to be removed.\n");
+	}
+
+	if (fill_holes_flag || fixall_flag) {
+		if (stl->stats.connected_facets_3_edge < int(stl->stats.number_of_facets)) {
+	  		if (verbose_flag)
+	    		printf("Filling holes...\n");
+	  		stl_fill_holes(stl);
+		} else if (verbose_flag)
+	    	printf("No holes need to be filled.\n");
+	}
+
+	if (reverse_all_flag) {
+		if (verbose_flag)
+	  		printf("Reversing all facets...\n");
+		stl_reverse_all_facets(stl);
+	}
+
+	if (normal_directions_flag || fixall_flag) {
+		if (verbose_flag)
+	  		printf("Checking normal directions...\n");
+		stl_fix_normal_directions(stl);
+	}
+
+	if (normal_values_flag || fixall_flag) {
+		if (verbose_flag)
+	  		printf("Checking normal values...\n");
+		stl_fix_normal_values(stl);
+	}
+
+  	// Always calculate the volume.  It shouldn't take too long.
+	if (verbose_flag)
+		printf("Calculating volume...\n");
+	stl_calculate_volume(stl);
+
+	if (exact_flag) {
+		if (verbose_flag)
+	  		printf("Verifying neighbors...\n");
+		stl_verify_neighbors(stl);
+	}
+}

src/agg/AUTHORS

@@ -0,0 +1,2 @@
+Anti-Grain Geometry - Version 2.4
+Copyright (C) 2002-2005 Maxim Shemanarev (McSeem) 

src/agg/VERSION

@@ -0,0 +1,2 @@
+2.4
+svn revision 128

src/agg/agg_basics.h

@@ -0,0 +1,574 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_BASICS_INCLUDED
+#define AGG_BASICS_INCLUDED
+
+#include <cmath>
+#include "agg_config.h"
+
+//---------------------------------------------------------AGG_CUSTOM_ALLOCATOR
+#ifdef AGG_CUSTOM_ALLOCATOR
+#include "agg_allocator.h"
+#else
+namespace agg
+{
+    // The policy of all AGG containers and memory allocation strategy 
+    // in general is that no allocated data requires explicit construction.
+    // It means that the allocator can be really simple; you can even
+    // replace new/delete to malloc/free. The constructors and destructors 
+    // won't be called in this case, however everything will remain working. 
+    // The second argument of deallocate() is the size of the allocated 
+    // block. You can use this information if you wish.
+    //------------------------------------------------------------pod_allocator
+    template<class T> struct pod_allocator
+    {
+        static T*   allocate(unsigned num)       { return new T [num]; }
+        static void deallocate(T* ptr, unsigned) { delete [] ptr;      }
+    };
+
+    // Single object allocator. It's also can be replaced with your custom
+    // allocator. The difference is that it can only allocate a single 
+    // object and the constructor and destructor must be called. 
+    // In AGG there is no need to allocate an array of objects with
+    // calling their constructors (only single ones). So that, if you
+    // replace these new/delete to malloc/free make sure that the in-place
+    // new is called and take care of calling the destructor too.
+    //------------------------------------------------------------obj_allocator
+    template<class T> struct obj_allocator
+    {
+        static T*   allocate()         { return new T; }
+        static void deallocate(T* ptr) { delete ptr;   }
+    };
+}
+#endif
+
+
+//-------------------------------------------------------- Default basic types
+//
+// If the compiler has different capacity of the basic types you can redefine
+// them via the compiler command line or by generating agg_config.h that is
+// empty by default.
+//
+#ifndef AGG_INT8
+#define AGG_INT8 signed char
+#endif
+
+#ifndef AGG_INT8U
+#define AGG_INT8U unsigned char
+#endif
+
+#ifndef AGG_INT16
+#define AGG_INT16 short
+#endif
+
+#ifndef AGG_INT16U
+#define AGG_INT16U unsigned short
+#endif
+
+#ifndef AGG_INT32
+#define AGG_INT32 int
+#endif
+
+#ifndef AGG_INT32U
+#define AGG_INT32U unsigned
+#endif
+
+#ifndef AGG_INT64
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define AGG_INT64 signed __int64
+#else
+#define AGG_INT64 signed long long
+#endif
+#endif
+
+#ifndef AGG_INT64U
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define AGG_INT64U unsigned __int64
+#else
+#define AGG_INT64U unsigned long long
+#endif
+#endif
+
+//------------------------------------------------ Some fixes for MS Visual C++
+#if defined(_MSC_VER)
+#pragma warning(disable:4786) // Identifier was truncated...
+#endif
+
+#if defined(_MSC_VER)
+#define AGG_INLINE __forceinline
+#else
+#define AGG_INLINE inline
+#endif
+
+namespace agg
+{
+    //-------------------------------------------------------------------------
+    typedef AGG_INT8   int8;         //----int8
+    typedef AGG_INT8U  int8u;        //----int8u
+    typedef AGG_INT16  int16;        //----int16
+    typedef AGG_INT16U int16u;       //----int16u
+    typedef AGG_INT32  int32;        //----int32
+    typedef AGG_INT32U int32u;       //----int32u
+    typedef AGG_INT64  int64;        //----int64
+    typedef AGG_INT64U int64u;       //----int64u
+
+#if defined(AGG_FISTP)
+#pragma warning(push)
+#pragma warning(disable : 4035) //Disable warning "no return value"
+    AGG_INLINE int iround(double v)              //-------iround
+    {
+        int t;
+        __asm fld   qword ptr [v]
+        __asm fistp dword ptr [t]
+        __asm mov eax, dword ptr [t]
+    }
+    AGG_INLINE unsigned uround(double v)         //-------uround
+    {
+        unsigned t;
+        __asm fld   qword ptr [v]
+        __asm fistp dword ptr [t]
+        __asm mov eax, dword ptr [t]
+    }
+#pragma warning(pop)
+    AGG_INLINE int ifloor(double v)
+    {
+        return int(floor(v));
+    }
+    AGG_INLINE unsigned ufloor(double v)         //-------ufloor
+    {
+        return unsigned(floor(v));
+    }
+    AGG_INLINE int iceil(double v)
+    {
+        return int(ceil(v));
+    }
+    AGG_INLINE unsigned uceil(double v)          //--------uceil
+    {
+        return unsigned(ceil(v));
+    }
+#elif defined(AGG_QIFIST)
+    AGG_INLINE int iround(double v)
+    {
+        return int(v);
+    }
+    AGG_INLINE int uround(double v)
+    {
+        return unsigned(v);
+    }
+    AGG_INLINE int ifloor(double v)
+    {
+        return int(floor(v));
+    }
+    AGG_INLINE unsigned ufloor(double v)
+    {
+        return unsigned(floor(v));
+    }
+    AGG_INLINE int iceil(double v)
+    {
+        return int(ceil(v));
+    }
+    AGG_INLINE unsigned uceil(double v)
+    {
+        return unsigned(ceil(v));
+    }
+#else
+    AGG_INLINE int iround(double v)
+    {
+        return int((v < 0.0) ? v - 0.5 : v + 0.5);
+    }
+    AGG_INLINE int uround(double v)
+    {
+        return unsigned(v + 0.5);
+    }
+    AGG_INLINE int ifloor(double v)
+    {
+        int i = int(v);
+        return i - (i > v);
+    }
+    AGG_INLINE unsigned ufloor(double v)
+    {
+        return unsigned(v);
+    }
+    AGG_INLINE int iceil(double v)
+    {
+        return int(ceil(v));
+    }
+    AGG_INLINE unsigned uceil(double v)
+    {
+        return unsigned(ceil(v));
+    }
+#endif
+
+    //---------------------------------------------------------------saturation
+    template<int Limit> struct saturation
+    {
+        AGG_INLINE static int iround(double v)
+        {
+            if(v < double(-Limit)) return -Limit;
+            if(v > double( Limit)) return  Limit;
+            return agg::iround(v);
+        }
+    };
+
+    //------------------------------------------------------------------mul_one
+    template<unsigned Shift> struct mul_one
+    {
+        AGG_INLINE static unsigned mul(unsigned a, unsigned b)
+        {
+            unsigned q = a * b + (1 << (Shift-1));
+            return (q + (q >> Shift)) >> Shift;
+        }
+    };
+
+    //-------------------------------------------------------------------------
+    typedef unsigned char cover_type;    //----cover_type
+    enum cover_scale_e
+    {
+        cover_shift = 8,                 //----cover_shift
+        cover_size  = 1 << cover_shift,  //----cover_size 
+        cover_mask  = cover_size - 1,    //----cover_mask 
+        cover_none  = 0,                 //----cover_none 
+        cover_full  = cover_mask         //----cover_full 
+    };
+
+    //----------------------------------------------------poly_subpixel_scale_e
+    // These constants determine the subpixel accuracy, to be more precise, 
+    // the number of bits of the fractional part of the coordinates. 
+    // The possible coordinate capacity in bits can be calculated by formula:
+    // sizeof(int) * 8 - poly_subpixel_shift, i.e, for 32-bit integers and
+    // 8-bits fractional part the capacity is 24 bits.
+    enum poly_subpixel_scale_e
+    {
+        poly_subpixel_shift = 8,                      //----poly_subpixel_shift
+        poly_subpixel_scale = 1<<poly_subpixel_shift, //----poly_subpixel_scale 
+        poly_subpixel_mask  = poly_subpixel_scale-1   //----poly_subpixel_mask 
+    };
+
+    //----------------------------------------------------------filling_rule_e
+    enum filling_rule_e
+    {
+        fill_non_zero,
+        fill_even_odd
+    };
+
+    //-----------------------------------------------------------------------pi
+    const double pi = 3.14159265358979323846;
+
+    //------------------------------------------------------------------deg2rad
+    inline double deg2rad(double deg)
+    {
+        return deg * pi / 180.0;
+    }
+
+    //------------------------------------------------------------------rad2deg
+    inline double rad2deg(double rad)
+    {
+        return rad * 180.0 / pi;
+    }
+ 
+    //----------------------------------------------------------------rect_base
+    template<class T> struct rect_base
+    {
+        typedef T            value_type;
+        typedef rect_base<T> self_type;
+        T x1, y1, x2, y2;
+
+        rect_base() {}
+        rect_base(T x1_, T y1_, T x2_, T y2_) :
+            x1(x1_), y1(y1_), x2(x2_), y2(y2_) {}
+
+        void init(T x1_, T y1_, T x2_, T y2_) 
+        {
+            x1 = x1_; y1 = y1_; x2 = x2_; y2 = y2_; 
+        }
+
+        const self_type& normalize()
+        {
+            T t;
+            if(x1 > x2) { t = x1; x1 = x2; x2 = t; }
+            if(y1 > y2) { t = y1; y1 = y2; y2 = t; }
+            return *this;
+        }
+
+        bool clip(const self_type& r)
+        {
+            if(x2 > r.x2) x2 = r.x2;
+            if(y2 > r.y2) y2 = r.y2;
+            if(x1 < r.x1) x1 = r.x1;
+            if(y1 < r.y1) y1 = r.y1;
+            return x1 <= x2 && y1 <= y2;
+        }
+
+        bool is_valid() const
+        {
+            return x1 <= x2 && y1 <= y2;
+        }
+
+        bool hit_test(T x, T y) const
+        {
+            return (x >= x1 && x <= x2 && y >= y1 && y <= y2);
+        }
+        
+        bool overlaps(const self_type& r) const
+        {
+            return !(r.x1 > x2 || r.x2 < x1
+                  || r.y1 > y2 || r.y2 < y1);
+        }
+    };
+
+    //-----------------------------------------------------intersect_rectangles
+    template<class Rect> 
+    inline Rect intersect_rectangles(const Rect& r1, const Rect& r2)
+    {
+        Rect r = r1;
+
+        // First process x2,y2 because the other order 
+        // results in Internal Compiler Error under 
+        // Microsoft Visual C++ .NET 2003 69462-335-0000007-18038 in 
+        // case of "Maximize Speed" optimization option.
+        //-----------------
+        if(r.x2 > r2.x2) r.x2 = r2.x2; 
+        if(r.y2 > r2.y2) r.y2 = r2.y2;
+        if(r.x1 < r2.x1) r.x1 = r2.x1;
+        if(r.y1 < r2.y1) r.y1 = r2.y1;
+        return r;
+    }
+
+
+    //---------------------------------------------------------unite_rectangles
+    template<class Rect> 
+    inline Rect unite_rectangles(const Rect& r1, const Rect& r2)
+    {
+        Rect r = r1;
+        if(r.x2 < r2.x2) r.x2 = r2.x2;
+        if(r.y2 < r2.y2) r.y2 = r2.y2;
+        if(r.x1 > r2.x1) r.x1 = r2.x1;
+        if(r.y1 > r2.y1) r.y1 = r2.y1;
+        return r;
+    }
+
+    typedef rect_base<int>    rect_i; //----rect_i
+    typedef rect_base<float>  rect_f; //----rect_f
+    typedef rect_base<double> rect_d; //----rect_d
+
+    //---------------------------------------------------------path_commands_e
+    enum path_commands_e
+    {
+        path_cmd_stop     = 0,        //----path_cmd_stop    
+        path_cmd_move_to  = 1,        //----path_cmd_move_to 
+        path_cmd_line_to  = 2,        //----path_cmd_line_to 
+        path_cmd_curve3   = 3,        //----path_cmd_curve3  
+        path_cmd_curve4   = 4,        //----path_cmd_curve4  
+        path_cmd_curveN   = 5,        //----path_cmd_curveN
+        path_cmd_catrom   = 6,        //----path_cmd_catrom
+        path_cmd_ubspline = 7,        //----path_cmd_ubspline
+        path_cmd_end_poly = 0x0F,     //----path_cmd_end_poly
+        path_cmd_mask     = 0x0F      //----path_cmd_mask    
+    };
+
+    //------------------------------------------------------------path_flags_e
+    enum path_flags_e
+    {
+        path_flags_none  = 0,         //----path_flags_none 
+        path_flags_ccw   = 0x10,      //----path_flags_ccw  
+        path_flags_cw    = 0x20,      //----path_flags_cw   
+        path_flags_close = 0x40,      //----path_flags_close
+        path_flags_mask  = 0xF0       //----path_flags_mask 
+    };
+
+    //---------------------------------------------------------------is_vertex
+    inline bool is_vertex(unsigned c)
+    {
+        return c >= path_cmd_move_to && c < path_cmd_end_poly;
+    }
+
+    //--------------------------------------------------------------is_drawing
+    inline bool is_drawing(unsigned c)
+    {
+        return c >= path_cmd_line_to && c < path_cmd_end_poly;
+    }
+
+    //-----------------------------------------------------------------is_stop
+    inline bool is_stop(unsigned c)
+    { 
+        return c == path_cmd_stop;
+    }
+
+    //--------------------------------------------------------------is_move_to
+    inline bool is_move_to(unsigned c)
+    {
+        return c == path_cmd_move_to;
+    }
+
+    //--------------------------------------------------------------is_line_to
+    inline bool is_line_to(unsigned c)
+    {
+        return c == path_cmd_line_to;
+    }
+
+    //----------------------------------------------------------------is_curve
+    inline bool is_curve(unsigned c)
+    {
+        return c == path_cmd_curve3 || c == path_cmd_curve4;
+    }
+
+    //---------------------------------------------------------------is_curve3
+    inline bool is_curve3(unsigned c)
+    {
+        return c == path_cmd_curve3;
+    }
+
+    //---------------------------------------------------------------is_curve4
+    inline bool is_curve4(unsigned c)
+    {
+        return c == path_cmd_curve4;
+    }
+
+    //-------------------------------------------------------------is_end_poly
+    inline bool is_end_poly(unsigned c)
+    {
+        return (c & path_cmd_mask) == path_cmd_end_poly;
+    }
+
+    //----------------------------------------------------------------is_close
+    inline bool is_close(unsigned c)
+    {
+        return (c & ~(path_flags_cw | path_flags_ccw)) ==
+               (path_cmd_end_poly | path_flags_close); 
+    }
+
+    //------------------------------------------------------------is_next_poly
+    inline bool is_next_poly(unsigned c)
+    {
+        return is_stop(c) || is_move_to(c) || is_end_poly(c);
+    }
+
+    //-------------------------------------------------------------------is_cw
+    inline bool is_cw(unsigned c)
+    {
+        return (c & path_flags_cw) != 0;
+    }
+
+    //------------------------------------------------------------------is_ccw
+    inline bool is_ccw(unsigned c)
+    {
+        return (c & path_flags_ccw) != 0;
+    }
+
+    //-------------------------------------------------------------is_oriented
+    inline bool is_oriented(unsigned c)
+    {
+        return (c & (path_flags_cw | path_flags_ccw)) != 0; 
+    }
+
+    //---------------------------------------------------------------is_closed
+    inline bool is_closed(unsigned c)
+    {
+        return (c & path_flags_close) != 0; 
+    }
+
+    //----------------------------------------------------------get_close_flag
+    inline unsigned get_close_flag(unsigned c)
+    {
+        return c & path_flags_close; 
+    }
+
+    //-------------------------------------------------------clear_orientation
+    inline unsigned clear_orientation(unsigned c)
+    {
+        return c & ~(path_flags_cw | path_flags_ccw);
+    }
+
+    //---------------------------------------------------------get_orientation
+    inline unsigned get_orientation(unsigned c)
+    {
+        return c & (path_flags_cw | path_flags_ccw);
+    }
+
+    //---------------------------------------------------------set_orientation
+    inline unsigned set_orientation(unsigned c, unsigned o)
+    {
+        return clear_orientation(c) | o;
+    }
+
+    //--------------------------------------------------------------point_base
+    template<class T> struct point_base
+    {
+        typedef T value_type;
+        T x,y;
+        point_base() {}
+        point_base(T x_, T y_) : x(x_), y(y_) {}
+    };
+    typedef point_base<int>    point_i; //-----point_i
+    typedef point_base<float>  point_f; //-----point_f
+    typedef point_base<double> point_d; //-----point_d
+
+    //-------------------------------------------------------------vertex_base
+    template<class T> struct vertex_base
+    {
+        typedef T value_type;
+        T x,y;
+        unsigned cmd;
+        vertex_base() {}
+        vertex_base(T x_, T y_, unsigned cmd_) : x(x_), y(y_), cmd(cmd_) {}
+    };
+    typedef vertex_base<int>    vertex_i; //-----vertex_i
+    typedef vertex_base<float>  vertex_f; //-----vertex_f
+    typedef vertex_base<double> vertex_d; //-----vertex_d
+
+    //----------------------------------------------------------------row_info
+    template<class T> struct row_info
+    {
+        int x1, x2;
+        T* ptr;
+        row_info() {}
+        row_info(int x1_, int x2_, T* ptr_) : x1(x1_), x2(x2_), ptr(ptr_) {}
+    };
+
+    //----------------------------------------------------------const_row_info
+    template<class T> struct const_row_info
+    {
+        int x1, x2;
+        const T* ptr;
+        const_row_info() {}
+        const_row_info(int x1_, int x2_, const T* ptr_) : 
+            x1(x1_), x2(x2_), ptr(ptr_) {}
+    };
+
+    //------------------------------------------------------------is_equal_eps
+    template<class T> inline bool is_equal_eps(T v1, T v2, T epsilon)
+    {
+	bool neg1 = v1 < 0.0;
+	bool neg2 = v2 < 0.0;
+
+	if (neg1 != neg2)
+	    return std::fabs(v1) < epsilon && std::fabs(v2) < epsilon;
+
+        int int1, int2;
+	std::frexp(v1, &int1);
+	std::frexp(v2, &int2);
+	int min12 = int1 < int2 ? int1 : int2;
+
+	v1 = std::ldexp(v1, -min12);
+	v2 = std::ldexp(v2, -min12);
+
+	return std::fabs(v1 - v2) < epsilon;
+    }
+}
+
+
+#endif
+

src/agg/agg_bezier_arc.h

@@ -0,0 +1,159 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Arc generator. Produces at most 4 consecutive cubic bezier curves, i.e., 
+// 4, 7, 10, or 13 vertices.
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_BEZIER_ARC_INCLUDED
+#define AGG_BEZIER_ARC_INCLUDED
+
+#include "agg_conv_transform.h"
+
+namespace agg
+{
+
+    //-----------------------------------------------------------------------
+    void arc_to_bezier(double cx, double cy, double rx, double ry, 
+                       double start_angle, double sweep_angle,
+                       double* curve);
+
+
+    //==============================================================bezier_arc
+    // 
+    // See implemantaion agg_bezier_arc.cpp
+    //
+    class bezier_arc
+    {
+    public:
+        //--------------------------------------------------------------------
+        bezier_arc() : m_vertex(26), m_num_vertices(0), m_cmd(path_cmd_line_to) {}
+        bezier_arc(double x,  double y, 
+                   double rx, double ry, 
+                   double start_angle, 
+                   double sweep_angle)
+        {
+            init(x, y, rx, ry, start_angle, sweep_angle);
+        }
+
+        //--------------------------------------------------------------------
+        void init(double x,  double y, 
+                  double rx, double ry, 
+                  double start_angle, 
+                  double sweep_angle);
+
+        //--------------------------------------------------------------------
+        void rewind(unsigned)
+        {
+            m_vertex = 0;
+        }
+
+        //--------------------------------------------------------------------
+        unsigned vertex(double* x, double* y)
+        {
+            if(m_vertex >= m_num_vertices) return path_cmd_stop;
+            *x = m_vertices[m_vertex];
+            *y = m_vertices[m_vertex + 1];
+            m_vertex += 2;
+            return (m_vertex == 2) ? unsigned(path_cmd_move_to) : m_cmd;
+        }
+
+        // Supplemantary functions. num_vertices() actually returns doubled 
+        // number of vertices. That is, for 1 vertex it returns 2.
+        //--------------------------------------------------------------------
+        unsigned  num_vertices() const { return m_num_vertices; }
+        const double* vertices() const { return m_vertices;     }
+        double*       vertices()       { return m_vertices;     }
+ 
+    private:
+        unsigned m_vertex;
+        unsigned m_num_vertices;
+        double   m_vertices[26];
+        unsigned m_cmd;
+    };
+
+
+
+    //==========================================================bezier_arc_svg
+    // Compute an SVG-style bezier arc. 
+    //
+    // Computes an elliptical arc from (x1, y1) to (x2, y2). The size and 
+    // orientation of the ellipse are defined by two radii (rx, ry) 
+    // and an x-axis-rotation, which indicates how the ellipse as a whole 
+    // is rotated relative to the current coordinate system. The center 
+    // (cx, cy) of the ellipse is calculated automatically to satisfy the 
+    // constraints imposed by the other parameters. 
+    // large-arc-flag and sweep-flag contribute to the automatic calculations 
+    // and help determine how the arc is drawn.
+    class bezier_arc_svg
+    {
+    public:
+        //--------------------------------------------------------------------
+        bezier_arc_svg() : m_arc(), m_radii_ok(false) {}
+
+        bezier_arc_svg(double x1, double y1, 
+                       double rx, double ry, 
+                       double angle,
+                       bool large_arc_flag,
+                       bool sweep_flag,
+                       double x2, double y2) : 
+            m_arc(), m_radii_ok(false)
+        {
+            init(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2);
+        }
+
+        //--------------------------------------------------------------------
+        void init(double x1, double y1, 
+                  double rx, double ry, 
+                  double angle,
+                  bool large_arc_flag,
+                  bool sweep_flag,
+                  double x2, double y2);
+
+        //--------------------------------------------------------------------
+        bool radii_ok() const { return m_radii_ok; }
+
+        //--------------------------------------------------------------------
+        void rewind(unsigned)
+        {
+            m_arc.rewind(0);
+        }
+
+        //--------------------------------------------------------------------
+        unsigned vertex(double* x, double* y)
+        {
+            return m_arc.vertex(x, y);
+        }
+
+        // Supplemantary functions. num_vertices() actually returns doubled 
+        // number of vertices. That is, for 1 vertex it returns 2.
+        //--------------------------------------------------------------------
+        unsigned  num_vertices() const { return m_arc.num_vertices(); }
+        const double* vertices() const { return m_arc.vertices();     }
+        double*       vertices()       { return m_arc.vertices();     }
+
+    private:
+        bezier_arc m_arc;
+        bool       m_radii_ok;
+    };
+
+
+
+
+}
+
+
+#endif

src/agg/agg_clip_liang_barsky.h

@@ -0,0 +1,333 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Liang-Barsky clipping 
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CLIP_LIANG_BARSKY_INCLUDED
+#define AGG_CLIP_LIANG_BARSKY_INCLUDED
+
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //------------------------------------------------------------------------
+    enum clipping_flags_e
+    {
+        clipping_flags_x1_clipped = 4,
+        clipping_flags_x2_clipped = 1,
+        clipping_flags_y1_clipped = 8,
+        clipping_flags_y2_clipped = 2,
+        clipping_flags_x_clipped = clipping_flags_x1_clipped | clipping_flags_x2_clipped,
+        clipping_flags_y_clipped = clipping_flags_y1_clipped | clipping_flags_y2_clipped
+    };
+
+    //----------------------------------------------------------clipping_flags
+    // Determine the clipping code of the vertex according to the 
+    // Cyrus-Beck line clipping algorithm
+    //
+    //        |        |
+    //  0110  |  0010  | 0011
+    //        |        |
+    // -------+--------+-------- clip_box.y2
+    //        |        |
+    //  0100  |  0000  | 0001
+    //        |        |
+    // -------+--------+-------- clip_box.y1
+    //        |        |
+    //  1100  |  1000  | 1001
+    //        |        |
+    //  clip_box.x1  clip_box.x2
+    //
+    // 
+    template<class T>
+    inline unsigned clipping_flags(T x, T y, const rect_base<T>& clip_box)
+    {
+        return  (x > clip_box.x2) |
+               ((y > clip_box.y2) << 1) |
+               ((x < clip_box.x1) << 2) |
+               ((y < clip_box.y1) << 3);
+    }
+
+    //--------------------------------------------------------clipping_flags_x
+    template<class T>
+    inline unsigned clipping_flags_x(T x, const rect_base<T>& clip_box)
+    {
+        return  (x > clip_box.x2) | ((x < clip_box.x1) << 2);
+    }
+
+
+    //--------------------------------------------------------clipping_flags_y
+    template<class T>
+    inline unsigned clipping_flags_y(T y, const rect_base<T>& clip_box)
+    {
+        return ((y > clip_box.y2) << 1) | ((y < clip_box.y1) << 3);
+    }
+
+
+    //-------------------------------------------------------clip_liang_barsky
+    template<class T>
+    inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2,
+                                      const rect_base<T>& clip_box,
+                                      T* x, T* y)
+    {
+        const double nearzero = 1e-30;
+
+        double deltax = x2 - x1;
+        double deltay = y2 - y1; 
+        double xin;
+        double xout;
+        double yin;
+        double yout;
+        double tinx;
+        double tiny;
+        double toutx;
+        double touty;  
+        double tin1;
+        double tin2;
+        double tout1;
+        unsigned np = 0;
+
+        if(deltax == 0.0) 
+        {   
+            // bump off of the vertical
+            deltax = (x1 > clip_box.x1) ? -nearzero : nearzero;
+        }
+
+        if(deltay == 0.0) 
+        { 
+            // bump off of the horizontal 
+            deltay = (y1 > clip_box.y1) ? -nearzero : nearzero;
+        }
+        
+        if(deltax > 0.0) 
+        {                
+            // points to right
+            xin  = clip_box.x1;
+            xout = clip_box.x2;
+        }
+        else 
+        {
+            xin  = clip_box.x2;
+            xout = clip_box.x1;
+        }
+
+        if(deltay > 0.0) 
+        {
+            // points up
+            yin  = clip_box.y1;
+            yout = clip_box.y2;
+        }
+        else 
+        {
+            yin  = clip_box.y2;
+            yout = clip_box.y1;
+        }
+        
+        tinx = (xin - x1) / deltax;
+        tiny = (yin - y1) / deltay;
+        
+        if (tinx < tiny) 
+        {
+            // hits x first
+            tin1 = tinx;
+            tin2 = tiny;
+        }
+        else
+        {
+            // hits y first
+            tin1 = tiny;
+            tin2 = tinx;
+        }
+        
+        if(tin1 <= 1.0) 
+        {
+            if(0.0 < tin1) 
+            {
+                *x++ = (T)xin;
+                *y++ = (T)yin;
+                ++np;
+            }
+
+            if(tin2 <= 1.0)
+            {
+                toutx = (xout - x1) / deltax;
+                touty = (yout - y1) / deltay;
+                
+                tout1 = (toutx < touty) ? toutx : touty;
+                
+                if(tin2 > 0.0 || tout1 > 0.0) 
+                {
+                    if(tin2 <= tout1) 
+                    {
+                        if(tin2 > 0.0) 
+                        {
+                            if(tinx > tiny) 
+                            {
+                                *x++ = (T)xin;
+                                *y++ = (T)(y1 + tinx * deltay);
+                            }
+                            else 
+                            {
+                                *x++ = (T)(x1 + tiny * deltax);
+                                *y++ = (T)yin;
+                            }
+                            ++np;
+                        }
+
+                        if(tout1 < 1.0) 
+                        {
+                            if(toutx < touty) 
+                            {
+                                *x++ = (T)xout;
+                                *y++ = (T)(y1 + toutx * deltay);
+                            }
+                            else 
+                            {
+                                *x++ = (T)(x1 + touty * deltax);
+                                *y++ = (T)yout;
+                            }
+                        }
+                        else 
+                        {
+                            *x++ = x2;
+                            *y++ = y2;
+                        }
+                        ++np;
+                    }
+                    else 
+                    {
+                        if(tinx > tiny) 
+                        {
+                            *x++ = (T)xin;
+                            *y++ = (T)yout;
+                        }
+                        else 
+                        {
+                            *x++ = (T)xout;
+                            *y++ = (T)yin;
+                        }
+                        ++np;
+                    }
+                }
+            }
+        }
+        return np;
+    }
+
+
+    //----------------------------------------------------------------------------
+    template<class T>
+    bool clip_move_point(T x1, T y1, T x2, T y2, 
+                         const rect_base<T>& clip_box, 
+                         T* x, T* y, unsigned flags)
+    {
+       T bound;
+
+       if(flags & clipping_flags_x_clipped)
+       {
+           if(x1 == x2)
+           {
+               return false;
+           }
+           bound = (flags & clipping_flags_x1_clipped) ? clip_box.x1 : clip_box.x2;
+           *y = (T)(double(bound - x1) * (y2 - y1) / (x2 - x1) + y1);
+           *x = bound;
+       }
+
+       flags = clipping_flags_y(*y, clip_box);
+       if(flags & clipping_flags_y_clipped)
+       {
+           if(y1 == y2)
+           {
+               return false;
+           }
+           bound = (flags & clipping_flags_y1_clipped) ? clip_box.y1 : clip_box.y2;
+           *x = (T)(double(bound - y1) * (x2 - x1) / (y2 - y1) + x1);
+           *y = bound;
+       }
+       return true;
+    }
+
+    //-------------------------------------------------------clip_line_segment
+    // Returns: ret >= 4        - Fully clipped
+    //          (ret & 1) != 0  - First point has been moved
+    //          (ret & 2) != 0  - Second point has been moved
+    //
+    template<class T>
+    unsigned clip_line_segment(T* x1, T* y1, T* x2, T* y2,
+                               const rect_base<T>& clip_box)
+    {
+        unsigned f1 = clipping_flags(*x1, *y1, clip_box);
+        unsigned f2 = clipping_flags(*x2, *y2, clip_box);
+        unsigned ret = 0;
+
+        if((f2 | f1) == 0)
+        {
+            // Fully visible
+            return 0;
+        }
+
+        if((f1 & clipping_flags_x_clipped) != 0 && 
+           (f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
+        {
+            // Fully clipped
+            return 4;
+        }
+
+        if((f1 & clipping_flags_y_clipped) != 0 && 
+           (f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
+        {
+            // Fully clipped
+            return 4;
+        }
+
+        T tx1 = *x1;
+        T ty1 = *y1;
+        T tx2 = *x2;
+        T ty2 = *y2;
+        if(f1) 
+        {   
+            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x1, y1, f1)) 
+            {
+                return 4;
+            }
+            if(*x1 == *x2 && *y1 == *y2) 
+            {
+                return 4;
+            }
+            ret |= 1;
+        }
+        if(f2) 
+        {
+            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x2, y2, f2))
+            {
+                return 4;
+            }
+            if(*x1 == *x2 && *y1 == *y2) 
+            {
+                return 4;
+            }
+            ret |= 2;
+        }
+        return ret;
+    }
+
+
+}
+
+
+#endif

src/agg/agg_config.h

@@ -0,0 +1,44 @@
+#ifndef AGG_CONFIG_INCLUDED
+#define AGG_CONFIG_INCLUDED
+
+// This file can be used to redefine certain data types.
+
+//---------------------------------------
+// 1. Default basic types such as:
+// 
+// AGG_INT8
+// AGG_INT8U
+// AGG_INT16
+// AGG_INT16U
+// AGG_INT32
+// AGG_INT32U
+// AGG_INT64
+// AGG_INT64U
+//
+// Just replace this file with new defines if necessary. 
+// For example, if your compiler doesn't have a 64 bit integer type
+// you can still use AGG if you define the follows:
+//
+// #define AGG_INT64  int
+// #define AGG_INT64U unsigned
+//
+// It will result in overflow in 16 bit-per-component image/pattern resampling
+// but it won't result any crash and the rest of the library will remain 
+// fully functional.
+
+
+//---------------------------------------
+// 2. Default rendering_buffer type. Can be:
+//
+// Provides faster access for massive pixel operations, 
+// such as blur, image filtering:
+// #define AGG_RENDERING_BUFFER row_ptr_cache<int8u>
+// 
+// Provides cheaper creation and destruction (no mem allocs):
+// #define AGG_RENDERING_BUFFER row_accessor<int8u>
+//
+// You can still use both of them simultaneously in your applications 
+// This #define is used only for default rendering_buffer type,
+// in short hand typedefs like pixfmt_rgba32.
+
+#endif

src/agg/agg_conv_transform.h

@@ -0,0 +1,68 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// class conv_transform
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_CONV_TRANSFORM_INCLUDED
+#define AGG_CONV_TRANSFORM_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_trans_affine.h"
+
+namespace agg
+{
+
+    //----------------------------------------------------------conv_transform
+    template<class VertexSource, class Transformer=trans_affine> class conv_transform
+    {
+    public:
+        conv_transform(VertexSource& source, Transformer& tr) :
+            m_source(&source), m_trans(&tr) {}
+        void attach(VertexSource& source) { m_source = &source; }
+
+        void rewind(unsigned path_id) 
+        { 
+            m_source->rewind(path_id); 
+        }
+
+        unsigned vertex(double* x, double* y)
+        {
+            unsigned cmd = m_source->vertex(x, y);
+            if(is_vertex(cmd))
+            {
+                m_trans->transform(x, y);
+            }
+            return cmd;
+        }
+
+        void transformer(Transformer& tr)
+        {
+            m_trans = &tr;
+        }
+
+    private:
+        conv_transform(const conv_transform<VertexSource>&);
+        const conv_transform<VertexSource>& 
+            operator = (const conv_transform<VertexSource>&);
+
+        VertexSource*      m_source;
+        Transformer* m_trans;
+    };
+
+
+}
+
+#endif

src/agg/agg_gamma_functions.h

@@ -0,0 +1,132 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_GAMMA_FUNCTIONS_INCLUDED
+#define AGG_GAMMA_FUNCTIONS_INCLUDED
+
+#include <math.h>
+#include "agg_basics.h"
+
+namespace agg
+{
+    //===============================================================gamma_none
+    struct gamma_none
+    {
+        double operator()(double x) const { return x; }
+    };
+
+
+    //==============================================================gamma_power
+    class gamma_power
+    {
+    public:
+        gamma_power() : m_gamma(1.0) {}
+        gamma_power(double g) : m_gamma(g) {}
+
+        void gamma(double g) { m_gamma = g; }
+        double gamma() const { return m_gamma; }
+
+        double operator() (double x) const
+        {
+            return pow(x, m_gamma);
+        }
+
+    private:
+        double m_gamma;
+    };
+
+
+    //==========================================================gamma_threshold
+    class gamma_threshold
+    {
+    public:
+        gamma_threshold() : m_threshold(0.5) {}
+        gamma_threshold(double t) : m_threshold(t) {}
+
+        void threshold(double t) { m_threshold = t; }
+        double threshold() const { return m_threshold; }
+
+        double operator() (double x) const
+        {
+            return (x < m_threshold) ? 0.0 : 1.0;
+        }
+
+    private:
+        double m_threshold;
+    };
+
+
+    //============================================================gamma_linear
+    class gamma_linear
+    {
+    public:
+        gamma_linear() : m_start(0.0), m_end(1.0) {}
+        gamma_linear(double s, double e) : m_start(s), m_end(e) {}
+
+        void set(double s, double e) { m_start = s; m_end = e; }
+        void start(double s) { m_start = s; }
+        void end(double e) { m_end = e; }
+        double start() const { return m_start; }
+        double end() const { return m_end; }
+
+        double operator() (double x) const
+        {
+            if(x < m_start) return 0.0;
+            if(x > m_end) return 1.0;
+            return (x - m_start) / (m_end - m_start);
+        }
+
+    private:
+        double m_start;
+        double m_end;
+    };
+
+
+    //==========================================================gamma_multiply
+    class gamma_multiply
+    {
+    public:
+        gamma_multiply() : m_mul(1.0) {}
+        gamma_multiply(double v) : m_mul(v) {}
+
+        void value(double v) { m_mul = v; }
+        double value() const { return m_mul; }
+
+        double operator() (double x) const
+        {
+            double y = x * m_mul;
+            if(y > 1.0) y = 1.0;
+            return y;
+        }
+
+    private:
+        double m_mul;
+    };
+
+    inline double sRGB_to_linear(double x)
+    {
+        return (x <= 0.04045) ? (x / 12.92) : pow((x + 0.055) / (1.055), 2.4);
+    }
+
+    inline double linear_to_sRGB(double x)
+    {
+        return (x <= 0.0031308) ? (x * 12.92) : (1.055 * pow(x, 1 / 2.4) - 0.055);
+    }
+}
+
+#endif
+
+
+

src/agg/agg_gamma_lut.h

@@ -0,0 +1,300 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_GAMMA_LUT_INCLUDED
+#define AGG_GAMMA_LUT_INCLUDED
+
+#include <math.h>
+#include "agg_basics.h"
+#include "agg_gamma_functions.h"
+
+namespace agg
+{
+    template<class LoResT=int8u, 
+             class HiResT=int8u, 
+             unsigned GammaShift=8, 
+             unsigned HiResShift=8> class gamma_lut
+    {
+    public:
+        typedef gamma_lut<LoResT, HiResT, GammaShift, HiResShift> self_type;
+
+        enum gamma_scale_e
+        {
+            gamma_shift = GammaShift,
+            gamma_size  = 1 << gamma_shift,
+            gamma_mask  = gamma_size - 1
+        };
+
+        enum hi_res_scale_e
+        {
+            hi_res_shift = HiResShift,
+            hi_res_size  = 1 << hi_res_shift,
+            hi_res_mask  = hi_res_size - 1
+        };
+
+        ~gamma_lut()
+        {
+            pod_allocator<LoResT>::deallocate(m_inv_gamma, hi_res_size);
+            pod_allocator<HiResT>::deallocate(m_dir_gamma, gamma_size);
+        }
+
+        gamma_lut() : 
+            m_gamma(1.0), 
+            m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
+            m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
+        {
+            unsigned i;
+            for(i = 0; i < gamma_size; i++)
+            {
+                m_dir_gamma[i] = HiResT(i << (hi_res_shift - gamma_shift));
+            }
+
+            for(i = 0; i < hi_res_size; i++)
+            {
+                m_inv_gamma[i] = LoResT(i >> (hi_res_shift - gamma_shift));
+            }
+        }
+
+        gamma_lut(double g) :
+            m_gamma(1.0), 
+            m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
+            m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
+        {
+            gamma(g);
+        }
+
+        void gamma(double g) 
+        {
+            m_gamma = g;
+
+            unsigned i;
+            for(i = 0; i < gamma_size; i++)
+            {
+                m_dir_gamma[i] = (HiResT)
+                    uround(pow(i / double(gamma_mask), m_gamma) * double(hi_res_mask));
+            }
+
+            double inv_g = 1.0 / g;
+            for(i = 0; i < hi_res_size; i++)
+            {
+                m_inv_gamma[i] = (LoResT)
+                    uround(pow(i / double(hi_res_mask), inv_g) * double(gamma_mask));
+            }
+        }
+
+        double gamma() const
+        {
+            return m_gamma;
+        }
+
+        HiResT dir(LoResT v) const 
+        { 
+            return m_dir_gamma[unsigned(v)]; 
+        }
+
+        LoResT inv(HiResT v) const 
+        { 
+            return m_inv_gamma[unsigned(v)];
+        }
+
+    private:
+        gamma_lut(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        double m_gamma;
+        HiResT* m_dir_gamma;
+        LoResT* m_inv_gamma;
+    };
+
+    //
+    // sRGB support classes
+    //
+
+    // sRGB_lut - implements sRGB conversion for the various types.
+    // Base template is undefined, specializations are provided below.
+    template<class LinearType>
+    class sRGB_lut;
+
+    template<>
+    class sRGB_lut<float>
+    {
+    public:
+		sRGB_lut()
+		{
+			// Generate lookup tables.
+			for (int i = 0; i <= 255; ++i)
+			{
+				m_dir_table[i] = float(sRGB_to_linear(i / 255.0));
+			}
+			for (int i = 0; i <= 65535; ++i)
+			{
+				m_inv_table[i] = uround(255.0 * linear_to_sRGB(i / 65535.0));
+			}
+		}
+
+		float dir(int8u v) const
+		{
+			return m_dir_table[v];
+		}
+
+		int8u inv(float v) const
+		{
+			return m_inv_table[int16u(0.5 + v * 65535)];
+		}
+
+	private:
+		float m_dir_table[256];
+		int8u m_inv_table[65536];
+    };
+
+    template<>
+    class sRGB_lut<int16u>
+    {
+    public:
+        sRGB_lut()
+        {
+            // Generate lookup tables.
+            for (int i = 0; i <= 255; ++i)
+            {
+                m_dir_table[i] = uround(65535.0 * sRGB_to_linear(i / 255.0));
+            }
+			for (int i = 0; i <= 65535; ++i)
+			{
+				m_inv_table[i] = uround(255.0 * linear_to_sRGB(i / 65535.0));
+			}
+		}
+
+		int16u dir(int8u v) const
+		{
+			return m_dir_table[v];
+		}
+
+		int8u inv(int16u v) const
+		{
+			return m_inv_table[v];
+		}
+
+	private:
+		int16u m_dir_table[256];
+		int8u m_inv_table[65536];
+	};
+
+    template<>
+    class sRGB_lut<int8u>
+    {
+    public:
+        sRGB_lut()
+        {
+            // Generate lookup tables. 
+            for (int i = 0; i <= 255; ++i)
+            {
+                m_dir_table[i] = uround(255.0 * sRGB_to_linear(i / 255.0));
+                m_inv_table[i] = uround(255.0 * linear_to_sRGB(i / 255.0));
+            }
+        }
+
+		int8u dir(int8u v) const
+		{
+			return m_dir_table[v];
+		}
+
+		int8u inv(int8u v) const
+        {
+            return m_inv_table[v];
+        }
+
+	private:
+		int8u m_dir_table[256];
+		int8u m_inv_table[256];
+	};
+
+    // Common base class for sRGB_conv objects. Defines an internal 
+    // sRGB_lut object so that users don't have to.
+    template<class T>
+    class sRGB_conv_base
+    {
+    public:
+        static T rgb_from_sRGB(int8u x)
+        {
+            return lut.dir(x);
+        }
+
+        static int8u rgb_to_sRGB(T x)
+        {
+            return lut.inv(x);
+        }
+
+    private:
+        static sRGB_lut<T> lut;
+    };
+
+    // Definition of sRGB_conv_base::lut. Due to the fact that this a template, 
+    // we don't need to place the definition in a cpp file. Hurrah.
+    template<class T>
+    sRGB_lut<T> sRGB_conv_base<T>::lut;
+
+    // Wrapper for sRGB-linear conversion. 
+    // Base template is undefined, specializations are provided below.
+    template<class T>
+    class sRGB_conv;
+
+    template<>
+    class sRGB_conv<float> : public sRGB_conv_base<float>
+    {
+    public:
+        static float alpha_from_sRGB(int8u x)
+        {
+			static const double y = 1 / 255.0;
+            return float(x * y);
+        }
+
+        static int8u alpha_to_sRGB(float x)
+        {
+            return int8u(0.5 + x * 255);
+        }
+    };
+
+    template<>
+    class sRGB_conv<int16u> : public sRGB_conv_base<int16u>
+    {
+    public:
+        static int16u alpha_from_sRGB(int8u x)
+        {
+            return (x << 8) | x;
+        }
+
+        static int8u alpha_to_sRGB(int16u x)
+        {
+            return x >> 8;
+        }
+    };
+
+    template<>
+    class sRGB_conv<int8u> : public sRGB_conv_base<int8u>
+    {
+    public:
+        static int8u alpha_from_sRGB(int8u x)
+        {
+            return x;
+        }
+
+        static int8u alpha_to_sRGB(int8u x)
+        {
+            return x;
+        }
+    };
+}
+
+#endif

src/agg/agg_math.h

@@ -0,0 +1,437 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+// Bessel function (besj) was adapted for use in AGG library by Andy Wilk 
+// Contact: castor.vulgaris@gmail.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_MATH_INCLUDED
+#define AGG_MATH_INCLUDED
+
+#include <math.h>
+#include "agg_basics.h"
+
+namespace agg
+{
+
+    //------------------------------------------------------vertex_dist_epsilon
+    // Coinciding points maximal distance (Epsilon)
+    const double vertex_dist_epsilon = 1e-14;
+
+    //-----------------------------------------------------intersection_epsilon
+    // See calc_intersection
+    const double intersection_epsilon = 1.0e-30;
+
+    //------------------------------------------------------------cross_product
+    AGG_INLINE double cross_product(double x1, double y1, 
+                                    double x2, double y2, 
+                                    double x,  double y)
+    {
+        return (x - x2) * (y2 - y1) - (y - y2) * (x2 - x1);
+    }
+
+    //--------------------------------------------------------point_in_triangle
+    AGG_INLINE bool point_in_triangle(double x1, double y1, 
+                                      double x2, double y2, 
+                                      double x3, double y3, 
+                                      double x,  double y)
+    {
+        bool cp1 = cross_product(x1, y1, x2, y2, x, y) < 0.0;
+        bool cp2 = cross_product(x2, y2, x3, y3, x, y) < 0.0;
+        bool cp3 = cross_product(x3, y3, x1, y1, x, y) < 0.0;
+        return cp1 == cp2 && cp2 == cp3 && cp3 == cp1;
+    }
+
+    //-----------------------------------------------------------calc_distance
+    AGG_INLINE double calc_distance(double x1, double y1, double x2, double y2)
+    {
+        double dx = x2-x1;
+        double dy = y2-y1;
+        return sqrt(dx * dx + dy * dy);
+    }
+
+    //--------------------------------------------------------calc_sq_distance
+    AGG_INLINE double calc_sq_distance(double x1, double y1, double x2, double y2)
+    {
+        double dx = x2-x1;
+        double dy = y2-y1;
+        return dx * dx + dy * dy;
+    }
+
+    //------------------------------------------------calc_line_point_distance
+    AGG_INLINE double calc_line_point_distance(double x1, double y1, 
+                                               double x2, double y2, 
+                                               double x,  double y)
+    {
+        double dx = x2-x1;
+        double dy = y2-y1;
+        double d = sqrt(dx * dx + dy * dy);
+        if(d < vertex_dist_epsilon)
+        {
+            return calc_distance(x1, y1, x, y);
+        }
+        return ((x - x2) * dy - (y - y2) * dx) / d;
+    }
+
+    //-------------------------------------------------------calc_line_point_u
+    AGG_INLINE double calc_segment_point_u(double x1, double y1, 
+                                           double x2, double y2, 
+                                           double x,  double y)
+    {
+        double dx = x2 - x1;
+        double dy = y2 - y1;
+
+        if(dx == 0 && dy == 0)
+        {
+	        return 0;
+        }
+
+        double pdx = x - x1;
+        double pdy = y - y1;
+
+        return (pdx * dx + pdy * dy) / (dx * dx + dy * dy);
+    }
+
+    //---------------------------------------------calc_line_point_sq_distance
+    AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1, 
+                                                     double x2, double y2, 
+                                                     double x,  double y,
+                                                     double u)
+    {
+        if(u <= 0)
+        {
+	        return calc_sq_distance(x, y, x1, y1);
+        }
+        else 
+        if(u >= 1)
+        {
+	        return calc_sq_distance(x, y, x2, y2);
+        }
+        return calc_sq_distance(x, y, x1 + u * (x2 - x1), y1 + u * (y2 - y1));
+    }
+
+    //---------------------------------------------calc_line_point_sq_distance
+    AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1, 
+                                                     double x2, double y2, 
+                                                     double x,  double y)
+    {
+        return 
+            calc_segment_point_sq_distance(
+                x1, y1, x2, y2, x, y,
+                calc_segment_point_u(x1, y1, x2, y2, x, y));
+    }
+
+    //-------------------------------------------------------calc_intersection
+    AGG_INLINE bool calc_intersection(double ax, double ay, double bx, double by,
+                                      double cx, double cy, double dx, double dy,
+                                      double* x, double* y)
+    {
+        double num = (ay-cy) * (dx-cx) - (ax-cx) * (dy-cy);
+        double den = (bx-ax) * (dy-cy) - (by-ay) * (dx-cx);
+        if(fabs(den) < intersection_epsilon) return false;
+        double r = num / den;
+        *x = ax + r * (bx-ax);
+        *y = ay + r * (by-ay);
+        return true;
+    }
+
+    //-----------------------------------------------------intersection_exists
+    AGG_INLINE bool intersection_exists(double x1, double y1, double x2, double y2,
+                                        double x3, double y3, double x4, double y4)
+    {
+        // It's less expensive but you can't control the 
+        // boundary conditions: Less or LessEqual
+        double dx1 = x2 - x1;
+        double dy1 = y2 - y1;
+        double dx2 = x4 - x3;
+        double dy2 = y4 - y3;
+        return ((x3 - x2) * dy1 - (y3 - y2) * dx1 < 0.0) != 
+               ((x4 - x2) * dy1 - (y4 - y2) * dx1 < 0.0) &&
+               ((x1 - x4) * dy2 - (y1 - y4) * dx2 < 0.0) !=
+               ((x2 - x4) * dy2 - (y2 - y4) * dx2 < 0.0);
+
+        // It's is more expensive but more flexible 
+        // in terms of boundary conditions.
+        //--------------------
+        //double den  = (x2-x1) * (y4-y3) - (y2-y1) * (x4-x3);
+        //if(fabs(den) < intersection_epsilon) return false;
+        //double nom1 = (x4-x3) * (y1-y3) - (y4-y3) * (x1-x3);
+        //double nom2 = (x2-x1) * (y1-y3) - (y2-y1) * (x1-x3);
+        //double ua = nom1 / den;
+        //double ub = nom2 / den;
+        //return ua >= 0.0 && ua <= 1.0 && ub >= 0.0 && ub <= 1.0;
+    }
+
+    //--------------------------------------------------------calc_orthogonal
+    AGG_INLINE void calc_orthogonal(double thickness,
+                                    double x1, double y1,
+                                    double x2, double y2,
+                                    double* x, double* y)
+    {
+        double dx = x2 - x1;
+        double dy = y2 - y1;
+        double d = sqrt(dx*dx + dy*dy); 
+        *x =  thickness * dy / d;
+        *y = -thickness * dx / d;
+    }
+
+    //--------------------------------------------------------dilate_triangle
+    AGG_INLINE void dilate_triangle(double x1, double y1,
+                                    double x2, double y2,
+                                    double x3, double y3,
+                                    double *x, double* y,
+                                    double d)
+    {
+        double dx1=0.0;
+        double dy1=0.0; 
+        double dx2=0.0;
+        double dy2=0.0; 
+        double dx3=0.0;
+        double dy3=0.0; 
+        double loc = cross_product(x1, y1, x2, y2, x3, y3);
+        if(fabs(loc) > intersection_epsilon)
+        {
+            if(cross_product(x1, y1, x2, y2, x3, y3) > 0.0) 
+            {
+                d = -d;
+            }
+            calc_orthogonal(d, x1, y1, x2, y2, &dx1, &dy1);
+            calc_orthogonal(d, x2, y2, x3, y3, &dx2, &dy2);
+            calc_orthogonal(d, x3, y3, x1, y1, &dx3, &dy3);
+        }
+        *x++ = x1 + dx1;  *y++ = y1 + dy1;
+        *x++ = x2 + dx1;  *y++ = y2 + dy1;
+        *x++ = x2 + dx2;  *y++ = y2 + dy2;
+        *x++ = x3 + dx2;  *y++ = y3 + dy2;
+        *x++ = x3 + dx3;  *y++ = y3 + dy3;
+        *x++ = x1 + dx3;  *y++ = y1 + dy3;
+    }
+
+    //------------------------------------------------------calc_triangle_area
+    AGG_INLINE double calc_triangle_area(double x1, double y1,
+                                         double x2, double y2,
+                                         double x3, double y3)
+    {
+        return (x1*y2 - x2*y1 + x2*y3 - x3*y2 + x3*y1 - x1*y3) * 0.5;
+    }
+
+    //-------------------------------------------------------calc_polygon_area
+    template<class Storage> double calc_polygon_area(const Storage& st)
+    {
+        unsigned i;
+        double sum = 0.0;
+        double x  = st[0].x;
+        double y  = st[0].y;
+        double xs = x;
+        double ys = y;
+
+        for(i = 1; i < st.size(); i++)
+        {
+            const typename Storage::value_type& v = st[i];
+            sum += x * v.y - y * v.x;
+            x = v.x;
+            y = v.y;
+        }
+        return (sum + x * ys - y * xs) * 0.5;
+    }
+
+    //------------------------------------------------------------------------
+    // Tables for fast sqrt
+    extern int16u g_sqrt_table[1024];
+    extern int8   g_elder_bit_table[256];
+
+
+    //---------------------------------------------------------------fast_sqrt
+    //Fast integer Sqrt - really fast: no cycles, divisions or multiplications
+    #if defined(_MSC_VER)
+    #pragma warning(push)
+    #pragma warning(disable : 4035) //Disable warning "no return value"
+    #endif
+    AGG_INLINE unsigned fast_sqrt(unsigned val)
+    {
+    #if defined(_M_IX86) && defined(_MSC_VER) && !defined(AGG_NO_ASM)
+        //For Ix86 family processors this assembler code is used. 
+        //The key command here is bsr - determination the number of the most 
+        //significant bit of the value. For other processors
+        //(and maybe compilers) the pure C "#else" section is used.
+        __asm
+        {
+            mov ebx, val
+            mov edx, 11
+            bsr ecx, ebx
+            sub ecx, 9
+            jle less_than_9_bits
+            shr ecx, 1
+            adc ecx, 0
+            sub edx, ecx
+            shl ecx, 1
+            shr ebx, cl
+    less_than_9_bits:
+            xor eax, eax
+            mov  ax, g_sqrt_table[ebx*2]
+            mov ecx, edx
+            shr eax, cl
+        }
+    #else
+
+        //This code is actually pure C and portable to most 
+        //arcitectures including 64bit ones. 
+        unsigned t = val;
+        int bit=0;
+        unsigned shift = 11;
+
+        //The following piece of code is just an emulation of the
+        //Ix86 assembler command "bsr" (see above). However on old
+        //Intels (like Intel MMX 233MHz) this code is about twice 
+        //faster (sic!) then just one "bsr". On PIII and PIV the
+        //bsr is optimized quite well.
+        bit = t >> 24;
+        if(bit)
+        {
+            bit = g_elder_bit_table[bit] + 24;
+        }
+        else
+        {
+            bit = (t >> 16) & 0xFF;
+            if(bit)
+            {
+                bit = g_elder_bit_table[bit] + 16;
+            }
+            else
+            {
+                bit = (t >> 8) & 0xFF;
+                if(bit)
+                {
+                    bit = g_elder_bit_table[bit] + 8;
+                }
+                else
+                {
+                    bit = g_elder_bit_table[t];
+                }
+            }
+        }
+
+        //This code calculates the sqrt.
+        bit -= 9;
+        if(bit > 0)
+        {
+            bit = (bit >> 1) + (bit & 1);
+            shift -= bit;
+            val >>= (bit << 1);
+        }
+        return g_sqrt_table[val] >> shift;
+    #endif
+    }
+    #if defined(_MSC_VER)
+    #pragma warning(pop)
+    #endif
+
+
+
+
+    //--------------------------------------------------------------------besj
+    // Function BESJ calculates Bessel function of first kind of order n
+    // Arguments:
+    //     n - an integer (>=0), the order
+    //     x - value at which the Bessel function is required
+    //--------------------
+    // C++ Mathematical Library
+    // Convereted from equivalent FORTRAN library
+    // Converetd by Gareth Walker for use by course 392 computational project
+    // All functions tested and yield the same results as the corresponding
+    // FORTRAN versions.
+    //
+    // If you have any problems using these functions please report them to
+    // M.Muldoon@UMIST.ac.uk
+    //
+    // Documentation available on the web
+    // http://www.ma.umist.ac.uk/mrm/Teaching/392/libs/392.html
+    // Version 1.0   8/98
+    // 29 October, 1999
+    //--------------------
+    // Adapted for use in AGG library by Andy Wilk (castor.vulgaris@gmail.com)
+    //------------------------------------------------------------------------
+    inline double besj(double x, int n)
+    {
+        if(n < 0)
+        {
+            return 0;
+        }
+        double d = 1E-6;
+        double b = 0;
+        if(fabs(x) <= d) 
+        {
+            if(n != 0) return 0;
+            return 1;
+        }
+        double b1 = 0; // b1 is the value from the previous iteration
+        // Set up a starting order for recurrence
+        int m1 = (int)fabs(x) + 6;
+        if(fabs(x) > 5) 
+        {
+            m1 = (int)(fabs(1.4 * x + 60 / x));
+        }
+        int m2 = (int)(n + 2 + fabs(x) / 4);
+        if (m1 > m2) 
+        {
+            m2 = m1;
+        }
+    
+        // Apply recurrence down from curent max order
+        for(;;) 
+        {
+            double c3 = 0;
+            double c2 = 1E-30;
+            double c4 = 0;
+            int m8 = 1;
+            if (m2 / 2 * 2 == m2) 
+            {
+                m8 = -1;
+            }
+            int imax = m2 - 2;
+            for (int i = 1; i <= imax; i++) 
+            {
+                double c6 = 2 * (m2 - i) * c2 / x - c3;
+                c3 = c2;
+                c2 = c6;
+                if(m2 - i - 1 == n)
+                {
+                    b = c6;
+                }
+                m8 = -1 * m8;
+                if (m8 > 0)
+                {
+                    c4 = c4 + 2 * c6;
+                }
+            }
+            double c6 = 2 * c2 / x - c3;
+            if(n == 0)
+            {
+                b = c6;
+            }
+            c4 += c6;
+            b /= c4;
+            if(fabs(b - b1) < d)
+            {
+                return b;
+            }
+            b1 = b;
+            m2 += 3;
+        }
+    }
+
+}
+
+
+#endif

src/agg/agg_pixfmt_base.h

@@ -0,0 +1,97 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_PIXFMT_BASE_INCLUDED
+#define AGG_PIXFMT_BASE_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_color_gray.h"
+#include "agg_color_rgba.h"
+
+namespace agg
+{
+    struct pixfmt_gray_tag
+    {
+    };
+
+    struct pixfmt_rgb_tag
+    {
+    };
+
+    struct pixfmt_rgba_tag
+    {
+    };
+
+    //--------------------------------------------------------------blender_base
+    template<class ColorT, class Order = void> 
+    struct blender_base
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+
+        static rgba get(value_type r, value_type g, value_type b, value_type a, cover_type cover = cover_full)
+        {
+            if (cover > cover_none)
+            {
+                rgba c(
+                    color_type::to_double(r), 
+                    color_type::to_double(g), 
+                    color_type::to_double(b), 
+                    color_type::to_double(a));
+
+                if (cover < cover_full)
+                {
+                    double x = double(cover) / cover_full;
+                    c.r *= x;
+                    c.g *= x;
+                    c.b *= x;
+                    c.a *= x;
+                }
+
+                return c;
+            }
+            else return rgba::no_color();
+        }
+
+        static rgba get(const value_type* p, cover_type cover = cover_full)
+        {
+            return get(
+                p[order_type::R], 
+                p[order_type::G], 
+                p[order_type::B], 
+                p[order_type::A], 
+                cover);
+        }
+
+        static void set(value_type* p, value_type r, value_type g, value_type b, value_type a)
+        {
+            p[order_type::R] = r;
+            p[order_type::G] = g;
+            p[order_type::B] = b;
+            p[order_type::A] = a;
+        }
+
+        static void set(value_type* p, const rgba& c)
+        {
+            p[order_type::R] = color_type::from_double(c.r);
+            p[order_type::G] = color_type::from_double(c.g);
+            p[order_type::B] = color_type::from_double(c.b);
+            p[order_type::A] = color_type::from_double(c.a);
+        }
+    };
+}
+
+#endif

src/agg/agg_pixfmt_gray.h

@@ -0,0 +1,738 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for high precision colors has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+
+#ifndef AGG_PIXFMT_GRAY_INCLUDED
+#define AGG_PIXFMT_GRAY_INCLUDED
+
+#include <string.h>
+#include "agg_pixfmt_base.h"
+#include "agg_rendering_buffer.h"
+
+namespace agg
+{
+ 
+    //============================================================blender_gray
+    template<class ColorT> struct blender_gray
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        // Blend pixels using the non-premultiplied form of Alvy-Ray Smith's
+        // compositing function. Since the render buffer is opaque we skip the
+        // initial premultiply and final demultiply.
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cv, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, cv, color_type::mult_cover(alpha, cover));
+        }
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cv, value_type alpha)
+        {
+            *p = color_type::lerp(*p, cv, alpha);
+        }
+    };
+
+
+    //======================================================blender_gray_pre
+    template<class ColorT> struct blender_gray_pre
+    {
+        typedef ColorT color_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        // Blend pixels using the premultiplied form of Alvy-Ray Smith's
+        // compositing function. 
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cv, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, color_type::mult_cover(cv, cover), color_type::mult_cover(alpha, cover));
+        }
+
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cv, value_type alpha)
+        {
+            *p = color_type::prelerp(*p, cv, alpha);
+        }
+    };
+    
+
+
+    //=====================================================apply_gamma_dir_gray
+    template<class ColorT, class GammaLut> class apply_gamma_dir_gray
+    {
+    public:
+        typedef typename ColorT::value_type value_type;
+
+        apply_gamma_dir_gray(const GammaLut& gamma) : m_gamma(gamma) {}
+
+        AGG_INLINE void operator () (value_type* p)
+        {
+            *p = m_gamma.dir(*p);
+        }
+
+    private:
+        const GammaLut& m_gamma;
+    };
+
+
+
+    //=====================================================apply_gamma_inv_gray
+    template<class ColorT, class GammaLut> class apply_gamma_inv_gray
+    {
+    public:
+        typedef typename ColorT::value_type value_type;
+
+        apply_gamma_inv_gray(const GammaLut& gamma) : m_gamma(gamma) {}
+
+        AGG_INLINE void operator () (value_type* p)
+        {
+            *p = m_gamma.inv(*p);
+        }
+
+    private:
+        const GammaLut& m_gamma;
+    };
+
+
+
+    //=================================================pixfmt_alpha_blend_gray
+    template<class Blender, class RenBuf, unsigned Step = 1, unsigned Offset = 0>
+    class pixfmt_alpha_blend_gray
+    {
+    public:
+        typedef pixfmt_gray_tag pixfmt_category;
+        typedef RenBuf   rbuf_type;
+        typedef typename rbuf_type::row_data row_data;
+        typedef Blender  blender_type;
+        typedef typename blender_type::color_type color_type;
+        typedef int                               order_type; // A fake one
+        typedef typename color_type::value_type   value_type;
+        typedef typename color_type::calc_type    calc_type;
+        enum 
+        {
+            num_components = 1,
+            pix_width = sizeof(value_type) * Step,
+            pix_step = Step,
+            pix_offset = Offset,
+        };
+        struct pixel_type
+        {
+            value_type c[num_components];
+
+            void set(value_type v)
+            {
+                c[0] = v;
+            }
+
+            void set(const color_type& color)
+            {
+                set(color.v);
+            }
+
+            void get(value_type& v) const
+            {
+                v = c[0];
+            }
+
+            color_type get() const
+            {
+                return color_type(c[0]);
+            }
+
+            pixel_type* next()
+            {
+                return (pixel_type*)(c + pix_step);
+            }
+
+            const pixel_type* next() const
+            {
+                return (const pixel_type*)(c + pix_step);
+            }
+
+            pixel_type* advance(int n)
+            {
+                return (pixel_type*)(c + n * pix_step);
+            }
+
+            const pixel_type* advance(int n) const
+            {
+                return (const pixel_type*)(c + n * pix_step);
+            }
+        };
+
+    private:
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, 
+            value_type v, value_type a, 
+            unsigned cover)
+        {
+            blender_type::blend_pix(p->c, v, a, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, value_type v, value_type a)
+        {
+            blender_type::blend_pix(p->c, v, a);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c, unsigned cover)
+        {
+            blender_type::blend_pix(p->c, c.v, c.a, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c)
+        {
+            blender_type::blend_pix(p->c, c.v, c.a);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c, unsigned cover)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    p->set(c);
+                }
+                else
+                {
+                    blend_pix(p, c, cover);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque())
+                {
+                    p->set(c);
+                }
+                else
+                {
+                    blend_pix(p, c);
+                }
+            }
+        }
+
+    public:
+        //--------------------------------------------------------------------
+        explicit pixfmt_alpha_blend_gray(rbuf_type& rb) :
+            m_rbuf(&rb)
+        {}
+        void attach(rbuf_type& rb) { m_rbuf = &rb; }
+        //--------------------------------------------------------------------
+
+        template<class PixFmt>
+        bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
+        {
+            rect_i r(x1, y1, x2, y2);
+            if (r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
+            {
+                int stride = pixf.stride();
+                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
+                               (r.x2 - r.x1) + 1,
+                               (r.y2 - r.y1) + 1,
+                               stride);
+                return true;
+            }
+            return false;
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
+        AGG_INLINE unsigned height() const { return m_rbuf->height(); }
+        AGG_INLINE int      stride() const { return m_rbuf->stride(); }
+
+        //--------------------------------------------------------------------
+        int8u* row_ptr(int y)       { return m_rbuf->row_ptr(y); }
+        const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
+        row_data     row(int y)     const { return m_rbuf->row(y); }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE int8u* pix_ptr(int x, int y) 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step + pix_offset);
+        }
+
+        AGG_INLINE const int8u* pix_ptr(int x, int y) const 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step + pix_offset);
+        }
+
+        // Return pointer to pixel value, forcing row to be allocated.
+        AGG_INLINE pixel_type* pix_value_ptr(int x, int y, unsigned len) 
+        {
+            return (pixel_type*)(m_rbuf->row_ptr(x, y, len) + sizeof(value_type) * (x * pix_step + pix_offset));
+        }
+
+        // Return pointer to pixel value, or null if row not allocated.
+        AGG_INLINE const pixel_type* pix_value_ptr(int x, int y) const 
+        {
+            int8u* p = m_rbuf->row_ptr(y);
+            return p ? (pixel_type*)(p + sizeof(value_type) * (x * pix_step + pix_offset)) : 0;
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static pixel_type* pix_value_ptr(void* p) 
+        {
+            return (pixel_type*)((value_type*)p + pix_offset);
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static const pixel_type* pix_value_ptr(const void* p) 
+        {
+            return (const pixel_type*)((const value_type*)p + pix_offset);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static void write_plain_color(void* p, color_type c)
+        {
+            // Grayscale formats are implicitly premultiplied.
+            c.premultiply();
+            pix_value_ptr(p)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static color_type read_plain_color(const void* p)
+        {
+            return pix_value_ptr(p)->get();
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
+        {
+            ((pixel_type*)p)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE color_type pixel(int x, int y) const
+        {
+            if (const pixel_type* p = pix_value_ptr(x, y))
+            {
+                return p->get();
+            }
+            return color_type::no_color();
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
+        {
+            pix_value_ptr(x, y, 1)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
+        {
+            copy_or_blend_pix(pix_value_ptr(x, y, 1), c, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_hline(int x, int y, 
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+            do
+            {
+                p->set(c);
+                p = p->next();
+            }
+            while(--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_vline(int x, int y,
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            do
+            {
+                pix_value_ptr(x, y++, 1)->set(c);
+            }
+            while (--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_hline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         int8u cover)
+        {
+            if (!c.is_transparent())
+            {
+                pixel_type* p = pix_value_ptr(x, y, len);
+
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    do
+                    {
+                        p->set(c);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do
+                    {
+                        blend_pix(p, c, cover);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_vline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         int8u cover)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    do
+                    {
+                        pix_value_ptr(x, y++, 1)->set(c);
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do
+                    {
+                        blend_pix(pix_value_ptr(x, y++, 1), c, cover);
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_solid_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const int8u* covers)
+        {
+            if (!c.is_transparent())
+            {
+                pixel_type* p = pix_value_ptr(x, y, len);
+
+                do 
+                {
+                    if (c.is_opaque() && *covers == cover_mask)
+                    {
+                        p->set(c);
+                    }
+                    else
+                    {
+                        blend_pix(p, c, *covers);
+                    }
+                    p = p->next();
+                    ++covers;
+                }
+                while (--len);
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_solid_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const int8u* covers)
+        {
+            if (!c.is_transparent())
+            {
+                do 
+                {
+                    pixel_type* p = pix_value_ptr(x, y++, 1);
+
+                    if (c.is_opaque() && *covers == cover_mask)
+                    {
+                        p->set(c);
+                    }
+                    else
+                    {
+                        blend_pix(p, c, *covers);
+                    }
+                    ++covers;
+                }
+                while (--len);
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_hspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+
+            do 
+            {
+                p->set(*colors++);
+                p = p->next();
+            }
+            while (--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_vspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            do 
+            {
+                pix_value_ptr(x, y++, 1)->set(*colors++);
+            }
+            while (--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_color_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const int8u* covers,
+                               int8u cover)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+
+            if (covers)
+            {
+                do 
+                {
+                    copy_or_blend_pix(p, *colors++, *covers++);
+                    p = p->next();
+                }
+                while (--len);
+            }
+            else
+            {
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(p, *colors++);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(p, *colors++, cover);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+        
+
+        //--------------------------------------------------------------------
+        void blend_color_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const int8u* covers,
+                               int8u cover)
+        {
+            if (covers)
+            {
+                do 
+                {
+                    copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, *covers++);
+                }
+                while (--len);
+            }
+            else
+            {
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++);
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, cover);
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class Function> void for_each_pixel(Function f)
+        {
+            unsigned y;
+            for (y = 0; y < height(); ++y)
+            {
+                row_data r = m_rbuf->row(y);
+                if (r.ptr)
+                {
+                    unsigned len = r.x2 - r.x1 + 1;
+                    pixel_type* p = pix_value_ptr(r.x1, y, len);
+                    do
+                    {
+                        f(p->c);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_dir_gray<color_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_inv_gray<color_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf2>
+        void copy_from(const RenBuf2& from, 
+                       int xdst, int ydst,
+                       int xsrc, int ysrc,
+                       unsigned len)
+        {
+            if (const int8u* p = from.row_ptr(ysrc))
+            {
+                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
+                        p + xsrc * pix_width, 
+                        len * pix_width);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from single color, using grayscale surface as alpha channel.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_color(const SrcPixelFormatRenderer& from, 
+                              const color_type& color,
+                              int xdst, int ydst,
+                              int xsrc, int ysrc,
+                              unsigned len,
+                              int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+            typedef typename SrcPixelFormatRenderer::color_type src_color_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                do 
+                {
+                    copy_or_blend_pix(pdst, color, src_color_type::scale_cover(cover, psrc->c[0]));
+                    psrc = psrc->next();
+                    pdst = pdst->next();
+                }
+                while (--len);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from color table, using grayscale surface as indexes into table.
+        // Obviously, this only works for integer value types.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_lut(const SrcPixelFormatRenderer& from, 
+                            const color_type* color_lut,
+                            int xdst, int ydst,
+                            int xsrc, int ysrc,
+                            unsigned len,
+                            int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                do 
+                {
+                    copy_or_blend_pix(pdst, color_lut[psrc->c[0]], cover);
+                    psrc = psrc->next();
+                    pdst = pdst->next();
+                }
+                while (--len);
+            }
+        }
+
+    private:
+        rbuf_type* m_rbuf;
+    };
+
+    typedef blender_gray<gray8> blender_gray8;
+    typedef blender_gray<sgray8> blender_sgray8;
+    typedef blender_gray<gray16> blender_gray16;
+    typedef blender_gray<gray32> blender_gray32;
+
+    typedef blender_gray_pre<gray8> blender_gray8_pre;
+    typedef blender_gray_pre<sgray8> blender_sgray8_pre;
+    typedef blender_gray_pre<gray16> blender_gray16_pre;
+    typedef blender_gray_pre<gray32> blender_gray32_pre;
+
+    typedef pixfmt_alpha_blend_gray<blender_gray8, rendering_buffer> pixfmt_gray8;
+    typedef pixfmt_alpha_blend_gray<blender_sgray8, rendering_buffer> pixfmt_sgray8;
+    typedef pixfmt_alpha_blend_gray<blender_gray16, rendering_buffer> pixfmt_gray16;
+    typedef pixfmt_alpha_blend_gray<blender_gray32, rendering_buffer> pixfmt_gray32;
+
+    typedef pixfmt_alpha_blend_gray<blender_gray8_pre, rendering_buffer> pixfmt_gray8_pre;
+    typedef pixfmt_alpha_blend_gray<blender_sgray8_pre, rendering_buffer> pixfmt_sgray8_pre;
+    typedef pixfmt_alpha_blend_gray<blender_gray16_pre, rendering_buffer> pixfmt_gray16_pre;
+    typedef pixfmt_alpha_blend_gray<blender_gray32_pre, rendering_buffer> pixfmt_gray32_pre;
+}
+
+#endif
+

src/agg/agg_pixfmt_rgb.h

@@ -0,0 +1,995 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for high precision colors has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+
+#ifndef AGG_PIXFMT_RGB_INCLUDED
+#define AGG_PIXFMT_RGB_INCLUDED
+
+#include <string.h>
+#include "agg_pixfmt_base.h"
+#include "agg_rendering_buffer.h"
+
+namespace agg
+{
+
+    //=====================================================apply_gamma_dir_rgb
+    template<class ColorT, class Order, class GammaLut> class apply_gamma_dir_rgb
+    {
+    public:
+        typedef typename ColorT::value_type value_type;
+
+        apply_gamma_dir_rgb(const GammaLut& gamma) : m_gamma(gamma) {}
+
+        AGG_INLINE void operator () (value_type* p)
+        {
+            p[Order::R] = m_gamma.dir(p[Order::R]);
+            p[Order::G] = m_gamma.dir(p[Order::G]);
+            p[Order::B] = m_gamma.dir(p[Order::B]);
+        }
+
+    private:
+        const GammaLut& m_gamma;
+    };
+
+
+
+    //=====================================================apply_gamma_inv_rgb
+    template<class ColorT, class Order, class GammaLut> class apply_gamma_inv_rgb
+    {
+    public:
+        typedef typename ColorT::value_type value_type;
+
+        apply_gamma_inv_rgb(const GammaLut& gamma) : m_gamma(gamma) {}
+
+        AGG_INLINE void operator () (value_type* p)
+        {
+            p[Order::R] = m_gamma.inv(p[Order::R]);
+            p[Order::G] = m_gamma.inv(p[Order::G]);
+            p[Order::B] = m_gamma.inv(p[Order::B]);
+        }
+
+    private:
+        const GammaLut& m_gamma;
+    };
+
+
+    //=========================================================blender_rgb
+    template<class ColorT, class Order> 
+    struct blender_rgb
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        // Blend pixels using the non-premultiplied form of Alvy-Ray Smith's
+        // compositing function. Since the render buffer is opaque we skip the
+        // initial premultiply and final demultiply.
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, cr, cg, cb, color_type::mult_cover(alpha, cover));
+        }
+        
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha)
+        {
+            p[Order::R] = color_type::lerp(p[Order::R], cr, alpha);
+            p[Order::G] = color_type::lerp(p[Order::G], cg, alpha);
+            p[Order::B] = color_type::lerp(p[Order::B], cb, alpha);
+        }
+    };
+
+    //======================================================blender_rgb_pre
+    template<class ColorT, class Order> 
+    struct blender_rgb_pre
+    {
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        // Blend pixels using the premultiplied form of Alvy-Ray Smith's
+        // compositing function. 
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, 
+                color_type::mult_cover(cr, cover), 
+                color_type::mult_cover(cg, cover), 
+                color_type::mult_cover(cb, cover), 
+                color_type::mult_cover(alpha, cover));
+        }
+
+        //--------------------------------------------------------------------
+        static AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha)
+        {
+            p[Order::R] = color_type::prelerp(p[Order::R], cr, alpha);
+            p[Order::G] = color_type::prelerp(p[Order::G], cg, alpha);
+            p[Order::B] = color_type::prelerp(p[Order::B], cb, alpha);
+        }
+    };
+
+    //===================================================blender_rgb_gamma
+    template<class ColorT, class Order, class Gamma> 
+    class blender_rgb_gamma : public blender_base<ColorT, Order>
+    {
+    public:
+        typedef ColorT color_type;
+        typedef Order order_type;
+        typedef Gamma gamma_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        typedef typename color_type::long_type long_type;
+
+        //--------------------------------------------------------------------
+        blender_rgb_gamma() : m_gamma(0) {}
+        void gamma(const gamma_type& g) { m_gamma = &g; }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha, cover_type cover)
+        {
+            blend_pix(p, cr, cg, cb, color_type::mult_cover(alpha, cover));
+        }
+        
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(value_type* p, 
+            value_type cr, value_type cg, value_type cb, value_type alpha)
+        {
+            calc_type r = m_gamma->dir(p[Order::R]);
+            calc_type g = m_gamma->dir(p[Order::G]);
+            calc_type b = m_gamma->dir(p[Order::B]);
+            p[Order::R] = m_gamma->inv(color_type::downscale((m_gamma->dir(cr) - r) * alpha) + r);
+            p[Order::G] = m_gamma->inv(color_type::downscale((m_gamma->dir(cg) - g) * alpha) + g);
+            p[Order::B] = m_gamma->inv(color_type::downscale((m_gamma->dir(cb) - b) * alpha) + b);
+        }
+        
+    private:
+        const gamma_type* m_gamma;
+    };
+
+
+    //==================================================pixfmt_alpha_blend_rgb
+    template<class Blender, class RenBuf, unsigned Step, unsigned Offset = 0> 
+    class pixfmt_alpha_blend_rgb
+    {
+    public:
+        typedef pixfmt_rgb_tag pixfmt_category;
+        typedef RenBuf   rbuf_type;
+        typedef Blender  blender_type;
+        typedef typename rbuf_type::row_data row_data;
+        typedef typename blender_type::color_type color_type;
+        typedef typename blender_type::order_type order_type;
+        typedef typename color_type::value_type value_type;
+        typedef typename color_type::calc_type calc_type;
+        enum 
+        {
+            num_components = 3,
+            pix_step = Step,
+            pix_offset = Offset,
+            pix_width = sizeof(value_type) * pix_step
+        };
+        struct pixel_type
+        {
+            value_type c[num_components];
+
+            void set(value_type r, value_type g, value_type b)
+            {
+                c[order_type::R] = r;
+                c[order_type::G] = g;
+                c[order_type::B] = b;
+            }
+
+            void set(const color_type& color)
+            {
+                set(color.r, color.g, color.b);
+            }
+
+            void get(value_type& r, value_type& g, value_type& b) const
+            {
+                r = c[order_type::R];
+                g = c[order_type::G];
+                b = c[order_type::B];
+            }
+
+            color_type get() const
+            {
+                return color_type(
+                    c[order_type::R], 
+                    c[order_type::G], 
+                    c[order_type::B]);
+            }
+
+            pixel_type* next()
+            {
+                return (pixel_type*)(c + pix_step);
+            }
+
+            const pixel_type* next() const
+            {
+                return (const pixel_type*)(c + pix_step);
+            }
+
+            pixel_type* advance(int n)
+            {
+                return (pixel_type*)(c + n * pix_step);
+            }
+
+            const pixel_type* advance(int n) const
+            {
+                return (const pixel_type*)(c + n * pix_step);
+            }
+        };
+
+    private:
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, 
+            value_type r, value_type g, value_type b, value_type a, 
+            unsigned cover)
+        {
+            m_blender.blend_pix(p->c, r, g, b, a, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, 
+            value_type r, value_type g, value_type b, value_type a)
+        {
+            m_blender.blend_pix(p->c, r, g, b, a);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c, unsigned cover)
+        {
+            m_blender.blend_pix(p->c, c.r, c.g, c.b, c.a, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pix(pixel_type* p, const color_type& c)
+        {
+            m_blender.blend_pix(p->c, c.r, c.g, c.b, c.a);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c, unsigned cover)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    p->set(c);
+                }
+                else
+                {
+                    blend_pix(p, c, cover);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque())
+                {
+                    p->set(c);
+                }
+                else
+                {
+                    blend_pix(p, c);
+                }
+            }
+        }
+
+    public:
+        //--------------------------------------------------------------------
+        explicit pixfmt_alpha_blend_rgb(rbuf_type& rb) :
+            m_rbuf(&rb)
+        {}
+        void attach(rbuf_type& rb) { m_rbuf = &rb; }
+
+        //--------------------------------------------------------------------
+        template<class PixFmt>
+        bool attach(PixFmt& pixf, int x1, int y1, int x2, int y2)
+        {
+            rect_i r(x1, y1, x2, y2);
+            if (r.clip(rect_i(0, 0, pixf.width()-1, pixf.height()-1)))
+            {
+                int stride = pixf.stride();
+                m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), 
+                               (r.x2 - r.x1) + 1,
+                               (r.y2 - r.y1) + 1,
+                               stride);
+                return true;
+            }
+            return false;
+        }
+
+        //--------------------------------------------------------------------
+        Blender& blender() { return m_blender; }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE unsigned width()  const { return m_rbuf->width();  }
+        AGG_INLINE unsigned height() const { return m_rbuf->height(); }
+        AGG_INLINE int      stride() const { return m_rbuf->stride(); }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       int8u* row_ptr(int y)       { return m_rbuf->row_ptr(y); }
+        AGG_INLINE const int8u* row_ptr(int y) const { return m_rbuf->row_ptr(y); }
+        AGG_INLINE row_data     row(int y)     const { return m_rbuf->row(y); }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE int8u* pix_ptr(int x, int y) 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step + pix_offset);
+        }
+
+        AGG_INLINE const int8u* pix_ptr(int x, int y) const 
+        { 
+            return m_rbuf->row_ptr(y) + sizeof(value_type) * (x * pix_step + pix_offset);
+        }
+
+        // Return pointer to pixel value, forcing row to be allocated.
+        AGG_INLINE pixel_type* pix_value_ptr(int x, int y, unsigned len) 
+        {
+            return (pixel_type*)(m_rbuf->row_ptr(x, y, len) + sizeof(value_type) * (x * pix_step + pix_offset));
+        }
+
+        // Return pointer to pixel value, or null if row not allocated.
+        AGG_INLINE const pixel_type* pix_value_ptr(int x, int y) const 
+        {
+            int8u* p = m_rbuf->row_ptr(y);
+            return p ? (pixel_type*)(p + sizeof(value_type) * (x * pix_step + pix_offset)) : 0;
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static pixel_type* pix_value_ptr(void* p) 
+        {
+            return (pixel_type*)((value_type*)p + pix_offset);
+        }
+
+        // Get pixel pointer from raw buffer pointer.
+        AGG_INLINE static const pixel_type* pix_value_ptr(const void* p) 
+        {
+            return (const pixel_type*)((const value_type*)p + pix_offset);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static void write_plain_color(void* p, color_type c)
+        {
+            // RGB formats are implicitly premultiplied.
+            c.premultiply();
+            pix_value_ptr(p)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static color_type read_plain_color(const void* p)
+        {
+            return pix_value_ptr(p)->get();
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE static void make_pix(int8u* p, const color_type& c)
+        {
+            ((pixel_type*)p)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE color_type pixel(int x, int y) const
+        {
+            if (const pixel_type* p = pix_value_ptr(x, y))
+            {
+                return p->get();
+            }
+            return color_type::no_color();
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
+        {
+            pix_value_ptr(x, y, 1)->set(c);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
+        {
+            copy_or_blend_pix(pix_value_ptr(x, y, 1), c, cover);
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_hline(int x, int y, 
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+            do
+            {
+                p->set(c);
+                p = p->next();
+            }
+            while(--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        AGG_INLINE void copy_vline(int x, int y,
+                                   unsigned len, 
+                                   const color_type& c)
+        {
+            do
+            {
+                pix_value_ptr(x, y++, 1)->set(c);
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_hline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         int8u cover)
+        {
+            if (!c.is_transparent())
+            {
+                pixel_type* p = pix_value_ptr(x, y, len);
+
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    do
+                    {
+                        p->set(c);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do
+                    {
+                        blend_pix(p, c, cover);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_vline(int x, int y,
+                         unsigned len, 
+                         const color_type& c,
+                         int8u cover)
+        {
+            if (!c.is_transparent())
+            {
+                if (c.is_opaque() && cover == cover_mask)
+                {
+                    do
+                    {
+                        pix_value_ptr(x, y++, 1)->set(c);
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do
+                    {
+                        blend_pix(pix_value_ptr(x, y++, 1), c, cover);
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void blend_solid_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const int8u* covers)
+        {
+            if (!c.is_transparent())
+            {
+                pixel_type* p = pix_value_ptr(x, y, len);
+
+                do 
+                {
+                    if (c.is_opaque() && *covers == cover_mask)
+                    {
+                        p->set(c);
+                    }
+                    else
+                    {
+                        blend_pix(p, c, *covers);
+                    }
+                    p = p->next();
+                    ++covers;
+                }
+                while (--len);
+            }
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_solid_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type& c,
+                               const int8u* covers)
+        {
+            if (!c.is_transparent())
+            {
+                do 
+                {
+                    pixel_type* p = pix_value_ptr(x, y++, 1);
+
+                    if (c.is_opaque() && *covers == cover_mask)
+                    {
+                        p->set(c);
+                    }
+                    else
+                    {
+                        blend_pix(p, c, *covers);
+                    }
+                    ++covers;
+                }
+                while (--len);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void copy_color_hspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+
+            do 
+            {
+                p->set(*colors++);
+                p = p->next();
+            }
+            while (--len);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_vspan(int x, int y,
+                              unsigned len, 
+                              const color_type* colors)
+        {
+            do 
+            {
+                pix_value_ptr(x, y++, 1)->set(*colors++);
+            }
+            while (--len);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_color_hspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const int8u* covers,
+                               int8u cover)
+        {
+            pixel_type* p = pix_value_ptr(x, y, len);
+
+            if (covers)
+            {
+                do 
+                {
+                    copy_or_blend_pix(p, *colors++, *covers++);
+                    p = p->next();
+                }
+                while (--len);
+            }
+            else
+            {
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(p, *colors++);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(p, *colors++, cover);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void blend_color_vspan(int x, int y,
+                               unsigned len, 
+                               const color_type* colors,
+                               const int8u* covers,
+                               int8u cover)
+        {
+            if (covers)
+            {
+                do 
+                {
+                    copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, *covers++);
+                }
+                while (--len);
+            }
+            else
+            {
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++);
+                    }
+                    while (--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, cover);
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class Function> void for_each_pixel(Function f)
+        {
+            for (unsigned y = 0; y < height(); ++y)
+            {
+                row_data r = m_rbuf->row(y);
+                if (r.ptr)
+                {
+                    unsigned len = r.x2 - r.x1 + 1;
+                    pixel_type* p = pix_value_ptr(r.x1, y, len);
+                    do
+                    {
+                        f(p->c);
+                        p = p->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_dir_rgb<color_type, order_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
+        {
+            for_each_pixel(apply_gamma_inv_rgb<color_type, order_type, GammaLut>(g));
+        }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf2>
+        void copy_from(const RenBuf2& from, 
+                       int xdst, int ydst,
+                       int xsrc, int ysrc,
+                       unsigned len)
+        {
+            if (const int8u* p = from.row_ptr(ysrc))
+            {
+                memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, 
+                        p + xsrc * pix_width, 
+                        len * pix_width);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from an RGBA surface.
+        template<class SrcPixelFormatRenderer>
+        void blend_from(const SrcPixelFormatRenderer& from, 
+                        int xdst, int ydst,
+                        int xsrc, int ysrc,
+                        unsigned len,
+                        int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+            typedef typename SrcPixelFormatRenderer::order_type src_order;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        value_type alpha = psrc->c[src_order::A];
+                        if (alpha <= color_type::empty_value())
+                        {
+                            if (alpha >= color_type::full_value())
+                            {
+                                pdst->c[order_type::R] = psrc->c[src_order::R];
+                                pdst->c[order_type::G] = psrc->c[src_order::G];
+                                pdst->c[order_type::B] = psrc->c[src_order::B];
+                            }
+                            else
+                            {
+                                blend_pix(pdst, 
+                                    psrc->c[src_order::R],
+                                    psrc->c[src_order::G],
+                                    psrc->c[src_order::B],
+                                    alpha);
+                            }
+                        }
+                        psrc = psrc->next();
+                        pdst = pdst->next();
+                    }
+                    while(--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pdst, psrc->get(), cover);
+                        psrc = psrc->next();
+                        pdst = pdst->next();
+                    }
+                    while (--len);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from single color, using grayscale surface as alpha channel.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_color(const SrcPixelFormatRenderer& from, 
+                              const color_type& color,
+                              int xdst, int ydst,
+                              int xsrc, int ysrc,
+                              unsigned len,
+                              int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+            typedef typename SrcPixelFormatRenderer::color_type src_color_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                do 
+                {
+                    copy_or_blend_pix(pdst, color, src_color_type::scale_cover(cover, psrc->c[0]));
+                    psrc = psrc->next();
+                    pdst = pdst->next();
+                }
+                while (--len);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        // Blend from color table, using grayscale surface as indexes into table. 
+        // Obviously, this only works for integer value types.
+        template<class SrcPixelFormatRenderer>
+        void blend_from_lut(const SrcPixelFormatRenderer& from, 
+                            const color_type* color_lut,
+                            int xdst, int ydst,
+                            int xsrc, int ysrc,
+                            unsigned len,
+                            int8u cover)
+        {
+            typedef typename SrcPixelFormatRenderer::pixel_type src_pixel_type;
+
+            if (const src_pixel_type* psrc = from.pix_value_ptr(xsrc, ysrc))
+            {
+                pixel_type* pdst = pix_value_ptr(xdst, ydst, len);
+
+                if (cover == cover_mask)
+                {
+                    do 
+                    {
+                        const color_type& color = color_lut[psrc->c[0]];
+                        blend_pix(pdst, color);
+                        psrc = psrc->next();
+                        pdst = pdst->next();
+                    }
+                    while(--len);
+                }
+                else
+                {
+                    do 
+                    {
+                        copy_or_blend_pix(pdst, color_lut[psrc->c[0]], cover);
+                        psrc = psrc->next();
+                        pdst = pdst->next();
+                    }
+                    while(--len);
+                }
+            }
+        }
+
+    private:
+        rbuf_type* m_rbuf;
+        Blender    m_blender;
+    };
+    
+    //-----------------------------------------------------------------------
+    typedef blender_rgb<rgba8, order_rgb> blender_rgb24;
+    typedef blender_rgb<rgba8, order_bgr> blender_bgr24;
+    typedef blender_rgb<srgba8, order_rgb> blender_srgb24;
+    typedef blender_rgb<srgba8, order_bgr> blender_sbgr24;
+    typedef blender_rgb<rgba16, order_rgb> blender_rgb48;
+    typedef blender_rgb<rgba16, order_bgr> blender_bgr48;
+    typedef blender_rgb<rgba32, order_rgb> blender_rgb96;
+    typedef blender_rgb<rgba32, order_bgr> blender_bgr96;
+
+    typedef blender_rgb_pre<rgba8, order_rgb> blender_rgb24_pre;
+    typedef blender_rgb_pre<rgba8, order_bgr> blender_bgr24_pre;
+    typedef blender_rgb_pre<srgba8, order_rgb> blender_srgb24_pre;
+    typedef blender_rgb_pre<srgba8, order_bgr> blender_sbgr24_pre;
+    typedef blender_rgb_pre<rgba16, order_rgb> blender_rgb48_pre;
+    typedef blender_rgb_pre<rgba16, order_bgr> blender_bgr48_pre;
+    typedef blender_rgb_pre<rgba32, order_rgb> blender_rgb96_pre;
+    typedef blender_rgb_pre<rgba32, order_bgr> blender_bgr96_pre;
+
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24, rendering_buffer, 3> pixfmt_rgb24;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24, rendering_buffer, 3> pixfmt_bgr24;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24, rendering_buffer, 3> pixfmt_srgb24;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24, rendering_buffer, 3> pixfmt_sbgr24;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48, rendering_buffer, 3> pixfmt_rgb48;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48, rendering_buffer, 3> pixfmt_bgr48;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96, rendering_buffer, 3> pixfmt_rgb96;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96, rendering_buffer, 3> pixfmt_bgr96;
+
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24_pre, rendering_buffer, 3> pixfmt_rgb24_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24_pre, rendering_buffer, 3> pixfmt_bgr24_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24_pre, rendering_buffer, 3> pixfmt_srgb24_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24_pre, rendering_buffer, 3> pixfmt_sbgr24_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48_pre, rendering_buffer, 3> pixfmt_rgb48_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48_pre, rendering_buffer, 3> pixfmt_bgr48_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96_pre, rendering_buffer, 3> pixfmt_rgb96_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96_pre, rendering_buffer, 3> pixfmt_bgr96_pre;
+
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24, rendering_buffer, 4, 0> pixfmt_rgbx32;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24, rendering_buffer, 4, 1> pixfmt_xrgb32;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24, rendering_buffer, 4, 1> pixfmt_xbgr32;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24, rendering_buffer, 4, 0> pixfmt_bgrx32;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24, rendering_buffer, 4, 0> pixfmt_srgbx32;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24, rendering_buffer, 4, 1> pixfmt_sxrgb32;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24, rendering_buffer, 4, 1> pixfmt_sxbgr32;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24, rendering_buffer, 4, 0> pixfmt_sbgrx32;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48, rendering_buffer, 4, 0> pixfmt_rgbx64;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48, rendering_buffer, 4, 1> pixfmt_xrgb64;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48, rendering_buffer, 4, 1> pixfmt_xbgr64;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48, rendering_buffer, 4, 0> pixfmt_bgrx64;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96, rendering_buffer, 4, 0> pixfmt_rgbx128;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96, rendering_buffer, 4, 1> pixfmt_xrgb128;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96, rendering_buffer, 4, 1> pixfmt_xbgr128;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96, rendering_buffer, 4, 0> pixfmt_bgrx128;
+
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24_pre, rendering_buffer, 4, 0> pixfmt_rgbx32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb24_pre, rendering_buffer, 4, 1> pixfmt_xrgb32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24_pre, rendering_buffer, 4, 1> pixfmt_xbgr32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr24_pre, rendering_buffer, 4, 0> pixfmt_bgrx32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24_pre, rendering_buffer, 4, 0> pixfmt_srgbx32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_srgb24_pre, rendering_buffer, 4, 1> pixfmt_sxrgb32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24_pre, rendering_buffer, 4, 1> pixfmt_sxbgr32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_sbgr24_pre, rendering_buffer, 4, 0> pixfmt_sbgrx32_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48_pre, rendering_buffer, 4, 0> pixfmt_rgbx64_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb48_pre, rendering_buffer, 4, 1> pixfmt_xrgb64_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48_pre, rendering_buffer, 4, 1> pixfmt_xbgr64_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr48_pre, rendering_buffer, 4, 0> pixfmt_bgrx64_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96_pre, rendering_buffer, 4, 0> pixfmt_rgbx128_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_rgb96_pre, rendering_buffer, 4, 1> pixfmt_xrgb128_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96_pre, rendering_buffer, 4, 1> pixfmt_xbgr128_pre;
+    typedef pixfmt_alpha_blend_rgb<blender_bgr96_pre, rendering_buffer, 4, 0> pixfmt_bgrx128_pre;
+    
+
+    //-----------------------------------------------------pixfmt_rgb24_gamma
+    template<class Gamma> class pixfmt_rgb24_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_rgb24_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+        
+    //-----------------------------------------------------pixfmt_srgb24_gamma
+    template<class Gamma> class pixfmt_srgb24_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<srgba8, order_rgb, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_srgb24_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<srgba8, order_rgb, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+        
+    //-----------------------------------------------------pixfmt_bgr24_gamma
+    template<class Gamma> class pixfmt_bgr24_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_bgr24_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+
+    //-----------------------------------------------------pixfmt_sbgr24_gamma
+    template<class Gamma> class pixfmt_sbgr24_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<srgba8, order_bgr, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_sbgr24_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<srgba8, order_bgr, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+
+    //-----------------------------------------------------pixfmt_rgb48_gamma
+    template<class Gamma> class pixfmt_rgb48_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_rgb48_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+        
+    //-----------------------------------------------------pixfmt_bgr48_gamma
+    template<class Gamma> class pixfmt_bgr48_gamma : 
+    public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer, 3>
+    {
+    public:
+        pixfmt_bgr48_gamma(rendering_buffer& rb, const Gamma& g) :
+            pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer, 3>(rb) 
+        {
+            this->blender().gamma(g);
+        }
+    };
+    
+}
+
+#endif
+

src/agg/agg_rasterizer_cells_aa.h

@@ -0,0 +1,741 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+//
+// The author gratefully acknowleges the support of David Turner, 
+// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
+// libray - in producing this work. See http://www.freetype.org for details.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+#ifndef AGG_RASTERIZER_CELLS_AA_INCLUDED
+#define AGG_RASTERIZER_CELLS_AA_INCLUDED
+
+#include <string.h>
+#include <cstdlib>
+#include <limits>
+#include "agg_math.h"
+#include "agg_array.h"
+
+
+namespace agg
+{
+
+    //-----------------------------------------------------rasterizer_cells_aa
+    // An internal class that implements the main rasterization algorithm.
+    // Used in the rasterizer. Should not be used direcly.
+    template<class Cell> class rasterizer_cells_aa
+    {
+        enum cell_block_scale_e
+        {
+            cell_block_shift = 12,
+            cell_block_size  = 1 << cell_block_shift,
+            cell_block_mask  = cell_block_size - 1,
+            cell_block_pool  = 256,
+            cell_block_limit = 1024
+        };
+
+        struct sorted_y
+        {
+            unsigned start;
+            unsigned num;
+        };
+
+    public:
+        typedef Cell cell_type;
+        typedef rasterizer_cells_aa<Cell> self_type;
+
+        ~rasterizer_cells_aa();
+        rasterizer_cells_aa();
+
+        void reset();
+        void style(const cell_type& style_cell);
+        void line(int x1, int y1, int x2, int y2);
+
+        int min_x() const { return m_min_x; }
+        int min_y() const { return m_min_y; }
+        int max_x() const { return m_max_x; }
+        int max_y() const { return m_max_y; }
+
+        void sort_cells();
+
+        unsigned total_cells() const 
+        {
+            return m_num_cells;
+        }
+
+        unsigned scanline_num_cells(unsigned y) const 
+        { 
+            return m_sorted_y[y - m_min_y].num; 
+        }
+
+        const cell_type* const* scanline_cells(unsigned y) const
+        { 
+            return m_sorted_cells.data() + m_sorted_y[y - m_min_y].start; 
+        }
+
+        bool sorted() const { return m_sorted; }
+
+    private:
+        rasterizer_cells_aa(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        void set_curr_cell(int x, int y);
+        void add_curr_cell();
+        void render_hline(int ey, int x1, int y1, int x2, int y2);
+        void allocate_block();
+        
+    private:
+        unsigned                m_num_blocks;
+        unsigned                m_max_blocks;
+        unsigned                m_curr_block;
+        unsigned                m_num_cells;
+        cell_type**             m_cells;
+        cell_type*              m_curr_cell_ptr;
+        pod_vector<cell_type*>  m_sorted_cells;
+        pod_vector<sorted_y>    m_sorted_y;
+        cell_type               m_curr_cell;
+        cell_type               m_style_cell;
+        int                     m_min_x;
+        int                     m_min_y;
+        int                     m_max_x;
+        int                     m_max_y;
+        bool                    m_sorted;
+    };
+
+
+
+
+    //------------------------------------------------------------------------
+    template<class Cell> 
+    rasterizer_cells_aa<Cell>::~rasterizer_cells_aa()
+    {
+        if(m_num_blocks)
+        {
+            cell_type** ptr = m_cells + m_num_blocks - 1;
+            while(m_num_blocks--)
+            {
+                pod_allocator<cell_type>::deallocate(*ptr, cell_block_size);
+                ptr--;
+            }
+            pod_allocator<cell_type*>::deallocate(m_cells, m_max_blocks);
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell> 
+    rasterizer_cells_aa<Cell>::rasterizer_cells_aa() :
+        m_num_blocks(0),
+        m_max_blocks(0),
+        m_curr_block(0),
+        m_num_cells(0),
+        m_cells(0),
+        m_curr_cell_ptr(0),
+        m_sorted_cells(),
+        m_sorted_y(),
+        m_min_x(std::numeric_limits<int>::max()),
+        m_min_y(std::numeric_limits<int>::max()),
+        m_max_x(std::numeric_limits<int>::min()),
+        m_max_y(std::numeric_limits<int>::min()),
+        m_sorted(false)
+    {
+        m_style_cell.initial();
+        m_curr_cell.initial();
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell> 
+    void rasterizer_cells_aa<Cell>::reset()
+    {
+        m_num_cells = 0; 
+        m_curr_block = 0;
+        m_curr_cell.initial();
+        m_style_cell.initial();
+        m_sorted = false;
+        m_min_x = std::numeric_limits<int>::max();
+        m_min_y = std::numeric_limits<int>::max();
+        m_max_x = std::numeric_limits<int>::min();
+        m_max_y = std::numeric_limits<int>::min();
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell> 
+    AGG_INLINE void rasterizer_cells_aa<Cell>::add_curr_cell()
+    {
+        if(m_curr_cell.area | m_curr_cell.cover)
+        {
+            if((m_num_cells & cell_block_mask) == 0)
+            {
+                if(m_num_blocks >= cell_block_limit) return;
+                allocate_block();
+            }
+            *m_curr_cell_ptr++ = m_curr_cell;
+            ++m_num_cells;
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell> 
+    AGG_INLINE void rasterizer_cells_aa<Cell>::set_curr_cell(int x, int y)
+    {
+        if(m_curr_cell.not_equal(x, y, m_style_cell))
+        {
+            add_curr_cell();
+            m_curr_cell.style(m_style_cell);
+            m_curr_cell.x     = x;
+            m_curr_cell.y     = y;
+            m_curr_cell.cover = 0;
+            m_curr_cell.area  = 0;
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell> 
+    AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey, 
+                                                            int x1, int y1, 
+                                                            int x2, int y2)
+    {
+        int ex1 = x1 >> poly_subpixel_shift;
+        int ex2 = x2 >> poly_subpixel_shift;
+        int fx1 = x1 & poly_subpixel_mask;
+        int fx2 = x2 & poly_subpixel_mask;
+
+        int delta, p, first;
+        long long dx;
+        int incr, lift, mod, rem;
+
+        //trivial case. Happens often
+        if(y1 == y2)
+        {
+            set_curr_cell(ex2, ey);
+            return;
+        }
+
+        //everything is located in a single cell.  That is easy!
+        if(ex1 == ex2)
+        {
+            delta = y2 - y1;
+            m_curr_cell.cover += delta;
+            m_curr_cell.area  += (fx1 + fx2) * delta;
+            return;
+        }
+
+        //ok, we'll have to render a run of adjacent cells on the same
+        //hline...
+        p     = (poly_subpixel_scale - fx1) * (y2 - y1);
+        first = poly_subpixel_scale;
+        incr  = 1;
+
+        dx = (long long)x2 - (long long)x1;
+
+        if(dx < 0)
+        {
+            p     = fx1 * (y2 - y1);
+            first = 0;
+            incr  = -1;
+            dx    = -dx;
+        }
+
+        delta = (int)(p / dx);
+        mod   = (int)(p % dx);
+
+        if(mod < 0)
+        {
+            delta--;
+            mod += static_cast<int>(dx);
+        }
+
+        m_curr_cell.cover += delta;
+        m_curr_cell.area  += (fx1 + first) * delta;
+
+        ex1 += incr;
+        set_curr_cell(ex1, ey);
+        y1  += delta;
+
+        if(ex1 != ex2)
+        {
+            p     = poly_subpixel_scale * (y2 - y1 + delta);
+            lift  = (int)(p / dx);
+            rem   = (int)(p % dx);
+
+            if (rem < 0)
+            {
+                lift--;
+                rem += static_cast<int>(dx);
+            }
+
+            mod -= static_cast<int>(dx);
+
+            while (ex1 != ex2)
+            {
+                delta = lift;
+                mod  += rem;
+                if(mod >= 0)
+                {
+                    mod -= static_cast<int>(dx);
+                    delta++;
+                }
+
+                m_curr_cell.cover += delta;
+                m_curr_cell.area  += poly_subpixel_scale * delta;
+                y1  += delta;
+                ex1 += incr;
+                set_curr_cell(ex1, ey);
+            }
+        }
+        delta = y2 - y1;
+        m_curr_cell.cover += delta;
+        m_curr_cell.area  += (fx2 + poly_subpixel_scale - first) * delta;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell> 
+    AGG_INLINE void rasterizer_cells_aa<Cell>::style(const cell_type& style_cell)
+    { 
+        m_style_cell.style(style_cell); 
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell> 
+    void rasterizer_cells_aa<Cell>::line(int x1, int y1, int x2, int y2)
+    {
+        enum dx_limit_e { dx_limit = 16384 << poly_subpixel_shift };
+
+        long long dx = (long long)x2 - (long long)x1;
+
+        if(dx >= dx_limit || dx <= -dx_limit)
+        {
+            int cx = (int)(((long long)x1 + (long long)x2) >> 1);
+            int cy = (int)(((long long)y1 + (long long)y2) >> 1);
+            line(x1, y1, cx, cy);
+            line(cx, cy, x2, y2);
+        }
+
+        long long dy = (long long)y2 - (long long)y1;
+        int ex1 = x1 >> poly_subpixel_shift;
+        int ex2 = x2 >> poly_subpixel_shift;
+        int ey1 = y1 >> poly_subpixel_shift;
+        int ey2 = y2 >> poly_subpixel_shift;
+        int fy1 = y1 & poly_subpixel_mask;
+        int fy2 = y2 & poly_subpixel_mask;
+
+        int x_from, x_to;
+        int rem, mod, lift, delta, first, incr;
+        long long p;
+
+        if(ex1 < m_min_x) m_min_x = ex1;
+        if(ex1 > m_max_x) m_max_x = ex1;
+        if(ey1 < m_min_y) m_min_y = ey1;
+        if(ey1 > m_max_y) m_max_y = ey1;
+        if(ex2 < m_min_x) m_min_x = ex2;
+        if(ex2 > m_max_x) m_max_x = ex2;
+        if(ey2 < m_min_y) m_min_y = ey2;
+        if(ey2 > m_max_y) m_max_y = ey2;
+
+        set_curr_cell(ex1, ey1);
+
+        //everything is on a single hline
+        if(ey1 == ey2)
+        {
+            render_hline(ey1, x1, fy1, x2, fy2);
+            return;
+        }
+
+        //Vertical line - we have to calculate start and end cells,
+        //and then - the common values of the area and coverage for
+        //all cells of the line. We know exactly there's only one 
+        //cell, so, we don't have to call render_hline().
+        incr  = 1;
+        if(dx == 0)
+        {
+            int ex = x1 >> poly_subpixel_shift;
+            int two_fx = (x1 - (ex << poly_subpixel_shift)) << 1;
+            int area;
+
+            first = poly_subpixel_scale;
+            if(dy < 0)
+            {
+                first = 0;
+                incr  = -1;
+            }
+
+            x_from = x1;
+
+            //render_hline(ey1, x_from, fy1, x_from, first);
+            delta = first - fy1;
+            m_curr_cell.cover += delta;
+            m_curr_cell.area  += two_fx * delta;
+
+            ey1 += incr;
+            set_curr_cell(ex, ey1);
+
+            delta = first + first - poly_subpixel_scale;
+            area = two_fx * delta;
+            while(ey1 != ey2)
+            {
+                //render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, first);
+                m_curr_cell.cover = delta;
+                m_curr_cell.area  = area;
+                ey1 += incr;
+                set_curr_cell(ex, ey1);
+            }
+            //render_hline(ey1, x_from, poly_subpixel_scale - first, x_from, fy2);
+            delta = fy2 - poly_subpixel_scale + first;
+            m_curr_cell.cover += delta;
+            m_curr_cell.area  += two_fx * delta;
+            return;
+        }
+
+        //ok, we have to render several hlines
+        p     = (poly_subpixel_scale - fy1) * dx;
+        first = poly_subpixel_scale;
+
+        if(dy < 0)
+        {
+            p     = fy1 * dx;
+            first = 0;
+            incr  = -1;
+            dy    = -dy;
+        }
+
+        delta = (int)(p / dy);
+        mod   = (int)(p % dy);
+
+        if(mod < 0)
+        {
+            delta--;
+            mod += static_cast<int>(dy);
+        }
+
+        x_from = x1 + delta;
+        render_hline(ey1, x1, fy1, x_from, first);
+
+        ey1 += incr;
+        set_curr_cell(x_from >> poly_subpixel_shift, ey1);
+
+        if(ey1 != ey2)
+        {
+            p     = poly_subpixel_scale * dx;
+            lift  = (int)(p / dy);
+            rem   = (int)(p % dy);
+
+            if(rem < 0)
+            {
+                lift--;
+                rem += static_cast<int>(dy);
+            }
+            mod -= static_cast<int>(dy);
+
+            while(ey1 != ey2)
+            {
+                delta = lift;
+                mod  += rem;
+                if (mod >= 0)
+                {
+                    mod -= static_cast<int>(dy);
+                    delta++;
+                }
+
+                x_to = x_from + delta;
+                render_hline(ey1, x_from, poly_subpixel_scale - first, x_to, first);
+                x_from = x_to;
+
+                ey1 += incr;
+                set_curr_cell(x_from >> poly_subpixel_shift, ey1);
+            }
+        }
+        render_hline(ey1, x_from, poly_subpixel_scale - first, x2, fy2);
+    }
+
+    //------------------------------------------------------------------------
+    template<class Cell> 
+    void rasterizer_cells_aa<Cell>::allocate_block()
+    {
+        if(m_curr_block >= m_num_blocks)
+        {
+            if(m_num_blocks >= m_max_blocks)
+            {
+                cell_type** new_cells = 
+                    pod_allocator<cell_type*>::allocate(m_max_blocks + 
+                                                        cell_block_pool);
+
+                if(m_cells)
+                {
+                    memcpy(new_cells, m_cells, m_max_blocks * sizeof(cell_type*));
+                    pod_allocator<cell_type*>::deallocate(m_cells, m_max_blocks);
+                }
+                m_cells = new_cells;
+                m_max_blocks += cell_block_pool;
+            }
+
+            m_cells[m_num_blocks++] = 
+                pod_allocator<cell_type>::allocate(cell_block_size);
+
+        }
+        m_curr_cell_ptr = m_cells[m_curr_block++];
+    }
+
+
+
+    //------------------------------------------------------------------------
+    template <class T> static AGG_INLINE void swap_cells(T* a, T* b)
+    {
+        T temp = *a;
+        *a = *b;
+        *b = temp;
+    }
+
+
+    //------------------------------------------------------------------------
+    enum
+    {
+        qsort_threshold = 9
+    };
+
+
+    //------------------------------------------------------------------------
+    template<class Cell>
+    void qsort_cells(Cell** start, unsigned num)
+    {
+        Cell**  stack[80];
+        Cell*** top; 
+        Cell**  limit;
+        Cell**  base;
+
+        limit = start + num;
+        base  = start;
+        top   = stack;
+
+        for (;;)
+        {
+            int len = int(limit - base);
+
+            Cell** i;
+            Cell** j;
+            Cell** pivot;
+
+            if(len > qsort_threshold)
+            {
+                // we use base + len/2 as the pivot
+                pivot = base + len / 2;
+                swap_cells(base, pivot);
+
+                i = base + 1;
+                j = limit - 1;
+
+                // now ensure that *i <= *base <= *j 
+                if((*j)->x < (*i)->x)
+                {
+                    swap_cells(i, j);
+                }
+
+                if((*base)->x < (*i)->x)
+                {
+                    swap_cells(base, i);
+                }
+
+                if((*j)->x < (*base)->x)
+                {
+                    swap_cells(base, j);
+                }
+
+                for(;;)
+                {
+                    int x = (*base)->x;
+                    do i++; while( (*i)->x < x );
+                    do j--; while( x < (*j)->x );
+
+                    if(i > j)
+                    {
+                        break;
+                    }
+
+                    swap_cells(i, j);
+                }
+
+                swap_cells(base, j);
+
+                // now, push the largest sub-array
+                if(j - base > limit - i)
+                {
+                    top[0] = base;
+                    top[1] = j;
+                    base   = i;
+                }
+                else
+                {
+                    top[0] = i;
+                    top[1] = limit;
+                    limit  = j;
+                }
+                top += 2;
+            }
+            else
+            {
+                // the sub-array is small, perform insertion sort
+                j = base;
+                i = j + 1;
+
+                for(; i < limit; j = i, i++)
+                {
+                    for(; j[1]->x < (*j)->x; j--)
+                    {
+                        swap_cells(j + 1, j);
+                        if (j == base)
+                        {
+                            break;
+                        }
+                    }
+                }
+
+                if(top > stack)
+                {
+                    top  -= 2;
+                    base  = top[0];
+                    limit = top[1];
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class Cell> 
+    void rasterizer_cells_aa<Cell>::sort_cells()
+    {
+        if(m_sorted) return; //Perform sort only the first time.
+
+        add_curr_cell();
+        m_curr_cell.x     = std::numeric_limits<int>::max();
+        m_curr_cell.y     = std::numeric_limits<int>::max();
+        m_curr_cell.cover = 0;
+        m_curr_cell.area  = 0;
+
+        if(m_num_cells == 0) return;
+
+// DBG: Check to see if min/max works well.
+//for(unsigned nc = 0; nc < m_num_cells; nc++)
+//{
+//    cell_type* cell = m_cells[nc >> cell_block_shift] + (nc & cell_block_mask);
+//    if(cell->x < m_min_x || 
+//       cell->y < m_min_y || 
+//       cell->x > m_max_x || 
+//       cell->y > m_max_y)
+//    {
+//        cell = cell; // Breakpoint here
+//    }
+//}
+        // Allocate the array of cell pointers
+        m_sorted_cells.allocate(m_num_cells, 16);
+
+        // Allocate and zero the Y array
+        m_sorted_y.allocate(m_max_y - m_min_y + 1, 16);
+        m_sorted_y.zero();
+
+        // Create the Y-histogram (count the numbers of cells for each Y)
+        cell_type** block_ptr = m_cells;
+        cell_type*  cell_ptr;
+        unsigned nb = m_num_cells;
+        unsigned i;
+        while(nb)
+        {
+            cell_ptr = *block_ptr++;
+            i = (nb > cell_block_size) ? unsigned(cell_block_size) : nb;
+            nb -= i;
+            while(i--) 
+            {
+                m_sorted_y[cell_ptr->y - m_min_y].start++;
+                ++cell_ptr;
+            }
+        }
+
+        // Convert the Y-histogram into the array of starting indexes
+        unsigned start = 0;
+        for(i = 0; i < m_sorted_y.size(); i++)
+        {
+            unsigned v = m_sorted_y[i].start;
+            m_sorted_y[i].start = start;
+            start += v;
+        }
+
+        // Fill the cell pointer array sorted by Y
+        block_ptr = m_cells;
+        nb = m_num_cells;
+        while(nb)
+        {
+            cell_ptr = *block_ptr++;
+            i = (nb > cell_block_size) ? unsigned(cell_block_size) : nb;
+            nb -= i;
+            while(i--)
+            {
+                sorted_y& curr_y = m_sorted_y[cell_ptr->y - m_min_y];
+                m_sorted_cells[curr_y.start + curr_y.num] = cell_ptr;
+                ++curr_y.num;
+                ++cell_ptr;
+            }
+        }
+        
+        // Finally arrange the X-arrays
+        for(i = 0; i < m_sorted_y.size(); i++)
+        {
+            const sorted_y& curr_y = m_sorted_y[i];
+            if(curr_y.num)
+            {
+                qsort_cells(m_sorted_cells.data() + curr_y.start, curr_y.num);
+            }
+        }
+        m_sorted = true;
+    }
+
+
+
+    //------------------------------------------------------scanline_hit_test
+    class scanline_hit_test
+    {
+    public:
+        scanline_hit_test(int x) : m_x(x), m_hit(false) {}
+
+        void reset_spans() {}
+        void finalize(int) {}
+        void add_cell(int x, int)
+        {
+            if(m_x == x) m_hit = true;
+        }
+        void add_span(int x, int len, int)
+        {
+            if(m_x >= x && m_x < x+len) m_hit = true;
+        }
+        unsigned num_spans() const { return 1; }
+        bool hit() const { return m_hit; }
+
+    private:
+        int  m_x;
+        bool m_hit;
+    };
+
+
+}
+
+#endif

src/agg/agg_rasterizer_scanline_aa.h

@@ -0,0 +1,481 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+//
+// The author gratefully acknowleges the support of David Turner, 
+// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
+// libray - in producing this work. See http://www.freetype.org for details.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+#ifndef AGG_RASTERIZER_SCANLINE_AA_INCLUDED
+#define AGG_RASTERIZER_SCANLINE_AA_INCLUDED
+
+#include "agg_rasterizer_cells_aa.h"
+#include "agg_rasterizer_sl_clip.h"
+#include "agg_rasterizer_scanline_aa_nogamma.h"
+#include "agg_gamma_functions.h"
+
+
+namespace agg
+{
+    //==================================================rasterizer_scanline_aa
+    // Polygon rasterizer that is used to render filled polygons with 
+    // high-quality Anti-Aliasing. Internally, by default, the class uses 
+    // integer coordinates in format 24.8, i.e. 24 bits for integer part 
+    // and 8 bits for fractional - see poly_subpixel_shift. This class can be 
+    // used in the following  way:
+    //
+    // 1. filling_rule(filling_rule_e ft) - optional.
+    //
+    // 2. gamma() - optional.
+    //
+    // 3. reset()
+    //
+    // 4. move_to(x, y) / line_to(x, y) - make the polygon. One can create 
+    //    more than one contour, but each contour must consist of at least 3
+    //    vertices, i.e. move_to(x1, y1); line_to(x2, y2); line_to(x3, y3);
+    //    is the absolute minimum of vertices that define a triangle.
+    //    The algorithm does not check either the number of vertices nor
+    //    coincidence of their coordinates, but in the worst case it just 
+    //    won't draw anything.
+    //    The orger of the vertices (clockwise or counterclockwise) 
+    //    is important when using the non-zero filling rule (fill_non_zero).
+    //    In this case the vertex order of all the contours must be the same
+    //    if you want your intersecting polygons to be without "holes".
+    //    You actually can use different vertices order. If the contours do not 
+    //    intersect each other the order is not important anyway. If they do, 
+    //    contours with the same vertex order will be rendered without "holes" 
+    //    while the intersecting contours with different orders will have "holes".
+    //
+    // filling_rule() and gamma() can be called anytime before "sweeping".
+    //------------------------------------------------------------------------
+    template<class Clip=rasterizer_sl_clip_int> class rasterizer_scanline_aa
+    {
+        enum status
+        {
+            status_initial,
+            status_move_to,
+            status_line_to,
+            status_closed
+        };
+
+    public:
+        typedef Clip                      clip_type;
+        typedef typename Clip::conv_type  conv_type;
+        typedef typename Clip::coord_type coord_type;
+
+        enum aa_scale_e
+        {
+            aa_shift  = 8,
+            aa_scale  = 1 << aa_shift,
+            aa_mask   = aa_scale - 1,
+            aa_scale2 = aa_scale * 2,
+            aa_mask2  = aa_scale2 - 1
+        };
+
+        //--------------------------------------------------------------------
+        rasterizer_scanline_aa() : 
+            m_outline(),
+            m_clipper(),
+            m_filling_rule(fill_non_zero),
+            m_auto_close(true),
+            m_start_x(0),
+            m_start_y(0),
+            m_status(status_initial)
+        {
+            int i;
+            for(i = 0; i < aa_scale; i++) m_gamma[i] = i;
+        }
+
+        //--------------------------------------------------------------------
+        template<class GammaF> 
+        rasterizer_scanline_aa(const GammaF& gamma_function) : 
+            m_outline(),
+            m_clipper(m_outline),
+            m_filling_rule(fill_non_zero),
+            m_auto_close(true),
+            m_start_x(0),
+            m_start_y(0),
+            m_status(status_initial)
+        {
+            gamma(gamma_function);
+        }
+
+        //--------------------------------------------------------------------
+        void reset(); 
+        void reset_clipping();
+        void clip_box(double x1, double y1, double x2, double y2);
+        void filling_rule(filling_rule_e filling_rule);
+        void auto_close(bool flag) { m_auto_close = flag; }
+
+        //--------------------------------------------------------------------
+        template<class GammaF> void gamma(const GammaF& gamma_function)
+        { 
+            int i;
+            for(i = 0; i < aa_scale; i++)
+            {
+                m_gamma[i] = uround(gamma_function(double(i) / aa_mask) * aa_mask);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        unsigned apply_gamma(unsigned cover) const 
+        { 
+            return m_gamma[cover]; 
+        }
+
+        //--------------------------------------------------------------------
+        void move_to(int x, int y);
+        void line_to(int x, int y);
+        void move_to_d(double x, double y);
+        void line_to_d(double x, double y);
+        void close_polygon();
+        void add_vertex(double x, double y, unsigned cmd);
+
+        void edge(int x1, int y1, int x2, int y2);
+        void edge_d(double x1, double y1, double x2, double y2);
+
+        //-------------------------------------------------------------------
+        template<class VertexSource>
+        void add_path(VertexSource &&vs, unsigned path_id=0)
+        {
+            double x;
+            double y;
+
+            unsigned cmd;
+            vs.rewind(path_id);
+            if(m_outline.sorted()) reset();
+            while(!is_stop(cmd = vs.vertex(&x, &y)))
+            {
+                add_vertex(x, y, cmd);
+            }
+        }
+        
+        //--------------------------------------------------------------------
+        int min_x() const { return m_outline.min_x(); }
+        int min_y() const { return m_outline.min_y(); }
+        int max_x() const { return m_outline.max_x(); }
+        int max_y() const { return m_outline.max_y(); }
+
+        //--------------------------------------------------------------------
+        void sort();
+        bool rewind_scanlines();
+        bool navigate_scanline(int y);
+
+        //--------------------------------------------------------------------
+        AGG_INLINE unsigned calculate_alpha(int area) const
+        {
+            int cover = area >> (poly_subpixel_shift*2 + 1 - aa_shift);
+
+            if(cover < 0) cover = -cover;
+            if(m_filling_rule == fill_even_odd)
+            {
+                cover &= aa_mask2;
+                if(cover > aa_scale)
+                {
+                    cover = aa_scale2 - cover;
+                }
+            }
+            if(cover > aa_mask) cover = aa_mask;
+            return m_gamma[cover];
+        }
+
+        //--------------------------------------------------------------------
+        template<class Scanline> bool sweep_scanline(Scanline& sl)
+        {
+            for(;;)
+            {
+                if(m_scan_y > m_outline.max_y()) return false;
+                sl.reset_spans();
+                unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
+                const cell_aa* const* cells = m_outline.scanline_cells(m_scan_y);
+                int cover = 0;
+
+                while(num_cells)
+                {
+                    const cell_aa* cur_cell = *cells;
+                    int x    = cur_cell->x;
+                    int area = cur_cell->area;
+                    unsigned alpha;
+
+                    cover += cur_cell->cover;
+
+                    //accumulate all cells with the same X
+                    while(--num_cells)
+                    {
+                        cur_cell = *++cells;
+                        if(cur_cell->x != x) break;
+                        area  += cur_cell->area;
+                        cover += cur_cell->cover;
+                    }
+
+                    if(area)
+                    {
+                        alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area);
+                        if(alpha)
+                        {
+                            sl.add_cell(x, alpha);
+                        }
+                        x++;
+                    }
+
+                    if(num_cells && cur_cell->x > x)
+                    {
+                        alpha = calculate_alpha(cover << (poly_subpixel_shift + 1));
+                        if(alpha)
+                        {
+                            sl.add_span(x, cur_cell->x - x, alpha);
+                        }
+                    }
+                }
+        
+                if(sl.num_spans()) break;
+                ++m_scan_y;
+            }
+
+            sl.finalize(m_scan_y);
+            ++m_scan_y;
+            return true;
+        }
+
+        //--------------------------------------------------------------------
+        bool hit_test(int tx, int ty);
+
+
+    private:
+        //--------------------------------------------------------------------
+        // Disable copying
+        rasterizer_scanline_aa(const rasterizer_scanline_aa<Clip>&);
+        const rasterizer_scanline_aa<Clip>& 
+        operator = (const rasterizer_scanline_aa<Clip>&);
+
+    private:
+        rasterizer_cells_aa<cell_aa> m_outline;
+        clip_type      m_clipper;
+        int            m_gamma[aa_scale];
+        filling_rule_e m_filling_rule;
+        bool           m_auto_close;
+        coord_type     m_start_x;
+        coord_type     m_start_y;
+        unsigned       m_status;
+        int            m_scan_y;
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::reset() 
+    { 
+        m_outline.reset(); 
+        m_status = status_initial;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::filling_rule(filling_rule_e filling_rule) 
+    { 
+        m_filling_rule = filling_rule; 
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::clip_box(double x1, double y1, 
+                                                double x2, double y2)
+    {
+        reset();
+        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), 
+                           conv_type::upscale(x2), conv_type::upscale(y2));
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::reset_clipping()
+    {
+        reset();
+        m_clipper.reset_clipping();
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::close_polygon()
+    {
+        if(m_status == status_line_to)
+        {
+            m_clipper.line_to(m_outline, m_start_x, m_start_y);
+            m_status = status_closed;
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::move_to(int x, int y)
+    {
+        if(m_outline.sorted()) reset();
+        if(m_auto_close) close_polygon();
+        m_clipper.move_to(m_start_x = conv_type::downscale(x), 
+                          m_start_y = conv_type::downscale(y));
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::line_to(int x, int y)
+    {
+        m_clipper.line_to(m_outline, 
+                          conv_type::downscale(x), 
+                          conv_type::downscale(y));
+        m_status = status_line_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::move_to_d(double x, double y) 
+    { 
+        if(m_outline.sorted()) reset();
+        if(m_auto_close) close_polygon();
+        m_clipper.move_to(m_start_x = conv_type::upscale(x), 
+                          m_start_y = conv_type::upscale(y)); 
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::line_to_d(double x, double y) 
+    { 
+        m_clipper.line_to(m_outline, 
+                          conv_type::upscale(x), 
+                          conv_type::upscale(y)); 
+        m_status = status_line_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::add_vertex(double x, double y, unsigned cmd)
+    {
+        if(is_move_to(cmd)) 
+        {
+            move_to_d(x, y);
+        }
+        else 
+        if(is_vertex(cmd))
+        {
+            line_to_d(x, y);
+        }
+        else
+        if(is_close(cmd))
+        {
+            close_polygon();
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::edge(int x1, int y1, int x2, int y2)
+    {
+        if(m_outline.sorted()) reset();
+        m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
+        m_clipper.line_to(m_outline, 
+                          conv_type::downscale(x2), 
+                          conv_type::downscale(y2));
+        m_status = status_move_to;
+    }
+    
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::edge_d(double x1, double y1, 
+                                              double x2, double y2)
+    {
+        if(m_outline.sorted()) reset();
+        m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1)); 
+        m_clipper.line_to(m_outline, 
+                          conv_type::upscale(x2), 
+                          conv_type::upscale(y2)); 
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa<Clip>::sort()
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    AGG_INLINE bool rasterizer_scanline_aa<Clip>::rewind_scanlines()
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+        if(m_outline.total_cells() == 0) 
+        {
+            return false;
+        }
+        m_scan_y = m_outline.min_y();
+        return true;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    AGG_INLINE bool rasterizer_scanline_aa<Clip>::navigate_scanline(int y)
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+        if(m_outline.total_cells() == 0 || 
+           y < m_outline.min_y() || 
+           y > m_outline.max_y()) 
+        {
+            return false;
+        }
+        m_scan_y = y;
+        return true;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    bool rasterizer_scanline_aa<Clip>::hit_test(int tx, int ty)
+    {
+        if(!navigate_scanline(ty)) return false;
+        scanline_hit_test sl(tx);
+        sweep_scanline(sl);
+        return sl.hit();
+    }
+
+
+
+}
+
+
+
+#endif
+

src/agg/agg_rasterizer_scanline_aa_nogamma.h

@@ -0,0 +1,483 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+//
+// The author gratefully acknowleges the support of David Turner, 
+// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
+// libray - in producing this work. See http://www.freetype.org for details.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+#ifndef AGG_RASTERIZER_SCANLINE_AA_NOGAMMA_INCLUDED
+#define AGG_RASTERIZER_SCANLINE_AA_NOGAMMA_INCLUDED
+
+#include <limits>
+#include "agg_rasterizer_cells_aa.h"
+#include "agg_rasterizer_sl_clip.h"
+
+
+namespace agg
+{
+
+
+    //-----------------------------------------------------------------cell_aa
+    // A pixel cell. There're no constructors defined and it was done 
+    // intentionally in order to avoid extra overhead when allocating an 
+    // array of cells.
+    struct cell_aa
+    {
+        int x;
+        int y;
+        int cover;
+        int area;
+
+        void initial()
+        {
+            x = std::numeric_limits<int>::max();
+            y = std::numeric_limits<int>::max();
+            cover = 0;
+            area  = 0;
+        }
+
+        void style(const cell_aa&) {}
+
+        int not_equal(int ex, int ey, const cell_aa&) const
+        {
+            return ((unsigned)ex - (unsigned)x) | ((unsigned)ey - (unsigned)y);
+        }
+    };
+
+
+    //==================================================rasterizer_scanline_aa_nogamma
+    // Polygon rasterizer that is used to render filled polygons with 
+    // high-quality Anti-Aliasing. Internally, by default, the class uses 
+    // integer coordinates in format 24.8, i.e. 24 bits for integer part 
+    // and 8 bits for fractional - see poly_subpixel_shift. This class can be 
+    // used in the following  way:
+    //
+    // 1. filling_rule(filling_rule_e ft) - optional.
+    //
+    // 2. gamma() - optional.
+    //
+    // 3. reset()
+    //
+    // 4. move_to(x, y) / line_to(x, y) - make the polygon. One can create 
+    //    more than one contour, but each contour must consist of at least 3
+    //    vertices, i.e. move_to(x1, y1); line_to(x2, y2); line_to(x3, y3);
+    //    is the absolute minimum of vertices that define a triangle.
+    //    The algorithm does not check either the number of vertices nor
+    //    coincidence of their coordinates, but in the worst case it just 
+    //    won't draw anything.
+    //    The orger of the vertices (clockwise or counterclockwise) 
+    //    is important when using the non-zero filling rule (fill_non_zero).
+    //    In this case the vertex order of all the contours must be the same
+    //    if you want your intersecting polygons to be without "holes".
+    //    You actually can use different vertices order. If the contours do not 
+    //    intersect each other the order is not important anyway. If they do, 
+    //    contours with the same vertex order will be rendered without "holes" 
+    //    while the intersecting contours with different orders will have "holes".
+    //
+    // filling_rule() and gamma() can be called anytime before "sweeping".
+    //------------------------------------------------------------------------
+    template<class Clip=rasterizer_sl_clip_int> class rasterizer_scanline_aa_nogamma
+    {
+        enum status
+        {
+            status_initial,
+            status_move_to,
+            status_line_to,
+            status_closed
+        };
+
+    public:
+        typedef Clip                      clip_type;
+        typedef typename Clip::conv_type  conv_type;
+        typedef typename Clip::coord_type coord_type;
+
+        enum aa_scale_e
+        {
+            aa_shift  = 8,
+            aa_scale  = 1 << aa_shift,
+            aa_mask   = aa_scale - 1,
+            aa_scale2 = aa_scale * 2,
+            aa_mask2  = aa_scale2 - 1
+        };
+
+        //--------------------------------------------------------------------
+        rasterizer_scanline_aa_nogamma() : 
+            m_outline(),
+            m_clipper(),
+            m_filling_rule(fill_non_zero),
+            m_auto_close(true),
+            m_start_x(0),
+            m_start_y(0),
+            m_status(status_initial)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        void reset(); 
+        void reset_clipping();
+        void clip_box(double x1, double y1, double x2, double y2);
+        void filling_rule(filling_rule_e filling_rule);
+        void auto_close(bool flag) { m_auto_close = flag; }
+
+        //--------------------------------------------------------------------
+        unsigned apply_gamma(unsigned cover) const 
+        { 
+            return cover;
+        }
+
+        //--------------------------------------------------------------------
+        void move_to(int x, int y);
+        void line_to(int x, int y);
+        void move_to_d(double x, double y);
+        void line_to_d(double x, double y);
+        void close_polygon();
+        void add_vertex(double x, double y, unsigned cmd);
+
+        void edge(int x1, int y1, int x2, int y2);
+        void edge_d(double x1, double y1, double x2, double y2);
+
+        //-------------------------------------------------------------------
+        template<class VertexSource>
+        void add_path(VertexSource& vs, unsigned path_id=0)
+        {
+            double x;
+            double y;
+
+            unsigned cmd;
+            vs.rewind(path_id);
+            if(m_outline.sorted()) reset();
+            while(!is_stop(cmd = vs.vertex(&x, &y)))
+            {
+                add_vertex(x, y, cmd);
+            }
+        }
+        
+        //--------------------------------------------------------------------
+        int min_x() const { return m_outline.min_x(); }
+        int min_y() const { return m_outline.min_y(); }
+        int max_x() const { return m_outline.max_x(); }
+        int max_y() const { return m_outline.max_y(); }
+
+        //--------------------------------------------------------------------
+        void sort();
+        bool rewind_scanlines();
+        bool navigate_scanline(int y);
+
+        //--------------------------------------------------------------------
+        AGG_INLINE unsigned calculate_alpha(int area) const
+        {
+            int cover = area >> (poly_subpixel_shift*2 + 1 - aa_shift);
+
+            if(cover < 0) cover = -cover;
+            if(m_filling_rule == fill_even_odd)
+            {
+                cover &= aa_mask2;
+                if(cover > aa_scale)
+                {
+                    cover = aa_scale2 - cover;
+                }
+            }
+            if(cover > aa_mask) cover = aa_mask;
+            return cover;
+        }
+
+        //--------------------------------------------------------------------
+        template<class Scanline> bool sweep_scanline(Scanline& sl)
+        {
+            for(;;)
+            {
+                if(m_scan_y > m_outline.max_y()) return false;
+                sl.reset_spans();
+                unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
+                const cell_aa* const* cells = m_outline.scanline_cells(m_scan_y);
+                int cover = 0;
+
+                while(num_cells)
+                {
+                    const cell_aa* cur_cell = *cells;
+                    int x    = cur_cell->x;
+                    int area = cur_cell->area;
+                    unsigned alpha;
+
+                    cover += cur_cell->cover;
+
+                    //accumulate all cells with the same X
+                    while(--num_cells)
+                    {
+                        cur_cell = *++cells;
+                        if(cur_cell->x != x) break;
+                        area  += cur_cell->area;
+                        cover += cur_cell->cover;
+                    }
+
+                    if(area)
+                    {
+                        alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area);
+                        if(alpha)
+                        {
+                            sl.add_cell(x, alpha);
+                        }
+                        x++;
+                    }
+
+                    if(num_cells && cur_cell->x > x)
+                    {
+                        alpha = calculate_alpha(cover << (poly_subpixel_shift + 1));
+                        if(alpha)
+                        {
+                            sl.add_span(x, cur_cell->x - x, alpha);
+                        }
+                    }
+                }
+        
+                if(sl.num_spans()) break;
+                ++m_scan_y;
+            }
+
+            sl.finalize(m_scan_y);
+            ++m_scan_y;
+            return true;
+        }
+
+        //--------------------------------------------------------------------
+        bool hit_test(int tx, int ty);
+
+
+    private:
+        //--------------------------------------------------------------------
+        // Disable copying
+        rasterizer_scanline_aa_nogamma(const rasterizer_scanline_aa_nogamma<Clip>&);
+        const rasterizer_scanline_aa_nogamma<Clip>& 
+        operator = (const rasterizer_scanline_aa_nogamma<Clip>&);
+
+    private:
+        rasterizer_cells_aa<cell_aa> m_outline;
+        clip_type      m_clipper;
+        filling_rule_e m_filling_rule;
+        bool           m_auto_close;
+        coord_type     m_start_x;
+        coord_type     m_start_y;
+        unsigned       m_status;
+        int            m_scan_y;
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::reset() 
+    { 
+        m_outline.reset(); 
+        m_status = status_initial;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::filling_rule(filling_rule_e filling_rule) 
+    { 
+        m_filling_rule = filling_rule; 
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::clip_box(double x1, double y1, 
+                                                double x2, double y2)
+    {
+        reset();
+        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), 
+                           conv_type::upscale(x2), conv_type::upscale(y2));
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::reset_clipping()
+    {
+        reset();
+        m_clipper.reset_clipping();
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::close_polygon()
+    {
+        if(m_status == status_line_to)
+        {
+            m_clipper.line_to(m_outline, m_start_x, m_start_y);
+            m_status = status_closed;
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::move_to(int x, int y)
+    {
+        if(m_outline.sorted()) reset();
+        if(m_auto_close) close_polygon();
+        m_clipper.move_to(m_start_x = conv_type::downscale(x), 
+                          m_start_y = conv_type::downscale(y));
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::line_to(int x, int y)
+    {
+        m_clipper.line_to(m_outline, 
+                          conv_type::downscale(x), 
+                          conv_type::downscale(y));
+        m_status = status_line_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::move_to_d(double x, double y) 
+    { 
+        if(m_outline.sorted()) reset();
+        if(m_auto_close) close_polygon();
+        m_clipper.move_to(m_start_x = conv_type::upscale(x), 
+                          m_start_y = conv_type::upscale(y)); 
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::line_to_d(double x, double y) 
+    { 
+        m_clipper.line_to(m_outline, 
+                          conv_type::upscale(x), 
+                          conv_type::upscale(y)); 
+        m_status = status_line_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::add_vertex(double x, double y, unsigned cmd)
+    {
+        if(is_move_to(cmd)) 
+        {
+            move_to_d(x, y);
+        }
+        else 
+        if(is_vertex(cmd))
+        {
+            line_to_d(x, y);
+        }
+        else
+        if(is_close(cmd))
+        {
+            close_polygon();
+        }
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::edge(int x1, int y1, int x2, int y2)
+    {
+        if(m_outline.sorted()) reset();
+        m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
+        m_clipper.line_to(m_outline, 
+                          conv_type::downscale(x2), 
+                          conv_type::downscale(y2));
+        m_status = status_move_to;
+    }
+    
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::edge_d(double x1, double y1, 
+                                              double x2, double y2)
+    {
+        if(m_outline.sorted()) reset();
+        m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1)); 
+        m_clipper.line_to(m_outline, 
+                          conv_type::upscale(x2), 
+                          conv_type::upscale(y2)); 
+        m_status = status_move_to;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    void rasterizer_scanline_aa_nogamma<Clip>::sort()
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    AGG_INLINE bool rasterizer_scanline_aa_nogamma<Clip>::rewind_scanlines()
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+        if(m_outline.total_cells() == 0) 
+        {
+            return false;
+        }
+        m_scan_y = m_outline.min_y();
+        return true;
+    }
+
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    AGG_INLINE bool rasterizer_scanline_aa_nogamma<Clip>::navigate_scanline(int y)
+    {
+        if(m_auto_close) close_polygon();
+        m_outline.sort_cells();
+        if(m_outline.total_cells() == 0 || 
+           y < m_outline.min_y() || 
+           y > m_outline.max_y()) 
+        {
+            return false;
+        }
+        m_scan_y = y;
+        return true;
+    }
+
+    //------------------------------------------------------------------------
+    template<class Clip> 
+    bool rasterizer_scanline_aa_nogamma<Clip>::hit_test(int tx, int ty)
+    {
+        if(!navigate_scanline(ty)) return false;
+        scanline_hit_test sl(tx);
+        sweep_scanline(sl);
+        return sl.hit();
+    }
+
+
+
+}
+
+
+
+#endif
+

src/agg/agg_rasterizer_sl_clip.h

@@ -0,0 +1,351 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+#ifndef AGG_RASTERIZER_SL_CLIP_INCLUDED
+#define AGG_RASTERIZER_SL_CLIP_INCLUDED
+
+#include "agg_clip_liang_barsky.h"
+
+namespace agg
+{
+    //--------------------------------------------------------poly_max_coord_e
+    enum poly_max_coord_e
+    {
+        poly_max_coord = (1 << 30) - 1 //----poly_max_coord
+    };
+    
+    //------------------------------------------------------------ras_conv_int
+    struct ras_conv_int
+    {
+        typedef int coord_type;
+        static AGG_INLINE int mul_div(double a, double b, double c)
+        {
+            return iround(a * b / c);
+        }
+        static int xi(int v) { return v; }
+        static int yi(int v) { return v; }
+        static int upscale(double v) { return iround(v * poly_subpixel_scale); }
+        static int downscale(int v)  { return v; }
+    };
+
+    //--------------------------------------------------------ras_conv_int_sat
+    struct ras_conv_int_sat
+    {
+        typedef int coord_type;
+        static AGG_INLINE int mul_div(double a, double b, double c)
+        {
+            return saturation<poly_max_coord>::iround(a * b / c);
+        }
+        static int xi(int v) { return v; }
+        static int yi(int v) { return v; }
+        static int upscale(double v) 
+        { 
+            return saturation<poly_max_coord>::iround(v * poly_subpixel_scale); 
+        }
+        static int downscale(int v) { return v; }
+    };
+
+    //---------------------------------------------------------ras_conv_int_3x
+    struct ras_conv_int_3x
+    {
+        typedef int coord_type;
+        static AGG_INLINE int mul_div(double a, double b, double c)
+        {
+            return iround(a * b / c);
+        }
+        static int xi(int v) { return v * 3; }
+        static int yi(int v) { return v; }
+        static int upscale(double v) { return iround(v * poly_subpixel_scale); }
+        static int downscale(int v)  { return v; }
+    };
+
+    //-----------------------------------------------------------ras_conv_dbl
+    struct ras_conv_dbl
+    {
+        typedef double coord_type;
+        static AGG_INLINE double mul_div(double a, double b, double c)
+        {
+            return a * b / c;
+        }
+        static int xi(double v) { return iround(v * poly_subpixel_scale); }
+        static int yi(double v) { return iround(v * poly_subpixel_scale); }
+        static double upscale(double v) { return v; }
+        static double downscale(int v)  { return v / double(poly_subpixel_scale); }
+    };
+
+    //--------------------------------------------------------ras_conv_dbl_3x
+    struct ras_conv_dbl_3x
+    {
+        typedef double coord_type;
+        static AGG_INLINE double mul_div(double a, double b, double c)
+        {
+            return a * b / c;
+        }
+        static int xi(double v) { return iround(v * poly_subpixel_scale * 3); }
+        static int yi(double v) { return iround(v * poly_subpixel_scale); }
+        static double upscale(double v) { return v; }
+        static double downscale(int v)  { return v / double(poly_subpixel_scale); }
+    };
+
+
+
+
+
+    //------------------------------------------------------rasterizer_sl_clip
+    template<class Conv> class rasterizer_sl_clip
+    {
+    public:
+        typedef Conv                      conv_type;
+        typedef typename Conv::coord_type coord_type;
+        typedef rect_base<coord_type>     rect_type;
+
+        //--------------------------------------------------------------------
+        rasterizer_sl_clip() :  
+            m_clip_box(0,0,0,0),
+            m_x1(0),
+            m_y1(0),
+            m_f1(0),
+            m_clipping(false) 
+        {}
+
+        //--------------------------------------------------------------------
+        void reset_clipping()
+        {
+            m_clipping = false;
+        }
+
+        //--------------------------------------------------------------------
+        void clip_box(coord_type x1, coord_type y1, coord_type x2, coord_type y2)
+        {
+            m_clip_box = rect_type(x1, y1, x2, y2);
+            m_clip_box.normalize();
+            m_clipping = true;
+        }
+
+        //--------------------------------------------------------------------
+        void move_to(coord_type x1, coord_type y1)
+        {
+            m_x1 = x1;
+            m_y1 = y1;
+            if(m_clipping) m_f1 = clipping_flags(x1, y1, m_clip_box);
+        }
+
+    private:
+        //------------------------------------------------------------------------
+        template<class Rasterizer>
+        AGG_INLINE void line_clip_y(Rasterizer& ras,
+                                    coord_type x1, coord_type y1, 
+                                    coord_type x2, coord_type y2, 
+                                    unsigned   f1, unsigned   f2) const
+        {
+            f1 &= 10;
+            f2 &= 10;
+            if((f1 | f2) == 0)
+            {
+                // Fully visible
+                ras.line(Conv::xi(x1), Conv::yi(y1), Conv::xi(x2), Conv::yi(y2)); 
+            }
+            else
+            {
+                if(f1 == f2)
+                {
+                    // Invisible by Y
+                    return;
+                }
+
+                coord_type tx1 = x1;
+                coord_type ty1 = y1;
+                coord_type tx2 = x2;
+                coord_type ty2 = y2;
+
+                if(f1 & 8) // y1 < clip.y1
+                {
+                    tx1 = x1 + Conv::mul_div(m_clip_box.y1-y1, x2-x1, y2-y1);
+                    ty1 = m_clip_box.y1;
+                }
+
+                if(f1 & 2) // y1 > clip.y2
+                {
+                    tx1 = x1 + Conv::mul_div(m_clip_box.y2-y1, x2-x1, y2-y1);
+                    ty1 = m_clip_box.y2;
+                }
+
+                if(f2 & 8) // y2 < clip.y1
+                {
+                    tx2 = x1 + Conv::mul_div(m_clip_box.y1-y1, x2-x1, y2-y1);
+                    ty2 = m_clip_box.y1;
+                }
+
+                if(f2 & 2) // y2 > clip.y2
+                {
+                    tx2 = x1 + Conv::mul_div(m_clip_box.y2-y1, x2-x1, y2-y1);
+                    ty2 = m_clip_box.y2;
+                }
+                ras.line(Conv::xi(tx1), Conv::yi(ty1), 
+                         Conv::xi(tx2), Conv::yi(ty2)); 
+            }
+        }
+
+
+    public:
+        //--------------------------------------------------------------------
+        template<class Rasterizer>
+        void line_to(Rasterizer& ras, coord_type x2, coord_type y2)
+        {
+            if(m_clipping)
+            {
+                unsigned f2 = clipping_flags(x2, y2, m_clip_box);
+
+                if((m_f1 & 10) == (f2 & 10) && (m_f1 & 10) != 0)
+                {
+                    // Invisible by Y
+                    m_x1 = x2;
+                    m_y1 = y2;
+                    m_f1 = f2;
+                    return;
+                }
+
+                coord_type x1 = m_x1;
+                coord_type y1 = m_y1;
+                unsigned   f1 = m_f1;
+                coord_type y3, y4;
+                unsigned   f3, f4;
+
+                switch(((f1 & 5) << 1) | (f2 & 5))
+                {
+                case 0: // Visible by X
+                    line_clip_y(ras, x1, y1, x2, y2, f1, f2);
+                    break;
+
+                case 1: // x2 > clip.x2
+                    y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    line_clip_y(ras, x1, y1, m_clip_box.x2, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x2, y3, m_clip_box.x2, y2, f3, f2);
+                    break;
+
+                case 2: // x1 > clip.x2
+                    y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    line_clip_y(ras, m_clip_box.x2, y1, m_clip_box.x2, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x2, y3, x2, y2, f3, f2);
+                    break;
+
+                case 3: // x1 > clip.x2 && x2 > clip.x2
+                    line_clip_y(ras, m_clip_box.x2, y1, m_clip_box.x2, y2, f1, f2);
+                    break;
+
+                case 4: // x2 < clip.x1
+                    y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    line_clip_y(ras, x1, y1, m_clip_box.x1, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x1, y3, m_clip_box.x1, y2, f3, f2);
+                    break;
+
+                case 6: // x1 > clip.x2 && x2 < clip.x1
+                    y3 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
+                    y4 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    f4 = clipping_flags_y(y4, m_clip_box);
+                    line_clip_y(ras, m_clip_box.x2, y1, m_clip_box.x2, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x2, y3, m_clip_box.x1, y4, f3, f4);
+                    line_clip_y(ras, m_clip_box.x1, y4, m_clip_box.x1, y2, f4, f2);
+                    break;
+
+                case 8: // x1 < clip.x1
+                    y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    line_clip_y(ras, m_clip_box.x1, y1, m_clip_box.x1, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x1, y3, x2, y2, f3, f2);
+                    break;
+
+                case 9:  // x1 < clip.x1 && x2 > clip.x2
+                    y3 = y1 + Conv::mul_div(m_clip_box.x1-x1, y2-y1, x2-x1);
+                    y4 = y1 + Conv::mul_div(m_clip_box.x2-x1, y2-y1, x2-x1);
+                    f3 = clipping_flags_y(y3, m_clip_box);
+                    f4 = clipping_flags_y(y4, m_clip_box);
+                    line_clip_y(ras, m_clip_box.x1, y1, m_clip_box.x1, y3, f1, f3);
+                    line_clip_y(ras, m_clip_box.x1, y3, m_clip_box.x2, y4, f3, f4);
+                    line_clip_y(ras, m_clip_box.x2, y4, m_clip_box.x2, y2, f4, f2);
+                    break;
+
+                case 12: // x1 < clip.x1 && x2 < clip.x1
+                    line_clip_y(ras, m_clip_box.x1, y1, m_clip_box.x1, y2, f1, f2);
+                    break;
+                }
+                m_f1 = f2;
+            }
+            else
+            {
+                ras.line(Conv::xi(m_x1), Conv::yi(m_y1), 
+                         Conv::xi(x2),   Conv::yi(y2)); 
+            }
+            m_x1 = x2;
+            m_y1 = y2;
+        }
+
+
+    private:
+        rect_type        m_clip_box;
+        coord_type       m_x1;
+        coord_type       m_y1;
+        unsigned         m_f1;
+        bool             m_clipping;
+    };
+
+
+
+
+    //---------------------------------------------------rasterizer_sl_no_clip
+    class rasterizer_sl_no_clip
+    {
+    public:
+        typedef ras_conv_int conv_type;
+        typedef int          coord_type;
+
+        rasterizer_sl_no_clip() : m_x1(0), m_y1(0) {}
+
+        void reset_clipping() {}
+        void clip_box(coord_type, coord_type, coord_type, coord_type) {}
+        void move_to(coord_type x1, coord_type y1) { m_x1 = x1; m_y1 = y1; }
+
+        template<class Rasterizer>
+        void line_to(Rasterizer& ras, coord_type x2, coord_type y2) 
+        { 
+            ras.line(m_x1, m_y1, x2, y2); 
+            m_x1 = x2; 
+            m_y1 = y2;
+        }
+
+    private:
+        int m_x1, m_y1;
+    };
+
+
+    //                                         -----rasterizer_sl_clip_int
+    //                                         -----rasterizer_sl_clip_int_sat
+    //                                         -----rasterizer_sl_clip_int_3x
+    //                                         -----rasterizer_sl_clip_dbl
+    //                                         -----rasterizer_sl_clip_dbl_3x
+    //------------------------------------------------------------------------
+    typedef rasterizer_sl_clip<ras_conv_int>     rasterizer_sl_clip_int;
+    typedef rasterizer_sl_clip<ras_conv_int_sat> rasterizer_sl_clip_int_sat;
+    typedef rasterizer_sl_clip<ras_conv_int_3x>  rasterizer_sl_clip_int_3x;
+    typedef rasterizer_sl_clip<ras_conv_dbl>     rasterizer_sl_clip_dbl;
+    typedef rasterizer_sl_clip<ras_conv_dbl_3x>  rasterizer_sl_clip_dbl_3x;
+
+
+}
+
+#endif

src/agg/agg_renderer_base.h

@@ -0,0 +1,731 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// class renderer_base
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_RENDERER_BASE_INCLUDED
+#define AGG_RENDERER_BASE_INCLUDED
+
+#include "agg_basics.h"
+#include "agg_rendering_buffer.h"
+
+namespace agg
+{
+
+    //-----------------------------------------------------------renderer_base
+    template<class PixelFormat> class renderer_base
+    {
+    public:
+        typedef PixelFormat pixfmt_type;
+        typedef typename pixfmt_type::color_type color_type;
+        typedef typename pixfmt_type::row_data row_data;
+
+        //--------------------------------------------------------------------
+        renderer_base() : m_ren(0), m_clip_box(1, 1, 0, 0) {}
+        explicit renderer_base(pixfmt_type& ren) :
+            m_ren(&ren),
+            m_clip_box(0, 0, ren.width() - 1, ren.height() - 1)
+        {}
+        void attach(pixfmt_type& ren)
+        {
+            m_ren = &ren;
+            m_clip_box = rect_i(0, 0, ren.width() - 1, ren.height() - 1);
+        }
+
+        //--------------------------------------------------------------------
+        const pixfmt_type& ren() const { return *m_ren;  }
+        pixfmt_type& ren() { return *m_ren;  }
+          
+        //--------------------------------------------------------------------
+        unsigned width()  const { return m_ren->width();  }
+        unsigned height() const { return m_ren->height(); }
+
+        //--------------------------------------------------------------------
+        bool clip_box(int x1, int y1, int x2, int y2)
+        {
+            rect_i cb(x1, y1, x2, y2);
+            cb.normalize();
+            if(cb.clip(rect_i(0, 0, width() - 1, height() - 1)))
+            {
+                m_clip_box = cb;
+                return true;
+            }
+            m_clip_box.x1 = 1;
+            m_clip_box.y1 = 1;
+            m_clip_box.x2 = 0;
+            m_clip_box.y2 = 0;
+            return false;
+        }
+
+        //--------------------------------------------------------------------
+        void reset_clipping(bool visibility)
+        {
+            if(visibility)
+            {
+                m_clip_box.x1 = 0;
+                m_clip_box.y1 = 0;
+                m_clip_box.x2 = width() - 1;
+                m_clip_box.y2 = height() - 1;
+            }
+            else
+            {
+                m_clip_box.x1 = 1;
+                m_clip_box.y1 = 1;
+                m_clip_box.x2 = 0;
+                m_clip_box.y2 = 0;
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void clip_box_naked(int x1, int y1, int x2, int y2)
+        {
+            m_clip_box.x1 = x1;
+            m_clip_box.y1 = y1;
+            m_clip_box.x2 = x2;
+            m_clip_box.y2 = y2;
+        }
+
+        //--------------------------------------------------------------------
+        bool inbox(int x, int y) const
+        {
+            return x >= m_clip_box.x1 && y >= m_clip_box.y1 &&
+                   x <= m_clip_box.x2 && y <= m_clip_box.y2;
+        }
+
+        //--------------------------------------------------------------------
+        const rect_i& clip_box() const { return m_clip_box;    }
+        int           xmin()     const { return m_clip_box.x1; }
+        int           ymin()     const { return m_clip_box.y1; }
+        int           xmax()     const { return m_clip_box.x2; }
+        int           ymax()     const { return m_clip_box.y2; }
+
+        //--------------------------------------------------------------------
+        const rect_i& bounding_clip_box() const { return m_clip_box;    }
+        int           bounding_xmin()     const { return m_clip_box.x1; }
+        int           bounding_ymin()     const { return m_clip_box.y1; }
+        int           bounding_xmax()     const { return m_clip_box.x2; }
+        int           bounding_ymax()     const { return m_clip_box.y2; }
+
+        //--------------------------------------------------------------------
+        void clear(const color_type& c)
+        {
+            unsigned y;
+            if(width())
+            {
+                for(y = 0; y < height(); y++)
+                {
+                    m_ren->copy_hline(0, y, width(), c);
+                }
+            }
+        }
+          
+
+        //--------------------------------------------------------------------
+        void fill(const color_type& c)
+        {
+            unsigned y;
+            if(width())
+            {
+                for(y = 0; y < height(); y++)
+                {
+                    m_ren->blend_hline(0, y, width(), c, cover_mask);
+                }
+            }
+        }
+        
+        //--------------------------------------------------------------------
+        void copy_pixel(int x, int y, const color_type& c)
+        {
+            if(inbox(x, y))
+            {
+                m_ren->copy_pixel(x, y, c);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void blend_pixel(int x, int y, const color_type& c, cover_type cover)
+        {
+            if(inbox(x, y))
+            {
+                m_ren->blend_pixel(x, y, c, cover);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        color_type pixel(int x, int y) const
+        {
+            return inbox(x, y) ? 
+                   m_ren->pixel(x, y) :
+                   color_type::no_color();
+        }
+
+        //--------------------------------------------------------------------
+        void copy_hline(int x1, int y, int x2, const color_type& c)
+        {
+            if(x1 > x2) { int t = x2; x2 = x1; x1 = t; }
+            if(y  > ymax()) return;
+            if(y  < ymin()) return;
+            if(x1 > xmax()) return;
+            if(x2 < xmin()) return;
+
+            if(x1 < xmin()) x1 = xmin();
+            if(x2 > xmax()) x2 = xmax();
+
+            m_ren->copy_hline(x1, y, x2 - x1 + 1, c);
+        }
+
+        //--------------------------------------------------------------------
+        void copy_vline(int x, int y1, int y2, const color_type& c)
+        {
+            if(y1 > y2) { int t = y2; y2 = y1; y1 = t; }
+            if(x  > xmax()) return;
+            if(x  < xmin()) return;
+            if(y1 > ymax()) return;
+            if(y2 < ymin()) return;
+
+            if(y1 < ymin()) y1 = ymin();
+            if(y2 > ymax()) y2 = ymax();
+
+            m_ren->copy_vline(x, y1, y2 - y1 + 1, c);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_hline(int x1, int y, int x2, 
+                         const color_type& c, cover_type cover)
+        {
+            if(x1 > x2) { int t = x2; x2 = x1; x1 = t; }
+            if(y  > ymax()) return;
+            if(y  < ymin()) return;
+            if(x1 > xmax()) return;
+            if(x2 < xmin()) return;
+
+            if(x1 < xmin()) x1 = xmin();
+            if(x2 > xmax()) x2 = xmax();
+
+            m_ren->blend_hline(x1, y, x2 - x1 + 1, c, cover);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_vline(int x, int y1, int y2, 
+                         const color_type& c, cover_type cover)
+        {
+            if(y1 > y2) { int t = y2; y2 = y1; y1 = t; }
+            if(x  > xmax()) return;
+            if(x  < xmin()) return;
+            if(y1 > ymax()) return;
+            if(y2 < ymin()) return;
+
+            if(y1 < ymin()) y1 = ymin();
+            if(y2 > ymax()) y2 = ymax();
+
+            m_ren->blend_vline(x, y1, y2 - y1 + 1, c, cover);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_bar(int x1, int y1, int x2, int y2, const color_type& c)
+        {
+            rect_i rc(x1, y1, x2, y2);
+            rc.normalize();
+            if(rc.clip(clip_box()))
+            {
+                int y;
+                for(y = rc.y1; y <= rc.y2; y++)
+                {
+                    m_ren->copy_hline(rc.x1, y, unsigned(rc.x2 - rc.x1 + 1), c);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void blend_bar(int x1, int y1, int x2, int y2, 
+                       const color_type& c, cover_type cover)
+        {
+            rect_i rc(x1, y1, x2, y2);
+            rc.normalize();
+            if(rc.clip(clip_box()))
+            {
+                int y;
+                for(y = rc.y1; y <= rc.y2; y++)
+                {
+                    m_ren->blend_hline(rc.x1,
+                                       y,
+                                       unsigned(rc.x2 - rc.x1 + 1), 
+                                       c, 
+                                       cover);
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void blend_solid_hspan(int x, int y, int len, 
+                               const color_type& c, 
+                               const cover_type* covers)
+        {
+            if(y > ymax()) return;
+            if(y < ymin()) return;
+
+            if(x < xmin())
+            {
+                len -= xmin() - x;
+                if(len <= 0) return;
+                covers += xmin() - x;
+                x = xmin();
+            }
+            if(x + len > xmax())
+            {
+                len = xmax() - x + 1;
+                if(len <= 0) return;
+            }
+            m_ren->blend_solid_hspan(x, y, len, c, covers);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_solid_vspan(int x, int y, int len, 
+                               const color_type& c, 
+                               const cover_type* covers)
+        {
+            if(x > xmax()) return;
+            if(x < xmin()) return;
+
+            if(y < ymin())
+            {
+                len -= ymin() - y;
+                if(len <= 0) return;
+                covers += ymin() - y;
+                y = ymin();
+            }
+            if(y + len > ymax())
+            {
+                len = ymax() - y + 1;
+                if(len <= 0) return;
+            }
+            m_ren->blend_solid_vspan(x, y, len, c, covers);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_hspan(int x, int y, int len, const color_type* colors)
+        {
+            if(y > ymax()) return;
+            if(y < ymin()) return;
+
+            if(x < xmin())
+            {
+                int d = xmin() - x;
+                len -= d;
+                if(len <= 0) return;
+                colors += d;
+                x = xmin();
+            }
+            if(x + len > xmax())
+            {
+                len = xmax() - x + 1;
+                if(len <= 0) return;
+            }
+            m_ren->copy_color_hspan(x, y, len, colors);
+        }
+
+
+        //--------------------------------------------------------------------
+        void copy_color_vspan(int x, int y, int len, const color_type* colors)
+        {
+            if(x > xmax()) return;
+            if(x < xmin()) return;
+
+            if(y < ymin())
+            {
+                int d = ymin() - y;
+                len -= d;
+                if(len <= 0) return;
+                colors += d;
+                y = ymin();
+            }
+            if(y + len > ymax())
+            {
+                len = ymax() - y + 1;
+                if(len <= 0) return;
+            }
+            m_ren->copy_color_vspan(x, y, len, colors);
+        }
+
+
+        //--------------------------------------------------------------------
+        void blend_color_hspan(int x, int y, int len, 
+                               const color_type* colors, 
+                               const cover_type* covers,
+                               cover_type cover = agg::cover_full)
+        {
+            if(y > ymax()) return;
+            if(y < ymin()) return;
+
+            if(x < xmin())
+            {
+                int d = xmin() - x;
+                len -= d;
+                if(len <= 0) return;
+                if(covers) covers += d;
+                colors += d;
+                x = xmin();
+            }
+            if(x + len > xmax())
+            {
+                len = xmax() - x + 1;
+                if(len <= 0) return;
+            }
+            m_ren->blend_color_hspan(x, y, len, colors, covers, cover);
+        }
+
+        //--------------------------------------------------------------------
+        void blend_color_vspan(int x, int y, int len, 
+                               const color_type* colors, 
+                               const cover_type* covers,
+                               cover_type cover = agg::cover_full)
+        {
+            if(x > xmax()) return;
+            if(x < xmin()) return;
+
+            if(y < ymin())
+            {
+                int d = ymin() - y;
+                len -= d;
+                if(len <= 0) return;
+                if(covers) covers += d;
+                colors += d;
+                y = ymin();
+            }
+            if(y + len > ymax())
+            {
+                len = ymax() - y + 1;
+                if(len <= 0) return;
+            }
+            m_ren->blend_color_vspan(x, y, len, colors, covers, cover);
+        }
+
+        //--------------------------------------------------------------------
+        rect_i clip_rect_area(rect_i& dst, rect_i& src, int wsrc, int hsrc) const
+        {
+            rect_i rc(0,0,0,0);
+            rect_i cb = clip_box();
+            ++cb.x2;
+            ++cb.y2;
+
+            if(src.x1 < 0)
+            {
+                dst.x1 -= src.x1;
+                src.x1 = 0;
+            }
+            if(src.y1 < 0)
+            {
+                dst.y1 -= src.y1;
+                src.y1 = 0;
+            }
+
+            if(src.x2 > wsrc) src.x2 = wsrc;
+            if(src.y2 > hsrc) src.y2 = hsrc;
+
+            if(dst.x1 < cb.x1)
+            {
+                src.x1 += cb.x1 - dst.x1;
+                dst.x1 = cb.x1;
+            }
+            if(dst.y1 < cb.y1)
+            {
+                src.y1 += cb.y1 - dst.y1;
+                dst.y1 = cb.y1;
+            }
+
+            if(dst.x2 > cb.x2) dst.x2 = cb.x2;
+            if(dst.y2 > cb.y2) dst.y2 = cb.y2;
+
+            rc.x2 = dst.x2 - dst.x1;
+            rc.y2 = dst.y2 - dst.y1;
+
+            if(rc.x2 > src.x2 - src.x1) rc.x2 = src.x2 - src.x1;
+            if(rc.y2 > src.y2 - src.y1) rc.y2 = src.y2 - src.y1;
+            return rc;
+        }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf>
+        void copy_from(const RenBuf& src, 
+                       const rect_i* rect_src_ptr = 0, 
+                       int dx = 0, 
+                       int dy = 0)
+        {
+            rect_i rsrc(0, 0, src.width(), src.height());
+            if(rect_src_ptr)
+            {
+                rsrc.x1 = rect_src_ptr->x1; 
+                rsrc.y1 = rect_src_ptr->y1;
+                rsrc.x2 = rect_src_ptr->x2 + 1;
+                rsrc.y2 = rect_src_ptr->y2 + 1;
+            }
+
+            // Version with xdst, ydst (absolute positioning)
+            //rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
+
+            // Version with dx, dy (relative positioning)
+            rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
+
+            rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
+
+            if(rc.x2 > 0)
+            {
+                int incy = 1;
+                if(rdst.y1 > rsrc.y1)
+                {
+                    rsrc.y1 += rc.y2 - 1;
+                    rdst.y1 += rc.y2 - 1;
+                    incy = -1;
+                }
+                while(rc.y2 > 0)
+                {
+                    m_ren->copy_from(src, 
+                                     rdst.x1, rdst.y1,
+                                     rsrc.x1, rsrc.y1,
+                                     rc.x2);
+                    rdst.y1 += incy;
+                    rsrc.y1 += incy;
+                    --rc.y2;
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class SrcPixelFormatRenderer>
+        void blend_from(const SrcPixelFormatRenderer& src, 
+                        const rect_i* rect_src_ptr = 0, 
+                        int dx = 0, 
+                        int dy = 0,
+                        cover_type cover = agg::cover_full)
+        {
+            rect_i rsrc(0, 0, src.width(), src.height());
+            if(rect_src_ptr)
+            {
+                rsrc.x1 = rect_src_ptr->x1; 
+                rsrc.y1 = rect_src_ptr->y1;
+                rsrc.x2 = rect_src_ptr->x2 + 1;
+                rsrc.y2 = rect_src_ptr->y2 + 1;
+            }
+
+            // Version with xdst, ydst (absolute positioning)
+            //rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
+
+            // Version with dx, dy (relative positioning)
+            rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
+            rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
+
+            if(rc.x2 > 0)
+            {
+                int incy = 1;
+                if(rdst.y1 > rsrc.y1)
+                {
+                    rsrc.y1 += rc.y2 - 1;
+                    rdst.y1 += rc.y2 - 1;
+                    incy = -1;
+                }
+                while(rc.y2 > 0)
+                {
+                    typename SrcPixelFormatRenderer::row_data rw = src.row(rsrc.y1);
+                    if(rw.ptr)
+                    {
+                        int x1src = rsrc.x1;
+                        int x1dst = rdst.x1;
+                        int len   = rc.x2;
+                        if(rw.x1 > x1src)
+                        {
+                            x1dst += rw.x1 - x1src;
+                            len   -= rw.x1 - x1src;
+                            x1src  = rw.x1;
+                        }
+                        if(len > 0)
+                        {
+                            if(x1src + len-1 > rw.x2)
+                            {
+                                len -= x1src + len - rw.x2 - 1;
+                            }
+                            if(len > 0)
+                            {
+                                m_ren->blend_from(src,
+                                                  x1dst, rdst.y1,
+                                                  x1src, rsrc.y1,
+                                                  len,
+                                                  cover);
+                            }
+                        }
+                    }
+                    rdst.y1 += incy;
+                    rsrc.y1 += incy;
+                    --rc.y2;
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class SrcPixelFormatRenderer>
+        void blend_from_color(const SrcPixelFormatRenderer& src, 
+                              const color_type& color,
+                              const rect_i* rect_src_ptr = 0, 
+                              int dx = 0, 
+                              int dy = 0,
+                              cover_type cover = agg::cover_full)
+        {
+            rect_i rsrc(0, 0, src.width(), src.height());
+            if(rect_src_ptr)
+            {
+                rsrc.x1 = rect_src_ptr->x1; 
+                rsrc.y1 = rect_src_ptr->y1;
+                rsrc.x2 = rect_src_ptr->x2 + 1;
+                rsrc.y2 = rect_src_ptr->y2 + 1;
+            }
+
+            // Version with xdst, ydst (absolute positioning)
+            //rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
+
+            // Version with dx, dy (relative positioning)
+            rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
+            rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
+
+            if(rc.x2 > 0)
+            {
+                int incy = 1;
+                if(rdst.y1 > rsrc.y1)
+                {
+                    rsrc.y1 += rc.y2 - 1;
+                    rdst.y1 += rc.y2 - 1;
+                    incy = -1;
+                }
+                while(rc.y2 > 0)
+                {
+                    typename SrcPixelFormatRenderer::row_data rw = src.row(rsrc.y1);
+                    if(rw.ptr)
+                    {
+                        int x1src = rsrc.x1;
+                        int x1dst = rdst.x1;
+                        int len   = rc.x2;
+                        if(rw.x1 > x1src)
+                        {
+                            x1dst += rw.x1 - x1src;
+                            len   -= rw.x1 - x1src;
+                            x1src  = rw.x1;
+                        }
+                        if(len > 0)
+                        {
+                            if(x1src + len-1 > rw.x2)
+                            {
+                                len -= x1src + len - rw.x2 - 1;
+                            }
+                            if(len > 0)
+                            {
+                                m_ren->blend_from_color(src,
+                                                        color,
+                                                        x1dst, rdst.y1,
+                                                        x1src, rsrc.y1,
+                                                        len,
+                                                        cover);
+                            }
+                        }
+                    }
+                    rdst.y1 += incy;
+                    rsrc.y1 += incy;
+                    --rc.y2;
+                }
+            }
+        }
+
+        //--------------------------------------------------------------------
+        template<class SrcPixelFormatRenderer>
+        void blend_from_lut(const SrcPixelFormatRenderer& src, 
+                            const color_type* color_lut,
+                            const rect_i* rect_src_ptr = 0, 
+                            int dx = 0, 
+                            int dy = 0,
+                            cover_type cover = agg::cover_full)
+        {
+            rect_i rsrc(0, 0, src.width(), src.height());
+            if(rect_src_ptr)
+            {
+                rsrc.x1 = rect_src_ptr->x1; 
+                rsrc.y1 = rect_src_ptr->y1;
+                rsrc.x2 = rect_src_ptr->x2 + 1;
+                rsrc.y2 = rect_src_ptr->y2 + 1;
+            }
+
+            // Version with xdst, ydst (absolute positioning)
+            //rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1);
+
+            // Version with dx, dy (relative positioning)
+            rect_i rdst(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy);
+            rect_i rc = clip_rect_area(rdst, rsrc, src.width(), src.height());
+
+            if(rc.x2 > 0)
+            {
+                int incy = 1;
+                if(rdst.y1 > rsrc.y1)
+                {
+                    rsrc.y1 += rc.y2 - 1;
+                    rdst.y1 += rc.y2 - 1;
+                    incy = -1;
+                }
+                while(rc.y2 > 0)
+                {
+                    typename SrcPixelFormatRenderer::row_data rw = src.row(rsrc.y1);
+                    if(rw.ptr)
+                    {
+                        int x1src = rsrc.x1;
+                        int x1dst = rdst.x1;
+                        int len   = rc.x2;
+                        if(rw.x1 > x1src)
+                        {
+                            x1dst += rw.x1 - x1src;
+                            len   -= rw.x1 - x1src;
+                            x1src  = rw.x1;
+                        }
+                        if(len > 0)
+                        {
+                            if(x1src + len-1 > rw.x2)
+                            {
+                                len -= x1src + len - rw.x2 - 1;
+                            }
+                            if(len > 0)
+                            {
+                                m_ren->blend_from_lut(src,
+                                                      color_lut,
+                                                      x1dst, rdst.y1,
+                                                      x1src, rsrc.y1,
+                                                      len,
+                                                      cover);
+                            }
+                        }
+                    }
+                    rdst.y1 += incy;
+                    rsrc.y1 += incy;
+                    --rc.y2;
+                }
+            }
+        }
+
+    private:
+        pixfmt_type* m_ren;
+        rect_i       m_clip_box;
+    };
+
+
+}
+
+#endif

src/agg/agg_renderer_scanline.h

@@ -0,0 +1,854 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+
+#ifndef AGG_RENDERER_SCANLINE_INCLUDED
+#define AGG_RENDERER_SCANLINE_INCLUDED
+
+#include <limits>
+#include <cstdlib>
+#include "agg_basics.h"
+#include "agg_renderer_base.h"
+
+namespace agg
+{
+
+    //================================================render_scanline_aa_solid
+    template<class Scanline, class BaseRenderer, class ColorT> 
+    void render_scanline_aa_solid(const Scanline& sl, 
+                                  BaseRenderer& ren, 
+                                  const ColorT& color)
+    {
+        int y = sl.y();
+        unsigned num_spans = sl.num_spans();
+        typename Scanline::const_iterator span = sl.begin();
+
+        for(;;)
+        {
+            int x = span->x;
+            if(span->len > 0)
+            {
+                ren.blend_solid_hspan(x, y, (unsigned)span->len, 
+                                      color, 
+                                      span->covers);
+            }
+            else
+            {
+                ren.blend_hline(x, y, (unsigned)(x - span->len - 1), 
+                                color, 
+                                *(span->covers));
+            }
+            if(--num_spans == 0) break;
+            ++span;
+        }
+    }
+
+    //===============================================render_scanlines_aa_solid
+    template<class Rasterizer, class Scanline, 
+             class BaseRenderer, class ColorT>
+    void render_scanlines_aa_solid(Rasterizer& ras, Scanline& sl, 
+                                   BaseRenderer& ren, const ColorT& color)
+    {
+        if(ras.rewind_scanlines())
+        {
+            // Explicitly convert "color" to the BaseRenderer color type.
+            // For example, it can be called with color type "rgba", while
+            // "rgba8" is needed. Otherwise it will be implicitly 
+            // converted in the loop many times.
+            //----------------------
+            typename BaseRenderer::color_type ren_color = color;
+
+            sl.reset(ras.min_x(), ras.max_x());
+            while(ras.sweep_scanline(sl))
+            {
+                //render_scanline_aa_solid(sl, ren, ren_color);
+
+                // This code is equivalent to the above call (copy/paste). 
+                // It's just a "manual" optimization for old compilers,
+                // like Microsoft Visual C++ v6.0
+                //-------------------------------
+                int y = sl.y();
+                unsigned num_spans = sl.num_spans();
+                typename Scanline::const_iterator span = sl.begin();
+
+                for(;;)
+                {
+                    int x = span->x;
+                    if(span->len > 0)
+                    {
+                        ren.blend_solid_hspan(x, y, (unsigned)span->len, 
+                                              ren_color, 
+                                              span->covers);
+                    }
+                    else
+                    {
+                        ren.blend_hline(x, y, (unsigned)(x - span->len - 1), 
+                                        ren_color, 
+                                        *(span->covers));
+                    }
+                    if(--num_spans == 0) break;
+                    ++span;
+                }
+            }
+        }
+    }
+
+    //==============================================renderer_scanline_aa_solid
+    template<class BaseRenderer> class renderer_scanline_aa_solid
+    {
+    public:
+        typedef BaseRenderer base_ren_type;
+        typedef typename base_ren_type::color_type color_type;
+
+        //--------------------------------------------------------------------
+        renderer_scanline_aa_solid() : m_ren(0) {}
+        explicit renderer_scanline_aa_solid(base_ren_type& ren) : m_ren(&ren) {}
+        void attach(base_ren_type& ren)
+        {
+            m_ren = &ren;
+        }
+        
+        //--------------------------------------------------------------------
+        void color(const color_type& c) { m_color = c; }
+        const color_type& color() const { return m_color; }
+
+        //--------------------------------------------------------------------
+        void prepare() {}
+
+        //--------------------------------------------------------------------
+        template<class Scanline> void render(const Scanline& sl)
+        {
+            render_scanline_aa_solid(sl, *m_ren, m_color);
+        }
+        
+    private:
+        base_ren_type* m_ren;
+        color_type m_color;
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+
+    //======================================================render_scanline_aa
+    template<class Scanline, class BaseRenderer, 
+             class SpanAllocator, class SpanGenerator> 
+    void render_scanline_aa(const Scanline& sl, BaseRenderer& ren, 
+                            SpanAllocator& alloc, SpanGenerator& span_gen)
+    {
+        int y = sl.y();
+
+        unsigned num_spans = sl.num_spans();
+        typename Scanline::const_iterator span = sl.begin();
+        for(;;)
+        {
+            int x = span->x;
+            int len = span->len;
+            const typename Scanline::cover_type* covers = span->covers;
+
+            if(len < 0) len = -len;
+            typename BaseRenderer::color_type* colors = alloc.allocate(len);
+            span_gen.generate(colors, x, y, len);
+            ren.blend_color_hspan(x, y, len, colors, 
+                                  (span->len < 0) ? 0 : covers, *covers);
+
+            if(--num_spans == 0) break;
+            ++span;
+        }
+    }
+
+    //=====================================================render_scanlines_aa
+    template<class Rasterizer, class Scanline, class BaseRenderer, 
+             class SpanAllocator, class SpanGenerator>
+    void render_scanlines_aa(Rasterizer& ras, Scanline& sl, BaseRenderer& ren, 
+                             SpanAllocator& alloc, SpanGenerator& span_gen)
+    {
+        if(ras.rewind_scanlines())
+        {
+            sl.reset(ras.min_x(), ras.max_x());
+            span_gen.prepare();
+            while(ras.sweep_scanline(sl))
+            {
+                render_scanline_aa(sl, ren, alloc, span_gen);
+            }
+        }
+    }
+
+    //====================================================renderer_scanline_aa
+    template<class BaseRenderer, class SpanAllocator, class SpanGenerator> 
+    class renderer_scanline_aa
+    {
+    public:
+        typedef BaseRenderer  base_ren_type;
+        typedef SpanAllocator alloc_type;
+        typedef SpanGenerator span_gen_type;
+
+        //--------------------------------------------------------------------
+        renderer_scanline_aa() : m_ren(0), m_alloc(0), m_span_gen(0) {}
+        renderer_scanline_aa(base_ren_type& ren, 
+                             alloc_type& alloc, 
+                             span_gen_type& span_gen) :
+            m_ren(&ren),
+            m_alloc(&alloc),
+            m_span_gen(&span_gen)
+        {}
+        void attach(base_ren_type& ren, 
+                    alloc_type& alloc, 
+                    span_gen_type& span_gen)
+        {
+            m_ren = &ren;
+            m_alloc = &alloc;
+            m_span_gen = &span_gen;
+        }
+        
+        //--------------------------------------------------------------------
+        void prepare() { m_span_gen->prepare(); }
+
+        //--------------------------------------------------------------------
+        template<class Scanline> void render(const Scanline& sl)
+        {
+            render_scanline_aa(sl, *m_ren, *m_alloc, *m_span_gen);
+        }
+
+    private:
+        base_ren_type* m_ren;
+        alloc_type*    m_alloc;
+        span_gen_type* m_span_gen;
+    };
+
+
+
+
+
+
+    //===============================================render_scanline_bin_solid
+    template<class Scanline, class BaseRenderer, class ColorT> 
+    void render_scanline_bin_solid(const Scanline& sl, 
+                                   BaseRenderer& ren, 
+                                   const ColorT& color)
+    {
+        unsigned num_spans = sl.num_spans();
+        typename Scanline::const_iterator span = sl.begin();
+        for(;;)
+        {
+            ren.blend_hline(span->x, 
+                            sl.y(), 
+                            span->x - 1 + ((span->len < 0) ? 
+                                              -span->len : 
+                                               span->len), 
+                               color, 
+                               cover_full);
+            if(--num_spans == 0) break;
+            ++span;
+        }
+    }
+
+    //==============================================render_scanlines_bin_solid
+    template<class Rasterizer, class Scanline, 
+             class BaseRenderer, class ColorT>
+    void render_scanlines_bin_solid(Rasterizer& ras, Scanline& sl, 
+                                    BaseRenderer& ren, const ColorT& color)
+    {
+        if(ras.rewind_scanlines())
+        {
+            // Explicitly convert "color" to the BaseRenderer color type.
+            // For example, it can be called with color type "rgba", while
+            // "rgba8" is needed. Otherwise it will be implicitly 
+            // converted in the loop many times.
+            //----------------------
+            typename BaseRenderer::color_type ren_color(color);
+
+            sl.reset(ras.min_x(), ras.max_x());
+            while(ras.sweep_scanline(sl))
+            {
+                //render_scanline_bin_solid(sl, ren, ren_color);
+
+                // This code is equivalent to the above call (copy/paste). 
+                // It's just a "manual" optimization for old compilers,
+                // like Microsoft Visual C++ v6.0
+                //-------------------------------
+                unsigned num_spans = sl.num_spans();
+                typename Scanline::const_iterator span = sl.begin();
+                for(;;)
+                {
+                    ren.blend_hline(span->x, 
+                                    sl.y(), 
+                                    span->x - 1 + ((span->len < 0) ? 
+                                                      -span->len : 
+                                                       span->len), 
+                                       ren_color, 
+                                       cover_full);
+                    if(--num_spans == 0) break;
+                    ++span;
+                }
+            }
+        }
+    }
+
+    //=============================================renderer_scanline_bin_solid
+    template<class BaseRenderer> class renderer_scanline_bin_solid
+    {
+    public:
+        typedef BaseRenderer base_ren_type;
+        typedef typename base_ren_type::color_type color_type;
+
+        //--------------------------------------------------------------------
+        renderer_scanline_bin_solid() : m_ren(0) {}
+        explicit renderer_scanline_bin_solid(base_ren_type& ren) : m_ren(&ren) {}
+        void attach(base_ren_type& ren)
+        {
+            m_ren = &ren;
+        }
+        
+        //--------------------------------------------------------------------
+        void color(const color_type& c) { m_color = c; }
+        const color_type& color() const { return m_color; }
+
+        //--------------------------------------------------------------------
+        void prepare() {}
+
+        //--------------------------------------------------------------------
+        template<class Scanline> void render(const Scanline& sl)
+        {
+            render_scanline_bin_solid(sl, *m_ren, m_color);
+        }
+        
+    private:
+        base_ren_type* m_ren;
+        color_type m_color;
+    };
+
+
+
+
+
+
+
+
+    //======================================================render_scanline_bin
+    template<class Scanline, class BaseRenderer, 
+             class SpanAllocator, class SpanGenerator> 
+    void render_scanline_bin(const Scanline& sl, BaseRenderer& ren, 
+                             SpanAllocator& alloc, SpanGenerator& span_gen)
+    {
+        int y = sl.y();
+
+        unsigned num_spans = sl.num_spans();
+        typename Scanline::const_iterator span = sl.begin();
+        for(;;)
+        {
+            int x = span->x;
+            int len = span->len;
+            if(len < 0) len = -len;
+            typename BaseRenderer::color_type* colors = alloc.allocate(len);
+            span_gen.generate(colors, x, y, len);
+            ren.blend_color_hspan(x, y, len, colors, 0, cover_full); 
+            if(--num_spans == 0) break;
+            ++span;
+        }
+    }
+
+    //=====================================================render_scanlines_bin
+    template<class Rasterizer, class Scanline, class BaseRenderer, 
+             class SpanAllocator, class SpanGenerator>
+    void render_scanlines_bin(Rasterizer& ras, Scanline& sl, BaseRenderer& ren, 
+                              SpanAllocator& alloc, SpanGenerator& span_gen)
+    {
+        if(ras.rewind_scanlines())
+        {
+            sl.reset(ras.min_x(), ras.max_x());
+            span_gen.prepare();
+            while(ras.sweep_scanline(sl))
+            {
+                render_scanline_bin(sl, ren, alloc, span_gen);
+            }
+        }
+    }
+
+    //====================================================renderer_scanline_bin
+    template<class BaseRenderer, class SpanAllocator, class SpanGenerator> 
+    class renderer_scanline_bin
+    {
+    public:
+        typedef BaseRenderer  base_ren_type;
+        typedef SpanAllocator alloc_type;
+        typedef SpanGenerator span_gen_type;
+
+        //--------------------------------------------------------------------
+        renderer_scanline_bin() : m_ren(0), m_alloc(0), m_span_gen(0) {}
+        renderer_scanline_bin(base_ren_type& ren, 
+                              alloc_type& alloc, 
+                              span_gen_type& span_gen) :
+            m_ren(&ren),
+            m_alloc(&alloc),
+            m_span_gen(&span_gen)
+        {}
+        void attach(base_ren_type& ren, 
+                    alloc_type& alloc, 
+                    span_gen_type& span_gen)
+        {
+            m_ren = &ren;
+            m_alloc = &alloc;
+            m_span_gen = &span_gen;
+        }
+        
+        //--------------------------------------------------------------------
+        void prepare() { m_span_gen->prepare(); }
+
+        //--------------------------------------------------------------------
+        template<class Scanline> void render(const Scanline& sl)
+        {
+            render_scanline_bin(sl, *m_ren, *m_alloc, *m_span_gen);
+        }
+
+    private:
+        base_ren_type* m_ren;
+        alloc_type*    m_alloc;
+        span_gen_type* m_span_gen;
+    };
+
+
+
+
+
+
+
+
+
+
+    //========================================================render_scanlines
+    template<class Rasterizer, class Scanline, class Renderer>
+    void render_scanlines(Rasterizer& ras, Scanline& sl, Renderer& ren)
+    {
+        if(ras.rewind_scanlines())
+        {
+            sl.reset(ras.min_x(), ras.max_x());
+            ren.prepare();
+            while(ras.sweep_scanline(sl))
+            {
+                ren.render(sl);
+            }
+        }
+    }
+
+    //========================================================render_all_paths
+    template<class Rasterizer, class Scanline, class Renderer, 
+             class VertexSource, class ColorStorage, class PathId>
+    void render_all_paths(Rasterizer& ras, 
+                          Scanline& sl,
+                          Renderer& r, 
+                          VertexSource& vs, 
+                          const ColorStorage& as, 
+                          const PathId& path_id,
+                          unsigned num_paths)
+    {
+        for(unsigned i = 0; i < num_paths; i++)
+        {
+            ras.reset();
+            ras.add_path(vs, path_id[i]);
+            r.color(as[i]);
+            render_scanlines(ras, sl, r);
+        }
+    }
+
+
+
+
+
+
+    //=============================================render_scanlines_compound
+    template<class Rasterizer, 
+             class ScanlineAA, 
+             class ScanlineBin, 
+             class BaseRenderer, 
+             class SpanAllocator,
+             class StyleHandler>
+    void render_scanlines_compound(Rasterizer& ras, 
+                                   ScanlineAA& sl_aa,
+                                   ScanlineBin& sl_bin,
+                                   BaseRenderer& ren,
+                                   SpanAllocator& alloc,
+                                   StyleHandler& sh)
+    {
+        if(ras.rewind_scanlines())
+        {
+            int min_x = ras.min_x();
+            int len = ras.max_x() - min_x + 2;
+            sl_aa.reset(min_x, ras.max_x());
+            sl_bin.reset(min_x, ras.max_x());
+
+            typedef typename BaseRenderer::color_type color_type;
+            color_type* color_span = alloc.allocate(len * 2);
+            color_type* mix_buffer = color_span + len;
+            unsigned num_spans;
+
+            unsigned num_styles;
+            unsigned style;
+            bool     solid;
+            while((num_styles = ras.sweep_styles()) > 0)
+            {
+                typename ScanlineAA::const_iterator span_aa;
+                if(num_styles == 1)
+                {
+                    // Optimization for a single style. Happens often
+                    //-------------------------
+                    if(ras.sweep_scanline(sl_aa, 0))
+                    {
+                        style = ras.style(0);
+                        if(sh.is_solid(style))
+                        {
+                            // Just solid fill
+                            //-----------------------
+                            render_scanline_aa_solid(sl_aa, ren, sh.color(style));
+                        }
+                        else
+                        {
+                            // Arbitrary span generator
+                            //-----------------------
+                            span_aa   = sl_aa.begin();
+                            num_spans = sl_aa.num_spans();
+                            for(;;)
+                            {
+                                len = span_aa->len;
+                                sh.generate_span(color_span, 
+                                                 span_aa->x, 
+                                                 sl_aa.y(), 
+                                                 len, 
+                                                 style);
+
+                                ren.blend_color_hspan(span_aa->x, 
+                                                      sl_aa.y(), 
+                                                      span_aa->len,
+                                                      color_span,
+                                                      span_aa->covers);
+                                if(--num_spans == 0) break;
+                                ++span_aa;
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    if(ras.sweep_scanline(sl_bin, -1))
+                    {
+                        // Clear the spans of the mix_buffer
+                        //--------------------
+                        typename ScanlineBin::const_iterator span_bin = sl_bin.begin();
+                        num_spans = sl_bin.num_spans();
+                        for(;;)
+                        {
+                            memset(mix_buffer + span_bin->x - min_x, 
+                                   0, 
+                                   span_bin->len * sizeof(color_type));
+
+                            if(--num_spans == 0) break;
+                            ++span_bin;
+                        }
+
+                        unsigned i;
+                        for(i = 0; i < num_styles; i++)
+                        {
+                            style = ras.style(i);
+                            solid = sh.is_solid(style);
+
+                            if(ras.sweep_scanline(sl_aa, i))
+                            {
+                                color_type* colors;
+                                color_type* cspan;
+                                typename ScanlineAA::cover_type* covers;
+                                span_aa   = sl_aa.begin();
+                                num_spans = sl_aa.num_spans();
+                                if(solid)
+                                {
+                                    // Just solid fill
+                                    //-----------------------
+                                    for(;;)
+                                    {
+                                        color_type c = sh.color(style);
+                                        len    = span_aa->len;
+                                        colors = mix_buffer + span_aa->x - min_x;
+                                        covers = span_aa->covers;
+                                        do
+                                        {
+                                            if(*covers == cover_full) 
+                                            {
+                                                *colors = c;
+                                            }
+                                            else
+                                            {
+                                                colors->add(c, *covers);
+                                            }
+                                            ++colors;
+                                            ++covers;
+                                        }
+                                        while(--len);
+                                        if(--num_spans == 0) break;
+                                        ++span_aa;
+                                    }
+                                }
+                                else
+                                {
+                                    // Arbitrary span generator
+                                    //-----------------------
+                                    for(;;)
+                                    {
+                                        len = span_aa->len;
+                                        colors = mix_buffer + span_aa->x - min_x;
+                                        cspan  = color_span;
+                                        sh.generate_span(cspan, 
+                                                         span_aa->x, 
+                                                         sl_aa.y(), 
+                                                         len, 
+                                                         style);
+                                        covers = span_aa->covers;
+                                        do
+                                        {
+                                            if(*covers == cover_full) 
+                                            {
+                                                *colors = *cspan;
+                                            }
+                                            else
+                                            {
+                                                colors->add(*cspan, *covers);
+                                            }
+                                            ++cspan;
+                                            ++colors;
+                                            ++covers;
+                                        }
+                                        while(--len);
+                                        if(--num_spans == 0) break;
+                                        ++span_aa;
+                                    }
+                                }
+                            }
+                        }
+
+                        // Emit the blended result as a color hspan
+                        //-------------------------
+                        span_bin = sl_bin.begin();
+                        num_spans = sl_bin.num_spans();
+                        for(;;)
+                        {
+                            ren.blend_color_hspan(span_bin->x, 
+                                                  sl_bin.y(), 
+                                                  span_bin->len,
+                                                  mix_buffer + span_bin->x - min_x,
+                                                  0,
+                                                  cover_full);
+                            if(--num_spans == 0) break;
+                            ++span_bin;
+                        }
+                    } // if(ras.sweep_scanline(sl_bin, -1))
+                } // if(num_styles == 1) ... else
+            } // while((num_styles = ras.sweep_styles()) > 0)
+        } // if(ras.rewind_scanlines())
+    }
+
+    //=======================================render_scanlines_compound_layered
+    template<class Rasterizer, 
+             class ScanlineAA, 
+             class BaseRenderer, 
+             class SpanAllocator,
+             class StyleHandler>
+    void render_scanlines_compound_layered(Rasterizer& ras, 
+                                           ScanlineAA& sl_aa,
+                                           BaseRenderer& ren,
+                                           SpanAllocator& alloc,
+                                           StyleHandler& sh)
+    {
+        if(ras.rewind_scanlines())
+        {
+            int min_x = ras.min_x();
+            int len = ras.max_x() - min_x + 2;
+            sl_aa.reset(min_x, ras.max_x());
+
+            typedef typename BaseRenderer::color_type color_type;
+            color_type* color_span   = alloc.allocate(len * 2);
+            color_type* mix_buffer   = color_span + len;
+            cover_type* cover_buffer = ras.allocate_cover_buffer(len);
+            unsigned num_spans;
+
+            unsigned num_styles;
+            unsigned style;
+            bool     solid;
+            while((num_styles = ras.sweep_styles()) > 0)
+            {
+                typename ScanlineAA::const_iterator span_aa;
+                if(num_styles == 1)
+                {
+                    // Optimization for a single style. Happens often
+                    //-------------------------
+                    if(ras.sweep_scanline(sl_aa, 0))
+                    {
+                        style = ras.style(0);
+                        if(sh.is_solid(style))
+                        {
+                            // Just solid fill
+                            //-----------------------
+                            render_scanline_aa_solid(sl_aa, ren, sh.color(style));
+                        }
+                        else
+                        {
+                            // Arbitrary span generator
+                            //-----------------------
+                            span_aa   = sl_aa.begin();
+                            num_spans = sl_aa.num_spans();
+                            for(;;)
+                            {
+                                len = span_aa->len;
+                                sh.generate_span(color_span, 
+                                                 span_aa->x, 
+                                                 sl_aa.y(), 
+                                                 len, 
+                                                 style);
+
+                                ren.blend_color_hspan(span_aa->x, 
+                                                      sl_aa.y(), 
+                                                      span_aa->len,
+                                                      color_span,
+                                                      span_aa->covers);
+                                if(--num_spans == 0) break;
+                                ++span_aa;
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    int      sl_start = ras.scanline_start();
+                    unsigned sl_len   = ras.scanline_length();
+
+                    if(sl_len)
+                    {
+                        memset(mix_buffer + sl_start - min_x, 
+                               0, 
+                               sl_len * sizeof(color_type));
+
+                        memset(cover_buffer + sl_start - min_x, 
+                               0, 
+                               sl_len * sizeof(cover_type));
+
+                        int sl_y = std::numeric_limits<int>::max();
+                        unsigned i;
+                        for(i = 0; i < num_styles; i++)
+                        {
+                            style = ras.style(i);
+                            solid = sh.is_solid(style);
+
+                            if(ras.sweep_scanline(sl_aa, i))
+                            {
+                                unsigned    cover;
+                                color_type* colors;
+                                color_type* cspan;
+                                cover_type* src_covers;
+                                cover_type* dst_covers;
+                                span_aa   = sl_aa.begin();
+                                num_spans = sl_aa.num_spans();
+                                sl_y      = sl_aa.y();
+                                if(solid)
+                                {
+                                    // Just solid fill
+                                    //-----------------------
+                                    for(;;)
+                                    {
+                                        color_type c = sh.color(style);
+                                        len    = span_aa->len;
+                                        colors = mix_buffer + span_aa->x - min_x;
+                                        src_covers = span_aa->covers;
+                                        dst_covers = cover_buffer + span_aa->x - min_x;
+                                        do
+                                        {
+                                            cover = *src_covers;
+                                            if(*dst_covers + cover > cover_full)
+                                            {
+                                                cover = cover_full - *dst_covers;
+                                            }
+                                            if(cover)
+                                            {
+                                                colors->add(c, cover);
+                                                *dst_covers += cover;
+                                            }
+                                            ++colors;
+                                            ++src_covers;
+                                            ++dst_covers;
+                                        }
+                                        while(--len);
+                                        if(--num_spans == 0) break;
+                                        ++span_aa;
+                                    }
+                                }
+                                else
+                                {
+                                    // Arbitrary span generator
+                                    //-----------------------
+                                    for(;;)
+                                    {
+                                        len = span_aa->len;
+                                        colors = mix_buffer + span_aa->x - min_x;
+                                        cspan  = color_span;
+                                        sh.generate_span(cspan, 
+                                                         span_aa->x, 
+                                                         sl_aa.y(), 
+                                                         len, 
+                                                         style);
+                                        src_covers = span_aa->covers;
+                                        dst_covers = cover_buffer + span_aa->x - min_x;
+                                        do
+                                        {
+                                            cover = *src_covers;
+                                            if(*dst_covers + cover > cover_full)
+                                            {
+                                                cover = cover_full - *dst_covers;
+                                            }
+                                            if(cover)
+                                            {
+                                                colors->add(*cspan, cover);
+                                                *dst_covers += cover;
+                                            }
+                                            ++cspan;
+                                            ++colors;
+                                            ++src_covers;
+                                            ++dst_covers;
+                                        }
+                                        while(--len);
+                                        if(--num_spans == 0) break;
+                                        ++span_aa;
+                                    }
+                                }
+                            }
+                        }
+                        ren.blend_color_hspan(sl_start, 
+                                              sl_y, 
+                                              sl_len,
+                                              mix_buffer + sl_start - min_x,
+                                              0,
+                                              cover_full);
+                    } //if(sl_len)
+                } //if(num_styles == 1) ... else
+            } //while((num_styles = ras.sweep_styles()) > 0)
+        } //if(ras.rewind_scanlines())
+    }
+
+
+}
+
+#endif

src/agg/agg_rendering_buffer.h

@@ -0,0 +1,300 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// class rendering_buffer
+//
+//----------------------------------------------------------------------------
+
+#ifndef AGG_RENDERING_BUFFER_INCLUDED
+#define AGG_RENDERING_BUFFER_INCLUDED
+
+#include "agg_array.h"
+
+namespace agg
+{
+
+    //===========================================================row_accessor
+    template<class T> class row_accessor
+    {
+    public:
+        typedef const_row_info<T> row_data;
+
+        //-------------------------------------------------------------------
+        row_accessor() :
+            m_buf(0),
+            m_start(0),
+            m_width(0),
+            m_height(0),
+            m_stride(0)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        row_accessor(T* buf, unsigned width, unsigned height, int stride) :
+            m_buf(0),
+            m_start(0),
+            m_width(0),
+            m_height(0),
+            m_stride(0)
+        {
+            attach(buf, width, height, stride);
+        }
+
+
+        //--------------------------------------------------------------------
+        void attach(T* buf, unsigned width, unsigned height, int stride)
+        {
+            m_buf = m_start = buf;
+            m_width = width;
+            m_height = height;
+            m_stride = stride;
+            if(stride < 0) 
+            { 
+                m_start = m_buf - int(height - 1) * stride;
+            }
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       T* buf()          { return m_buf;    }
+        AGG_INLINE const T* buf()    const { return m_buf;    }
+        AGG_INLINE unsigned width()  const { return m_width;  }
+        AGG_INLINE unsigned height() const { return m_height; }
+        AGG_INLINE int      stride() const { return m_stride; }
+        AGG_INLINE unsigned stride_abs() const 
+        {
+            return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); 
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       T* row_ptr(int, int y, unsigned) 
+        { 
+            return m_start + y * m_stride; 
+        }
+        AGG_INLINE       T* row_ptr(int y)       { return m_start + y * m_stride; }
+        AGG_INLINE const T* row_ptr(int y) const { return m_start + y * m_stride; }
+        AGG_INLINE row_data row    (int y) const 
+        { 
+            return row_data(0, m_width-1, row_ptr(y)); 
+        }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf>
+        void copy_from(const RenBuf& src)
+        {
+            unsigned h = height();
+            if(src.height() < h) h = src.height();
+        
+            unsigned l = stride_abs();
+            if(src.stride_abs() < l) l = src.stride_abs();
+        
+            l *= sizeof(T);
+
+            unsigned y;
+            unsigned w = width();
+            for (y = 0; y < h; y++)
+            {
+                memcpy(row_ptr(0, y, w), src.row_ptr(y), l);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void clear(T value)
+        {
+            unsigned y;
+            unsigned w = width();
+            unsigned stride = stride_abs();
+            for(y = 0; y < height(); y++)
+            {
+                T* p = row_ptr(0, y, w);
+                unsigned x;
+                for(x = 0; x < stride; x++)
+                {
+                    *p++ = value;
+                }
+            }
+        }
+
+    private:
+        //--------------------------------------------------------------------
+        T*            m_buf;    // Pointer to renrdering buffer
+        T*            m_start;  // Pointer to first pixel depending on stride 
+        unsigned      m_width;  // Width in pixels
+        unsigned      m_height; // Height in pixels
+        int           m_stride; // Number of bytes per row. Can be < 0
+    };
+
+
+
+
+    //==========================================================row_ptr_cache
+    template<class T> class row_ptr_cache
+    {
+    public:
+        typedef const_row_info<T> row_data;
+
+        //-------------------------------------------------------------------
+        row_ptr_cache() :
+            m_buf(0),
+            m_rows(),
+            m_width(0),
+            m_height(0),
+            m_stride(0)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        row_ptr_cache(T* buf, unsigned width, unsigned height, int stride) :
+            m_buf(0),
+            m_rows(),
+            m_width(0),
+            m_height(0),
+            m_stride(0)
+        {
+            attach(buf, width, height, stride);
+        }
+
+        //--------------------------------------------------------------------
+        void attach(T* buf, unsigned width, unsigned height, int stride)
+        {
+            m_buf = buf;
+            m_width = width;
+            m_height = height;
+            m_stride = stride;
+            if(height > m_rows.size())
+            {
+                m_rows.resize(height);
+            }
+
+            T* row_ptr = m_buf;
+
+            if(stride < 0)
+            {
+                row_ptr = m_buf - int(height - 1) * stride;
+            }
+
+            T** rows = &m_rows[0];
+
+            while(height--)
+            {
+                *rows++ = row_ptr;
+                row_ptr += stride;
+            }
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       T* buf()          { return m_buf;    }
+        AGG_INLINE const T* buf()    const { return m_buf;    }
+        AGG_INLINE unsigned width()  const { return m_width;  }
+        AGG_INLINE unsigned height() const { return m_height; }
+        AGG_INLINE int      stride() const { return m_stride; }
+        AGG_INLINE unsigned stride_abs() const 
+        {
+            return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); 
+        }
+
+        //--------------------------------------------------------------------
+        AGG_INLINE       T* row_ptr(int, int y, unsigned) 
+        { 
+            return m_rows[y]; 
+        }
+        AGG_INLINE       T* row_ptr(int y)       { return m_rows[y]; }
+        AGG_INLINE const T* row_ptr(int y) const { return m_rows[y]; }
+        AGG_INLINE row_data row    (int y) const 
+        { 
+            return row_data(0, m_width-1, m_rows[y]); 
+        }
+
+        //--------------------------------------------------------------------
+        T const* const* rows() const { return &m_rows[0]; }
+
+        //--------------------------------------------------------------------
+        template<class RenBuf>
+        void copy_from(const RenBuf& src)
+        {
+            unsigned h = height();
+            if(src.height() < h) h = src.height();
+        
+            unsigned l = stride_abs();
+            if(src.stride_abs() < l) l = src.stride_abs();
+        
+            l *= sizeof(T);
+
+            unsigned y;
+            unsigned w = width();
+            for (y = 0; y < h; y++)
+            {
+                memcpy(row_ptr(0, y, w), src.row_ptr(y), l);
+            }
+        }
+
+        //--------------------------------------------------------------------
+        void clear(T value)
+        {
+            unsigned y;
+            unsigned w = width();
+            unsigned stride = stride_abs();
+            for(y = 0; y < height(); y++)
+            {
+                T* p = row_ptr(0, y, w);
+                unsigned x;
+                for(x = 0; x < stride; x++)
+                {
+                    *p++ = value;
+                }
+            }
+        }
+
+    private:
+        //--------------------------------------------------------------------
+        T*            m_buf;        // Pointer to renrdering buffer
+        pod_array<T*> m_rows;       // Pointers to each row of the buffer
+        unsigned      m_width;      // Width in pixels
+        unsigned      m_height;     // Height in pixels
+        int           m_stride;     // Number of bytes per row. Can be < 0
+    };
+
+
+
+
+    //========================================================rendering_buffer
+    // 
+    // The definition of the main type for accessing the rows in the frame 
+    // buffer. It provides functionality to navigate to the rows in a 
+    // rectangular matrix, from top to bottom or from bottom to top depending 
+    // on stride.
+    //
+    // row_accessor is cheap to create/destroy, but performs one multiplication
+    // when calling row_ptr().
+    // 
+    // row_ptr_cache creates an array of pointers to rows, so, the access 
+    // via row_ptr() may be faster. But it requires memory allocation 
+    // when creating. For example, on typical Intel Pentium hardware 
+    // row_ptr_cache speeds span_image_filter_rgb_nn up to 10%
+    //
+    // It's used only in short hand typedefs like pixfmt_rgba32 and can be 
+    // redefined in agg_config.h
+    // In real applications you can use both, depending on your needs
+    //------------------------------------------------------------------------
+#ifdef AGG_RENDERING_BUFFER
+    typedef AGG_RENDERING_BUFFER rendering_buffer;
+#else
+//  typedef row_ptr_cache<int8u> rendering_buffer;
+    typedef row_accessor<int8u> rendering_buffer;
+#endif
+
+}
+
+
+#endif

src/agg/agg_scanline_p.h

@@ -0,0 +1,329 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Class scanline_p - a general purpose scanline container with packed spans.
+//
+//----------------------------------------------------------------------------
+//
+// Adaptation for 32-bit screen coordinates (scanline32_p) has been sponsored by 
+// Liberty Technology Systems, Inc., visit http://lib-sys.com
+//
+// Liberty Technology Systems, Inc. is the provider of
+// PostScript and PDF technology for software developers.
+// 
+//----------------------------------------------------------------------------
+#ifndef AGG_SCANLINE_P_INCLUDED
+#define AGG_SCANLINE_P_INCLUDED
+
+#include "agg_array.h"
+
+namespace agg
+{
+
+    //=============================================================scanline_p8
+    // 
+    // This is a general purpose scaline container which supports the interface 
+    // used in the rasterizer::render(). See description of scanline_u8
+    // for details.
+    // 
+    //------------------------------------------------------------------------
+    class scanline_p8
+    {
+    public:
+        typedef scanline_p8 self_type;
+        typedef int8u       cover_type;
+        typedef int16       coord_type;
+
+        //--------------------------------------------------------------------
+        struct span
+        {
+            coord_type        x;
+            coord_type        len; // If negative, it's a solid span, covers is valid
+            const cover_type* covers;
+        };
+
+        typedef span* iterator;
+        typedef const span* const_iterator;
+
+        scanline_p8() :
+            m_last_x(0x7FFFFFF0),
+            m_covers(),
+            m_cover_ptr(0),
+            m_spans(),
+            m_cur_span(0)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        void reset(int min_x, int max_x)
+        {
+            unsigned max_len = max_x - min_x + 3;
+            if(max_len > m_spans.size())
+            {
+                m_spans.resize(max_len);
+                m_covers.resize(max_len);
+            }
+            m_last_x    = 0x7FFFFFF0;
+            m_cover_ptr = &m_covers[0];
+            m_cur_span  = &m_spans[0];
+            m_cur_span->len = 0;
+        }
+
+        //--------------------------------------------------------------------
+        void add_cell(int x, unsigned cover)
+        {
+            *m_cover_ptr = (cover_type)cover;
+            if(x == m_last_x+1 && m_cur_span->len > 0)
+            {
+                m_cur_span->len++;
+            }
+            else
+            {
+                m_cur_span++;
+                m_cur_span->covers = m_cover_ptr;
+                m_cur_span->x = (int16)x;
+                m_cur_span->len = 1;
+            }
+            m_last_x = x;
+            m_cover_ptr++;
+        }
+
+        //--------------------------------------------------------------------
+        void add_cells(int x, unsigned len, const cover_type* covers)
+        {
+            memcpy(m_cover_ptr, covers, len * sizeof(cover_type));
+            if(x == m_last_x+1 && m_cur_span->len > 0)
+            {
+                m_cur_span->len += (int16)len;
+            }
+            else
+            {
+                m_cur_span++;
+                m_cur_span->covers = m_cover_ptr;
+                m_cur_span->x = (int16)x;
+                m_cur_span->len = (int16)len;
+            }
+            m_cover_ptr += len;
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void add_span(int x, unsigned len, unsigned cover)
+        {
+            if(x == m_last_x+1 && 
+               m_cur_span->len < 0 && 
+               cover == *m_cur_span->covers)
+            {
+                m_cur_span->len -= (int16)len;
+            }
+            else
+            {
+                *m_cover_ptr = (cover_type)cover;
+                m_cur_span++;
+                m_cur_span->covers = m_cover_ptr++;
+                m_cur_span->x      = (int16)x;
+                m_cur_span->len    = (int16)(-int(len));
+            }
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void finalize(int y) 
+        { 
+            m_y = y; 
+        }
+
+        //--------------------------------------------------------------------
+        void reset_spans()
+        {
+            m_last_x    = 0x7FFFFFF0;
+            m_cover_ptr = &m_covers[0];
+            m_cur_span  = &m_spans[0];
+            m_cur_span->len = 0;
+        }
+
+        //--------------------------------------------------------------------
+        int            y()         const { return m_y; }
+        unsigned       num_spans() const { return unsigned(m_cur_span - &m_spans[0]); }
+        const_iterator begin()     const { return &m_spans[1]; }
+
+    private:
+        scanline_p8(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        int                   m_last_x;
+        int                   m_y;
+        pod_array<cover_type> m_covers;
+        cover_type*           m_cover_ptr;
+        pod_array<span>       m_spans;
+        span*                 m_cur_span;
+    };
+
+
+
+
+
+
+
+
+    //==========================================================scanline32_p8
+    class scanline32_p8
+    {
+    public:
+        typedef scanline32_p8 self_type;
+        typedef int8u         cover_type;
+        typedef int32         coord_type;
+
+        struct span
+        {
+            span() {}
+            span(coord_type x_, coord_type len_, const cover_type* covers_) :
+                x(x_), len(len_), covers(covers_) {}
+
+            coord_type x;
+            coord_type len; // If negative, it's a solid span, covers is valid
+            const cover_type* covers;
+        };
+        typedef pod_bvector<span, 4> span_array_type;
+
+
+        //--------------------------------------------------------------------
+        class const_iterator
+        {
+        public:
+            const_iterator(const span_array_type& spans) :
+                m_spans(spans),
+                m_span_idx(0)
+            {}
+
+            const span& operator*()  const { return m_spans[m_span_idx];  }
+            const span* operator->() const { return &m_spans[m_span_idx]; }
+
+            void operator ++ () { ++m_span_idx; }
+
+        private:
+            const span_array_type& m_spans;
+            unsigned               m_span_idx;
+        };
+
+        //--------------------------------------------------------------------
+        scanline32_p8() :
+            m_max_len(0),
+            m_last_x(0x7FFFFFF0),
+            m_covers(),
+            m_cover_ptr(0)
+        {
+        }
+
+        //--------------------------------------------------------------------
+        void reset(int min_x, int max_x)
+        {
+            unsigned max_len = max_x - min_x + 3;
+            if(max_len > m_covers.size())
+            {
+                m_covers.resize(max_len);
+            }
+            m_last_x    = 0x7FFFFFF0;
+            m_cover_ptr = &m_covers[0];
+            m_spans.remove_all();
+        }
+
+        //--------------------------------------------------------------------
+        void add_cell(int x, unsigned cover)
+        {
+            *m_cover_ptr = cover_type(cover);
+            if(x == m_last_x+1 && m_spans.size() && m_spans.last().len > 0)
+            {
+                m_spans.last().len++;
+            }
+            else
+            {
+                m_spans.add(span(coord_type(x), 1, m_cover_ptr));
+            }
+            m_last_x = x;
+            m_cover_ptr++;
+        }
+
+        //--------------------------------------------------------------------
+        void add_cells(int x, unsigned len, const cover_type* covers)
+        {
+            memcpy(m_cover_ptr, covers, len * sizeof(cover_type));
+            if(x == m_last_x+1 && m_spans.size() && m_spans.last().len > 0)
+            {
+                m_spans.last().len += coord_type(len);
+            }
+            else
+            {
+                m_spans.add(span(coord_type(x), coord_type(len), m_cover_ptr));
+            }
+            m_cover_ptr += len;
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void add_span(int x, unsigned len, unsigned cover)
+        {
+            if(x == m_last_x+1 && 
+               m_spans.size() &&
+               m_spans.last().len < 0 && 
+               cover == *m_spans.last().covers)
+            {
+                m_spans.last().len -= coord_type(len);
+            }
+            else
+            {
+                *m_cover_ptr = cover_type(cover);
+                m_spans.add(span(coord_type(x), -coord_type(len), m_cover_ptr++));
+            }
+            m_last_x = x + len - 1;
+        }
+
+        //--------------------------------------------------------------------
+        void finalize(int y) 
+        { 
+            m_y = y; 
+        }
+
+        //--------------------------------------------------------------------
+        void reset_spans()
+        {
+            m_last_x    = 0x7FFFFFF0;
+            m_cover_ptr = &m_covers[0];
+            m_spans.remove_all();
+        }
+
+        //--------------------------------------------------------------------
+        int            y()         const { return m_y; }
+        unsigned       num_spans() const { return m_spans.size(); }
+        const_iterator begin()     const { return const_iterator(m_spans); }
+
+    private:
+        scanline32_p8(const self_type&);
+        const self_type& operator = (const self_type&);
+
+        unsigned              m_max_len;
+        int                   m_last_x;
+        int                   m_y;
+        pod_array<cover_type> m_covers;
+        cover_type*           m_cover_ptr;
+        span_array_type       m_spans;
+    };
+
+
+}
+
+
+#endif
+

src/agg/agg_trans_affine.h

@@ -0,0 +1,518 @@
+//----------------------------------------------------------------------------
+// Anti-Grain Geometry - Version 2.4
+// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
+//
+// Permission to copy, use, modify, sell and distribute this software 
+// is granted provided this copyright notice appears in all copies. 
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+//
+//----------------------------------------------------------------------------
+// Contact: mcseem@antigrain.com
+//          mcseemagg@yahoo.com
+//          http://www.antigrain.com
+//----------------------------------------------------------------------------
+//
+// Affine transformation classes.
+//
+//----------------------------------------------------------------------------
+#ifndef AGG_TRANS_AFFINE_INCLUDED
+#define AGG_TRANS_AFFINE_INCLUDED
+
+#include <math.h>
+#include "agg_basics.h"
+
+namespace agg
+{
+    const double affine_epsilon = 1e-14; 
+
+    //============================================================trans_affine
+    //
+    // See Implementation agg_trans_affine.cpp
+    //
+    // Affine transformation are linear transformations in Cartesian coordinates
+    // (strictly speaking not only in Cartesian, but for the beginning we will 
+    // think so). They are rotation, scaling, translation and skewing.  
+    // After any affine transformation a line segment remains a line segment 
+    // and it will never become a curve. 
+    //
+    // There will be no math about matrix calculations, since it has been 
+    // described many times. Ask yourself a very simple question:
+    // "why do we need to understand and use some matrix stuff instead of just 
+    // rotating, scaling and so on". The answers are:
+    //
+    // 1. Any combination of transformations can be done by only 4 multiplications
+    //    and 4 additions in floating point.
+    // 2. One matrix transformation is equivalent to the number of consecutive
+    //    discrete transformations, i.e. the matrix "accumulates" all transformations 
+    //    in the order of their settings. Suppose we have 4 transformations: 
+    //       * rotate by 30 degrees,
+    //       * scale X to 2.0, 
+    //       * scale Y to 1.5, 
+    //       * move to (100, 100). 
+    //    The result will depend on the order of these transformations, 
+    //    and the advantage of matrix is that the sequence of discret calls:
+    //    rotate(30), scaleX(2.0), scaleY(1.5), move(100,100) 
+    //    will have exactly the same result as the following matrix transformations:
+    //   
+    //    affine_matrix m;
+    //    m *= rotate_matrix(30); 
+    //    m *= scaleX_matrix(2.0);
+    //    m *= scaleY_matrix(1.5);
+    //    m *= move_matrix(100,100);
+    //
+    //    m.transform_my_point_at_last(x, y);
+    //
+    // What is the good of it? In real life we will set-up the matrix only once
+    // and then transform many points, let alone the convenience to set any 
+    // combination of transformations.
+    //
+    // So, how to use it? Very easy - literally as it's shown above. Not quite,
+    // let us write a correct example:
+    //
+    // agg::trans_affine m;
+    // m *= agg::trans_affine_rotation(30.0 * 3.1415926 / 180.0);
+    // m *= agg::trans_affine_scaling(2.0, 1.5);
+    // m *= agg::trans_affine_translation(100.0, 100.0);
+    // m.transform(&x, &y);
+    //
+    // The affine matrix is all you need to perform any linear transformation,
+    // but all transformations have origin point (0,0). It means that we need to 
+    // use 2 translations if we want to rotate someting around (100,100):
+    // 
+    // m *= agg::trans_affine_translation(-100.0, -100.0);         // move to (0,0)
+    // m *= agg::trans_affine_rotation(30.0 * 3.1415926 / 180.0);  // rotate
+    // m *= agg::trans_affine_translation(100.0, 100.0);           // move back to (100,100)
+    //----------------------------------------------------------------------
+    struct trans_affine
+    {
+        double sx, shy, shx, sy, tx, ty;
+
+        //------------------------------------------ Construction
+        // Identity matrix
+        trans_affine() :
+            sx(1.0), shy(0.0), shx(0.0), sy(1.0), tx(0.0), ty(0.0)
+        {}
+
+        // Custom matrix. Usually used in derived classes
+        trans_affine(double v0, double v1, double v2, 
+                     double v3, double v4, double v5) :
+            sx(v0), shy(v1), shx(v2), sy(v3), tx(v4), ty(v5)
+        {}
+
+        // Custom matrix from m[6]
+        explicit trans_affine(const double* m) :
+            sx(m[0]), shy(m[1]), shx(m[2]), sy(m[3]), tx(m[4]), ty(m[5])
+        {}
+
+        // Rectangle to a parallelogram.
+        trans_affine(double x1, double y1, double x2, double y2, 
+                     const double* parl)
+        {
+            rect_to_parl(x1, y1, x2, y2, parl);
+        }
+
+        // Parallelogram to a rectangle.
+        trans_affine(const double* parl, 
+                     double x1, double y1, double x2, double y2)
+        {
+            parl_to_rect(parl, x1, y1, x2, y2);
+        }
+
+        // Arbitrary parallelogram transformation.
+        trans_affine(const double* src, const double* dst)
+        {
+            parl_to_parl(src, dst);
+        }
+
+        //---------------------------------- Parellelogram transformations
+        // transform a parallelogram to another one. Src and dst are 
+        // pointers to arrays of three points (double[6], x1,y1,...) that 
+        // identify three corners of the parallelograms assuming implicit 
+        // fourth point. The arguments are arrays of double[6] mapped 
+        // to x1,y1, x2,y2, x3,y3  where the coordinates are:
+        //        *-----------------*
+        //       /          (x3,y3)/
+        //      /                 /
+        //     /(x1,y1)   (x2,y2)/
+        //    *-----------------*
+        const trans_affine& parl_to_parl(const double* src, 
+                                         const double* dst);
+
+        const trans_affine& rect_to_parl(double x1, double y1, 
+                                         double x2, double y2, 
+                                         const double* parl);
+
+        const trans_affine& parl_to_rect(const double* parl, 
+                                         double x1, double y1, 
+                                         double x2, double y2);
+
+
+        //------------------------------------------ Operations
+        // Reset - load an identity matrix
+        const trans_affine& reset();
+
+        // Direct transformations operations
+        const trans_affine& translate(double x, double y);
+        const trans_affine& rotate(double a);
+        const trans_affine& scale(double s);
+        const trans_affine& scale(double x, double y);
+
+        // Multiply matrix to another one
+        const trans_affine& multiply(const trans_affine& m);
+
+        // Multiply "m" to "this" and assign the result to "this"
+        const trans_affine& premultiply(const trans_affine& m);
+
+        // Multiply matrix to inverse of another one
+        const trans_affine& multiply_inv(const trans_affine& m);
+
+        // Multiply inverse of "m" to "this" and assign the result to "this"
+        const trans_affine& premultiply_inv(const trans_affine& m);
+
+        // Invert matrix. Do not try to invert degenerate matrices, 
+        // there's no check for validity. If you set scale to 0 and 
+        // then try to invert matrix, expect unpredictable result.
+        const trans_affine& invert();
+
+        // Mirroring around X
+        const trans_affine& flip_x();
+
+        // Mirroring around Y
+        const trans_affine& flip_y();
+
+        //------------------------------------------- Load/Store
+        // Store matrix to an array [6] of double
+        void store_to(double* m) const
+        {
+            *m++ = sx; *m++ = shy; *m++ = shx; *m++ = sy; *m++ = tx; *m++ = ty;
+        }
+
+        // Load matrix from an array [6] of double
+        const trans_affine& load_from(const double* m)
+        {
+            sx = *m++; shy = *m++; shx = *m++; sy = *m++; tx = *m++;  ty = *m++;
+            return *this;
+        }
+
+        //------------------------------------------- Operators
+        
+        // Multiply the matrix by another one
+        const trans_affine& operator *= (const trans_affine& m)
+        {
+            return multiply(m);
+        }
+
+        // Multiply the matrix by inverse of another one
+        const trans_affine& operator /= (const trans_affine& m)
+        {
+            return multiply_inv(m);
+        }
+
+        // Multiply the matrix by another one and return
+        // the result in a separete matrix.
+        trans_affine operator * (const trans_affine& m) const
+        {
+            return trans_affine(*this).multiply(m);
+        }
+
+        // Multiply the matrix by inverse of another one 
+        // and return the result in a separete matrix.
+        trans_affine operator / (const trans_affine& m) const
+        {
+            return trans_affine(*this).multiply_inv(m);
+        }
+
+        // Calculate and return the inverse matrix
+        trans_affine operator ~ () const
+        {
+            trans_affine ret = *this;
+            return ret.invert();
+        }
+
+        // Equal operator with default epsilon
+        bool operator == (const trans_affine& m) const
+        {
+            return is_equal(m, affine_epsilon);
+        }
+
+        // Not Equal operator with default epsilon
+        bool operator != (const trans_affine& m) const
+        {
+            return !is_equal(m, affine_epsilon);
+        }
+
+        //-------------------------------------------- Transformations
+        // Direct transformation of x and y
+        void transform(double* x, double* y) const;
+
+        // Direct transformation of x and y, 2x2 matrix only, no translation
+        void transform_2x2(double* x, double* y) const;
+
+        // Inverse transformation of x and y. It works slower than the 
+        // direct transformation. For massive operations it's better to 
+        // invert() the matrix and then use direct transformations. 
+        void inverse_transform(double* x, double* y) const;
+
+        //-------------------------------------------- Auxiliary
+        // Calculate the determinant of matrix
+        double determinant() const
+        {
+            return sx * sy - shy * shx;
+        }
+
+        // Calculate the reciprocal of the determinant
+        double determinant_reciprocal() const
+        {
+            return 1.0 / (sx * sy - shy * shx);
+        }
+
+        // Get the average scale (by X and Y). 
+        // Basically used to calculate the approximation_scale when
+        // decomposinting curves into line segments.
+        double scale() const;
+
+        // Check to see if the matrix is not degenerate
+        bool is_valid(double epsilon = affine_epsilon) const;
+
+        // Check to see if it's an identity matrix
+        bool is_identity(double epsilon = affine_epsilon) const;
+
+        // Check to see if two matrices are equal
+        bool is_equal(const trans_affine& m, double epsilon = affine_epsilon) const;
+
+        // Determine the major parameters. Use with caution considering 
+        // possible degenerate cases.
+        double rotation() const;
+        void   translation(double* dx, double* dy) const;
+        void   scaling(double* x, double* y) const;
+        void   scaling_abs(double* x, double* y) const;
+    };
+
+    //------------------------------------------------------------------------
+    inline void trans_affine::transform(double* x, double* y) const
+    {
+        double tmp = *x;
+        *x = tmp * sx  + *y * shx + tx;
+        *y = tmp * shy + *y * sy  + ty;
+    }
+
+    //------------------------------------------------------------------------
+    inline void trans_affine::transform_2x2(double* x, double* y) const
+    {
+        double tmp = *x;
+        *x = tmp * sx  + *y * shx;
+        *y = tmp * shy + *y * sy;
+    }
+
+    //------------------------------------------------------------------------
+    inline void trans_affine::inverse_transform(double* x, double* y) const
+    {
+        double d = determinant_reciprocal();
+        double a = (*x - tx) * d;
+        double b = (*y - ty) * d;
+        *x = a * sy - b * shx;
+        *y = b * sx - a * shy;
+    }
+
+    //------------------------------------------------------------------------
+    inline double trans_affine::scale() const
+    {
+        double x = 0.707106781 * sx  + 0.707106781 * shx;
+        double y = 0.707106781 * shy + 0.707106781 * sy;
+        return sqrt(x*x + y*y);
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::translate(double x, double y) 
+    { 
+        tx += x;
+        ty += y; 
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::rotate(double a) 
+    {
+        double ca = cos(a); 
+        double sa = sin(a);
+        double t0 = sx  * ca - shy * sa;
+        double t2 = shx * ca - sy * sa;
+        double t4 = tx  * ca - ty * sa;
+        shy = sx  * sa + shy * ca;
+        sy  = shx * sa + sy * ca; 
+        ty  = tx  * sa + ty * ca;
+        sx  = t0;
+        shx = t2;
+        tx  = t4;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::scale(double x, double y) 
+    {
+        double mm0 = x; // Possible hint for the optimizer
+        double mm3 = y; 
+        sx  *= mm0;
+        shx *= mm0;
+        tx  *= mm0;
+        shy *= mm3;
+        sy  *= mm3;
+        ty  *= mm3;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::scale(double s) 
+    {
+        double m = s; // Possible hint for the optimizer
+        sx  *= m;
+        shx *= m;
+        tx  *= m;
+        shy *= m;
+        sy  *= m;
+        ty  *= m;
+        return *this;
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::premultiply(const trans_affine& m)
+    {
+        trans_affine t = m;
+        return *this = t.multiply(*this);
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::multiply_inv(const trans_affine& m)
+    {
+        trans_affine t = m;
+        t.invert();
+        return multiply(t);
+    }
+
+    //------------------------------------------------------------------------
+    inline const trans_affine& trans_affine::premultiply_inv(const trans_affine& m)
+    {
+        trans_affine t = m;
+        t.invert();
+        return *this = t.multiply(*this);
+    }
+
+    //------------------------------------------------------------------------
+    inline void trans_affine::scaling_abs(double* x, double* y) const
+    {
+        // Used to calculate scaling coefficients in image resampling. 
+        // When there is considerable shear this method gives us much
+        // better estimation than just sx, sy.
+        *x = sqrt(sx  * sx  + shx * shx);
+        *y = sqrt(shy * shy + sy  * sy);
+    }
+
+    //====================================================trans_affine_rotation
+    // Rotation matrix. sin() and cos() are calculated twice for the same angle.
+    // There's no harm because the performance of sin()/cos() is very good on all
+    // modern processors. Besides, this operation is not going to be invoked too 
+    // often.
+    class trans_affine_rotation : public trans_affine
+    {
+    public:
+        trans_affine_rotation(double a) : 
+          trans_affine(cos(a), sin(a), -sin(a), cos(a), 0.0, 0.0)
+        {}
+    };
+
+    //====================================================trans_affine_scaling
+    // Scaling matrix. x, y - scale coefficients by X and Y respectively
+    class trans_affine_scaling : public trans_affine
+    {
+    public:
+        trans_affine_scaling(double x, double y) : 
+          trans_affine(x, 0.0, 0.0, y, 0.0, 0.0)
+        {}
+
+        trans_affine_scaling(double s) : 
+          trans_affine(s, 0.0, 0.0, s, 0.0, 0.0)
+        {}
+    };
+
+    //================================================trans_affine_translation
+    // Translation matrix
+    class trans_affine_translation : public trans_affine
+    {
+    public:
+        trans_affine_translation(double x, double y) : 
+          trans_affine(1.0, 0.0, 0.0, 1.0, x, y)
+        {}
+    };
+
+    //====================================================trans_affine_skewing
+    // Sckewing (shear) matrix
+    class trans_affine_skewing : public trans_affine
+    {
+    public:
+        trans_affine_skewing(double x, double y) : 
+          trans_affine(1.0, tan(y), tan(x), 1.0, 0.0, 0.0)
+        {}
+    };
+
+
+    //===============================================trans_affine_line_segment
+    // Rotate, Scale and Translate, associating 0...dist with line segment 
+    // x1,y1,x2,y2
+    class trans_affine_line_segment : public trans_affine
+    {
+    public:
+        trans_affine_line_segment(double x1, double y1, double x2, double y2, 
+                                  double dist)
+        {
+            double dx = x2 - x1;
+            double dy = y2 - y1;
+            if(dist > 0.0)
+            {
+                multiply(trans_affine_scaling(sqrt(dx * dx + dy * dy) / dist));
+            }
+            multiply(trans_affine_rotation(atan2(dy, dx)));
+            multiply(trans_affine_translation(x1, y1));
+        }
+    };
+
+
+    //============================================trans_affine_reflection_unit
+    // Reflection matrix. Reflect coordinates across the line through 
+    // the origin containing the unit vector (ux, uy).
+    // Contributed by John Horigan
+    class trans_affine_reflection_unit : public trans_affine
+    {
+    public:
+        trans_affine_reflection_unit(double ux, double uy) :
+          trans_affine(2.0 * ux * ux - 1.0, 
+                       2.0 * ux * uy, 
+                       2.0 * ux * uy, 
+                       2.0 * uy * uy - 1.0, 
+                       0.0, 0.0)
+        {}
+    };
+
+
+    //=================================================trans_affine_reflection
+    // Reflection matrix. Reflect coordinates across the line through 
+    // the origin at the angle a or containing the non-unit vector (x, y).
+    // Contributed by John Horigan
+    class trans_affine_reflection : public trans_affine_reflection_unit
+    {
+    public:
+        trans_affine_reflection(double a) :
+          trans_affine_reflection_unit(cos(a), sin(a))
+        {}
+
+
+        trans_affine_reflection(double x, double y) :
+          trans_affine_reflection_unit(x / sqrt(x * x + y * y), y / sqrt(x * x + y * y))
+        {}
+    };
+
+}
+
+
+#endif
+

src/agg/copying

@@ -0,0 +1,65 @@
+The Anti-Grain Geometry Project
+A high quality rendering engine for C++
+http://antigrain.com
+
+Anti-Grain Geometry has dual licensing model. The Modified BSD 
+License was first added in version v2.4 just for convenience.
+It is a simple, permissive non-copyleft free software license, 
+compatible with the GNU GPL. It's well proven and recognizable.
+See http://www.fsf.org/licensing/licenses/index_html#ModifiedBSD
+for details.
+
+Note that the Modified BSD license DOES NOT restrict your rights 
+if you choose the Anti-Grain Geometry Public License.
+
+
+
+
+Anti-Grain Geometry Public License
+====================================================
+
+Anti-Grain Geometry - Version 2.4 
+Copyright (C) 2002-2005 Maxim Shemanarev (McSeem) 
+
+Permission to copy, use, modify, sell and distribute this software 
+is granted provided this copyright notice appears in all copies. 
+This software is provided "as is" without express or implied
+warranty, and with no claim as to its suitability for any purpose.
+
+
+
+
+
+Modified BSD License
+====================================================
+Anti-Grain Geometry - Version 2.4 
+Copyright (C) 2002-2005 Maxim Shemanarev (McSeem) 
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions 
+are met:
+
+  1. Redistributions of source code must retain the above copyright 
+     notice, this list of conditions and the following disclaimer. 
+
+  2. Redistributions 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. 
+
+  3. The name of the author may not be used to endorse or promote 
+     products derived from this software without specific prior 
+     written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+

src/boost/CMakeLists.txt

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 2.8.12)
+project(nowide)
+
+add_library(nowide STATIC
+    nowide/args.hpp
+    nowide/cenv.hpp
+    nowide/config.hpp
+    nowide/convert.hpp
+    nowide/cstdio.hpp
+    nowide/cstdlib.hpp
+    nowide/filebuf.hpp
+    nowide/fstream.hpp
+    nowide/integration/filesystem.hpp
+    nowide/iostream.cpp
+    nowide/iostream.hpp
+    nowide/stackstring.hpp
+    nowide/system.hpp
+    nowide/utf8_codecvt.hpp
+    nowide/windows.hpp
+)
+
+target_link_libraries(nowide PUBLIC boost_headeronly)
+
+

src/boost/nowide/args.hpp

@@ -0,0 +1,167 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_ARGS_HPP_INCLUDED
+#define BOOST_NOWIDE_ARGS_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/nowide/stackstring.hpp>
+#include <vector>
+#ifdef BOOST_WINDOWS
+#include <boost/nowide/windows.hpp>
+#endif
+
+namespace boost {
+namespace nowide {
+    #if !defined(BOOST_WINDOWS) && !defined(BOOST_NOWIDE_DOXYGEN)
+    class args {
+    public:
+        args(int &,char **&) {}
+        args(int &,char **&,char **&){}
+        ~args() {}
+    };
+
+    #else
+
+    ///
+    /// \brief args is a class that fixes standard main() function arguments and changes them to UTF-8 under 
+    /// Microsoft Windows.
+    ///
+    /// The class uses \c GetCommandLineW(), \c CommandLineToArgvW() and \c GetEnvironmentStringsW()
+    /// in order to obtain the information. It does not relates to actual values of argc,argv and env
+    /// under Windows.
+    ///
+    /// It restores the original values in its destructor
+    ///
+    /// \note the class owns the memory of the newly allocated strings
+    ///
+    class args {
+    public:
+        
+        ///
+        /// Fix command line agruments 
+        ///
+        args(int &argc,char **&argv) :
+            old_argc_(argc),
+            old_argv_(argv),
+            old_env_(0),
+            old_argc_ptr_(&argc),
+            old_argv_ptr_(&argv),
+            old_env_ptr_(0)
+        {
+            fix_args(argc,argv);
+        }
+        ///
+        /// Fix command line agruments and environment
+        ///
+        args(int &argc,char **&argv,char **&en) :
+            old_argc_(argc),
+            old_argv_(argv),
+            old_env_(en),
+            old_argc_ptr_(&argc),
+            old_argv_ptr_(&argv),
+            old_env_ptr_(&en)
+        {
+            fix_args(argc,argv);
+            fix_env(en);
+        }
+        ///
+        /// Restore original argc,argv,env values, if changed
+        ///
+        ~args()
+        {
+            if(old_argc_ptr_)
+                *old_argc_ptr_ = old_argc_;
+            if(old_argv_ptr_)
+                *old_argv_ptr_ = old_argv_;
+            if(old_env_ptr_) 
+                *old_env_ptr_ = old_env_;
+        }
+    private:    
+        void fix_args(int &argc,char **&argv)
+        {
+                int wargc;
+                wchar_t **wargv = CommandLineToArgvW(GetCommandLineW(),&wargc);
+            if(!wargv) {
+                argc = 0;
+                static char *dummy = 0;
+                argv = &dummy;
+                return;
+            }
+            try{ 
+                args_.resize(wargc+1,0);
+                arg_values_.resize(wargc);
+                for(int i=0;i<wargc;i++) {
+                    if(!arg_values_[i].convert(wargv[i])) {
+                        wargc = i;
+                        break;
+                    }
+                    args_[i] = arg_values_[i].c_str();
+                }
+                argc = wargc;
+                argv = &args_[0];
+            }
+            catch(...) {
+                LocalFree(wargv);
+                throw;
+            }
+            LocalFree(wargv);
+        }
+        void fix_env(char **&en)
+        {
+            static char *dummy = 0;
+            en = &dummy;
+            wchar_t *wstrings = GetEnvironmentStringsW();
+            if(!wstrings)
+                return;
+            try {
+                wchar_t *wstrings_end = 0;
+                int count = 0;
+                for(wstrings_end = wstrings;*wstrings_end;wstrings_end+=wcslen(wstrings_end)+1)
+                        count++;
+                if(env_.convert(wstrings,wstrings_end)) {
+                    envp_.resize(count+1,0);
+                    char *p=env_.c_str();
+                    int pos = 0;
+                    for(int i=0;i<count;i++) {
+                        if(*p!='=')
+                            envp_[pos++] = p;
+                        p+=strlen(p)+1;
+                    }
+                    en = &envp_[0];
+                }
+            }
+            catch(...) {
+                FreeEnvironmentStringsW(wstrings);
+                throw;
+            }
+            FreeEnvironmentStringsW(wstrings);
+
+        }
+
+        std::vector<char *> args_;
+        std::vector<short_stackstring> arg_values_;
+        stackstring env_;
+        std::vector<char *> envp_;
+
+        int old_argc_;
+        char **old_argv_;
+        char **old_env_;
+
+        int  *old_argc_ptr_;
+        char ***old_argv_ptr_;
+        char ***old_env_ptr_;
+    };
+
+    #endif
+
+} // nowide
+} // namespace boost
+#endif
+
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/cenv.hpp

@@ -0,0 +1,124 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_CENV_H_INCLUDED
+#define BOOST_NOWIDE_CENV_H_INCLUDED
+
+#include <string>
+#include <stdexcept>
+#include <stdlib.h>
+#include <boost/config.hpp>
+#include <boost/nowide/stackstring.hpp>
+#include <vector>
+
+#ifdef BOOST_WINDOWS
+#include <boost/nowide/windows.hpp>
+#endif
+
+namespace boost {
+namespace nowide {
+    #if !defined(BOOST_WINDOWS) && !defined(BOOST_NOWIDE_DOXYGEN)
+    using ::getenv;
+    using ::setenv;
+    using ::unsetenv;
+    using ::putenv;
+    #else
+    ///
+    /// \brief UTF-8 aware getenv. Returns 0 if the variable is not set.
+    ///
+    /// This function is not thread safe or reenterable as defined by the standard library
+    ///
+    inline char *getenv(char const *key)
+    {
+        static stackstring value;
+        
+        wshort_stackstring name;
+        if(!name.convert(key))
+            return 0;
+
+        static const size_t buf_size = 64;
+        wchar_t buf[buf_size];
+        std::vector<wchar_t> tmp;
+        wchar_t *ptr = buf;
+        size_t n = GetEnvironmentVariableW(name.c_str(),buf,buf_size);
+        if(n == 0 && GetLastError() == 203) // ERROR_ENVVAR_NOT_FOUND
+            return 0;
+        if(n >= buf_size) {
+            tmp.resize(n+1,L'\0');
+            n = GetEnvironmentVariableW(name.c_str(),&tmp[0],static_cast<unsigned>(tmp.size() - 1));
+            // The size may have changed
+            if(n >= tmp.size() - 1)
+                return 0;
+            ptr = &tmp[0];
+        }
+        if(!value.convert(ptr))
+            return 0;
+        return value.c_str();
+    }
+    ///
+    /// \brief  UTF-8 aware setenv, \a key - the variable name, \a value is a new UTF-8 value,
+    /// 
+    /// if override is not 0, that the old value is always overridded, otherwise,
+    /// if the variable exists it remains unchanged
+    ///
+    inline int setenv(char const *key,char const *value,int override)
+    {
+        wshort_stackstring name;
+        if(!name.convert(key))
+            return -1;
+        if(!override) {
+            wchar_t unused[2];
+            if(!(GetEnvironmentVariableW(name.c_str(),unused,2)==0 && GetLastError() == 203)) // ERROR_ENVVAR_NOT_FOUND
+                return 0;
+        }
+        wstackstring wval;
+        if(!wval.convert(value))
+            return -1;
+        if(SetEnvironmentVariableW(name.c_str(),wval.c_str()))
+            return 0;
+        return -1;
+    }
+    ///
+    /// \brief Remove enviroment variable \a key
+    ///
+    inline int unsetenv(char const *key)
+    {
+        wshort_stackstring name;
+        if(!name.convert(key))
+            return -1;
+        if(SetEnvironmentVariableW(name.c_str(),0))
+            return 0;
+        return -1;
+    }
+    ///
+    /// \brief UTF-8 aware putenv implementation, expects string in format KEY=VALUE
+    ///
+    inline int putenv(char *string)
+    {
+        char const *key = string;
+        char const *key_end = string;
+        while(*key_end != '=' && *key_end != 0)
+            ++ key_end;
+        if(*key_end == 0)
+            return -1;
+        wshort_stackstring wkey;
+        if(!wkey.convert(key,key_end))
+            return -1;
+        wstackstring wvalue;
+        if(!wvalue.convert(key_end+1))
+            return -1;
+        if(SetEnvironmentVariableW(wkey.c_str(),wvalue.c_str()))
+            return 0;
+        return -1;
+    }
+    #endif
+} // nowide
+} // namespace boost
+
+#endif
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/config.hpp

@@ -0,0 +1,54 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_CONFIG_HPP_INCLUDED
+#define BOOST_NOWIDE_CONFIG_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+#ifndef BOOST_SYMBOL_VISIBLE
+# define BOOST_SYMBOL_VISIBLE
+#endif
+
+#ifdef BOOST_HAS_DECLSPEC 
+#   if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_NOWIDE_DYN_LINK)
+#       ifdef BOOST_NOWIDE_SOURCE
+#           define BOOST_NOWIDE_DECL BOOST_SYMBOL_EXPORT
+#       else
+#           define BOOST_NOWIDE_DECL BOOST_SYMBOL_IMPORT
+#       endif  // BOOST_NOWIDE_SOURCE
+#   endif  // DYN_LINK
+#endif  // BOOST_HAS_DECLSPEC
+
+#ifndef BOOST_NOWIDE_DECL
+#   define BOOST_NOWIDE_DECL
+#endif
+
+//
+// Automatically link to the correct build variant where possible. 
+// 
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_NOWIDE_NO_LIB) && !defined(BOOST_NOWIDE_SOURCE)
+//
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_nowide
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_NOWIDE_DYN_LINK)
+#  define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
+
+#endif // boost/nowide/config.hpp
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/convert.hpp

@@ -0,0 +1,154 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_CONVERT_H_INCLUDED
+#define BOOST_NOWIDE_CONVERT_H_INCLUDED
+
+#include <string>
+#include <boost/locale/encoding_utf.hpp>
+
+namespace boost {
+namespace nowide {
+    ///
+    /// \brief Template function that converts a buffer of UTF sequences in range [source_begin,source_end)
+    /// to the output \a buffer of size \a buffer_size.
+    ///
+    /// In case of success a NULL terminated string is returned (buffer), otherwise 0 is returned.
+    ///
+    /// If there is not enough room in the buffer or the source sequence contains invalid UTF,
+    /// 0 is returned, and the contents of the buffer are undefined.
+    ///
+    template<typename CharOut,typename CharIn>
+    CharOut *basic_convert(CharOut *buffer,size_t buffer_size,CharIn const *source_begin,CharIn const *source_end)
+    {
+        CharOut *rv = buffer;
+        if(buffer_size == 0)
+            return 0;
+        buffer_size --;
+        while(source_begin!=source_end) {
+            using namespace boost::locale::utf;
+            code_point c = utf_traits<CharIn>::template decode<CharIn const *>(source_begin,source_end);
+            if(c==illegal || c==incomplete) {
+                rv = 0;
+                break;
+            }
+            size_t width = utf_traits<CharOut>::width(c);
+            if(buffer_size < width) {
+                rv=0;
+                break;
+            }
+            buffer = utf_traits<CharOut>::template encode<CharOut *>(c,buffer);
+            buffer_size -= width;
+        }
+        *buffer++ = 0;
+        return rv;
+    }
+
+    /// \cond INTERNAL
+    namespace details {
+        //
+        // wcslen defined only in C99... So we will not use it
+        //
+        template<typename Char>
+        Char const *basic_strend(Char const *s)
+        {
+            while(*s)
+                s++;
+            return s;
+        }
+    }
+    /// \endcond
+
+    ///
+    /// Convert NULL terminated UTF source string to NULL terminated \a output string of size at
+    /// most output_size (including NULL)
+    /// 
+    /// In case of success output is returned, if the input sequence is illegal,
+    /// or there is not enough room NULL is returned 
+    ///
+    inline char *narrow(char *output,size_t output_size,wchar_t const *source)
+    {
+        return basic_convert(output,output_size,source,details::basic_strend(source));
+    }
+    ///
+    /// Convert UTF text in range [begin,end) to NULL terminated \a output string of size at
+    /// most output_size (including NULL)
+    /// 
+    /// In case of success output is returned, if the input sequence is illegal,
+    /// or there is not enough room NULL is returned 
+    ///
+    inline char *narrow(char *output,size_t output_size,wchar_t const *begin,wchar_t const *end)
+    {
+        return basic_convert(output,output_size,begin,end);
+    }
+    ///
+    /// Convert NULL terminated UTF source string to NULL terminated \a output string of size at
+    /// most output_size (including NULL)
+    /// 
+    /// In case of success output is returned, if the input sequence is illegal,
+    /// or there is not enough room NULL is returned 
+    ///
+    inline wchar_t *widen(wchar_t *output,size_t output_size,char const *source)
+    {
+        return basic_convert(output,output_size,source,details::basic_strend(source));
+    }
+    ///
+    /// Convert UTF text in range [begin,end) to NULL terminated \a output string of size at
+    /// most output_size (including NULL)
+    /// 
+    /// In case of success output is returned, if the input sequence is illegal,
+    /// or there is not enough room NULL is returned 
+    ///
+    inline wchar_t *widen(wchar_t *output,size_t output_size,char const *begin,char const *end)
+    {
+        return basic_convert(output,output_size,begin,end);
+    }
+
+
+    ///
+    /// Convert between Wide - UTF-16/32 string and UTF-8 string.
+    ///
+    /// boost::locale::conv::conversion_error is thrown in a case of a error
+    ///
+    inline std::string narrow(wchar_t const *s)
+    {
+        return boost::locale::conv::utf_to_utf<char>(s);
+    }
+    ///
+    /// Convert between UTF-8 and UTF-16 string, implemented only on Windows platform
+    ///
+    /// boost::locale::conv::conversion_error is thrown in a case of a error
+    ///
+    inline std::wstring widen(char const *s)
+    {
+        return boost::locale::conv::utf_to_utf<wchar_t>(s);
+    }
+    ///
+    /// Convert between Wide - UTF-16/32 string and UTF-8 string
+    ///
+    /// boost::locale::conv::conversion_error is thrown in a case of a error
+    ///
+    inline std::string narrow(std::wstring const &s) 
+    {
+        return boost::locale::conv::utf_to_utf<char>(s);
+    }
+    ///
+    /// Convert between UTF-8 and UTF-16 string, implemented only on Windows platform
+    ///
+    /// boost::locale::conv::conversion_error is thrown in a case of a error
+    ///
+    inline std::wstring widen(std::string const &s) 
+    {
+        return boost::locale::conv::utf_to_utf<wchar_t>(s);
+    }
+
+} // nowide
+} // namespace boost
+
+#endif
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/cstdio.hpp

@@ -0,0 +1,101 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_CSTDIO_H_INCLUDED
+#define BOOST_NOWIDE_CSTDIO_H_INCLUDED
+
+#include <cstdio>
+#include <stdio.h>
+#include <boost/config.hpp>
+#include <boost/nowide/convert.hpp>
+#include <boost/nowide/stackstring.hpp>
+#include <errno.h>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4996)
+#endif
+
+
+namespace boost {
+namespace nowide {
+#if !defined(BOOST_WINDOWS) && !defined(BOOST_NOWIDE_DOXYGEN)
+    using std::fopen;
+    using std::freopen;
+    using std::remove;
+    using std::rename;
+#else
+
+///
+/// \brief Same as freopen but file_name and mode are UTF-8 strings
+///
+/// If invalid UTF-8 given, NULL is returned and errno is set to EINVAL
+///
+inline FILE *freopen(char const *file_name,char const *mode,FILE *stream)
+{
+    wstackstring wname;
+    wshort_stackstring wmode;
+    if(!wname.convert(file_name) || !wmode.convert(mode)) {
+        errno = EINVAL;
+        return 0;
+    }
+    return _wfreopen(wname.c_str(),wmode.c_str(),stream);
+}
+///
+/// \brief Same as fopen but file_name and mode are UTF-8 strings
+///
+/// If invalid UTF-8 given, NULL is returned and errno is set to EINVAL
+///
+inline FILE *fopen(char const *file_name,char const *mode)
+{
+    wstackstring wname;
+    wshort_stackstring wmode;
+    if(!wname.convert(file_name) || !wmode.convert(mode)) {
+        errno = EINVAL;
+        return 0;
+    }
+    return _wfopen(wname.c_str(),wmode.c_str());
+}
+///
+/// \brief Same as rename but old_name and new_name are UTF-8 strings
+///
+/// If invalid UTF-8 given, -1 is returned and errno is set to EINVAL
+///
+inline int rename(char const *old_name,char const *new_name)
+{
+    wstackstring wold,wnew;
+    if(!wold.convert(old_name) || !wnew.convert(new_name)) {
+        errno = EINVAL;
+        return -1;
+    }
+    return _wrename(wold.c_str(),wnew.c_str());
+}
+///
+/// \brief Same as rename but name is UTF-8 string
+///
+/// If invalid UTF-8 given, -1 is returned and errno is set to EINVAL
+///
+inline int remove(char const *name)
+{
+    wstackstring wname;
+    if(!wname.convert(name)) {
+        errno = EINVAL;
+        return -1;
+    }
+    return _wremove(wname.c_str());
+}
+#endif
+} // nowide
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/cstdlib.hpp

@@ -0,0 +1,16 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_CSTDLIB_HPP_INCLUDED
+#define BOOST_NOWIDE_CSTDLIB_HPP_INCLUDED
+
+#include <boost/nowide/cenv.hpp>
+#include <boost/nowide/system.hpp>
+
+#endif
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/filebuf.hpp

@@ -0,0 +1,415 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_FILEBUF_HPP
+#define BOOST_NOWIDE_FILEBUF_HPP
+
+#include <iosfwd>
+#include <boost/config.hpp>
+#include <boost/nowide/stackstring.hpp>
+#include <fstream>
+#include <streambuf>
+#include <stdio.h>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4996 4244 4800)
+#endif
+
+
+namespace boost {
+namespace nowide {
+#if !defined(BOOST_WINDOWS) && !defined(BOOST_NOWIDE_FSTREAM_TESTS) && !defined(BOOST_NOWIDE_DOXYGEN)
+    using std::basic_filebuf;
+    using std::filebuf;
+#else // Windows
+    
+    ///
+    /// \brief This forward declaration defined the basic_filebuf type.
+    ///
+    /// it is implemented and specialized for CharType = char, it behaves
+    /// implements std::filebuf over standard C I/O
+    ///
+    template<typename CharType,typename Traits = std::char_traits<CharType> >
+    class basic_filebuf;
+    
+    ///
+    /// \brief This is implementation of std::filebuf
+    ///
+    /// it is implemented and specialized for CharType = char, it behaves
+    /// implements std::filebuf over standard C I/O
+    ///
+    template<>
+    class basic_filebuf<char> : public std::basic_streambuf<char> {
+    public:
+        ///
+        /// Creates new filebuf
+        ///
+        basic_filebuf() : 
+            buffer_size_(4),
+            buffer_(0),
+            file_(0),
+            own_(true),
+            mode_(std::ios::in | std::ios::out)
+        {
+            setg(0,0,0);
+            setp(0,0);
+        }
+        
+        virtual ~basic_filebuf()
+        {
+            if(file_) {
+                ::fclose(file_);
+                file_ = 0;
+            }
+            if(own_ && buffer_)
+                delete [] buffer_;
+        }
+        
+        ///
+        /// Same as std::filebuf::open but s is UTF-8 string
+        ///
+        basic_filebuf *open(std::string const &s,std::ios_base::openmode mode)
+        {
+            return open(s.c_str(),mode);
+        }
+        ///
+        /// Same as std::filebuf::open but s is UTF-8 string
+        ///
+        basic_filebuf *open(char const *s,std::ios_base::openmode mode)
+        {
+            if(file_) {
+                sync();
+                ::fclose(file_);
+                file_ = 0;
+            }
+            bool ate = bool(mode & std::ios_base::ate);
+            if(ate)
+                mode = mode ^ std::ios_base::ate;
+            wchar_t const *smode = get_mode(mode);
+            if(!smode)
+                return 0;
+            wstackstring name;
+            if(!name.convert(s)) 
+                return 0;
+            #ifdef BOOST_NOWIDE_FSTREAM_TESTS
+            FILE *f = ::fopen(s,boost::nowide::convert(smode).c_str());
+            #else
+            FILE *f = ::_wfopen(name.c_str(),smode);
+            #endif
+            if(!f)
+                return 0;
+            if(ate && fseek(f,0,SEEK_END)!=0) {
+                fclose(f);
+                return 0;
+            }
+            file_ = f;
+            return this;
+        }
+        ///
+        /// Same as std::filebuf::close()
+        ///
+        basic_filebuf *close()
+        {
+            bool res = sync() == 0;
+            if(file_) {
+                if(::fclose(file_)!=0)
+                    res = false;
+                file_ = 0;
+            }
+            return res ? this : 0;
+        }
+        ///
+        /// Same as std::filebuf::is_open()
+        ///
+        bool is_open() const
+        {
+            return file_ != 0;
+        }
+
+    private:
+        void make_buffer()
+        {
+            if(buffer_)
+                return;
+            if(buffer_size_ > 0) {
+                buffer_ = new char [buffer_size_];
+                own_ = true;
+            }
+        }
+    protected:
+        
+        virtual std::streambuf *setbuf(char *s,std::streamsize n)
+        {
+            if(!buffer_ && n>=0) {
+                buffer_ = s;
+                buffer_size_ = n;
+                own_ = false;
+            }
+            return this;
+        }
+        
+#ifdef BOOST_NOWIDE_DEBUG_FILEBUF
+
+        void print_buf(char *b,char *p,char *e)
+        {
+            std::cerr << "-- Is Null: " << (b==0) << std::endl;; 
+            if(b==0)
+                return;
+            if(e != 0)
+                std::cerr << "-- Total: " << e - b <<" offset from start " << p - b << std::endl;
+            else
+                std::cerr << "-- Total: " << p - b << std::endl;
+                
+            std::cerr << "-- [";
+            for(char *ptr = b;ptr<p;ptr++)
+                std::cerr << *ptr;
+            if(e!=0) {
+                std::cerr << "|";
+                for(char *ptr = p;ptr<e;ptr++)
+                    std::cerr << *ptr;
+            }
+            std::cerr << "]" << std::endl;
+           
+        }
+        
+        void print_state()
+        {
+            std::cerr << "- Output:" << std::endl;
+            print_buf(pbase(),pptr(),0);
+            std::cerr << "- Input:" << std::endl;
+            print_buf(eback(),gptr(),egptr());
+            std::cerr << "- fpos: " << (file_ ? ftell(file_) : -1L) << std::endl;
+        }
+        
+        struct print_guard
+        {
+            print_guard(basic_filebuf *p,char const *func)
+            {
+                self = p;
+                f=func;
+                std::cerr << "In: " << f << std::endl;
+                self->print_state();
+            }
+            ~print_guard()
+            {
+                std::cerr << "Out: " << f << std::endl;
+                self->print_state();
+            }
+            basic_filebuf *self;
+            char const *f;
+        };
+#else
+#endif        
+        
+        int overflow(int c)
+        {
+#ifdef BOOST_NOWIDE_DEBUG_FILEBUF
+            print_guard g(this,__FUNCTION__);
+#endif            
+            if(!file_)
+                return EOF;
+            
+            if(fixg() < 0)
+                return EOF;
+
+            size_t n = pptr() - pbase();
+            if(n > 0) {
+                if(::fwrite(pbase(),1,n,file_) < n)
+                    return -1;
+                fflush(file_);
+            }
+
+            if(buffer_size_ > 0) {
+                make_buffer();
+                setp(buffer_,buffer_+buffer_size_);
+                if(c!=EOF)
+                    sputc(c);
+            }
+            else if(c!=EOF) {
+                if(::fputc(c,file_)==EOF)
+                    return EOF;
+                fflush(file_);
+            }
+            return 0;
+        }
+        
+        
+        int sync()
+        {
+            return overflow(EOF);
+        }
+
+        int underflow()
+        {
+#ifdef BOOST_NOWIDE_DEBUG_FILEBUF
+            print_guard g(this,__FUNCTION__);
+#endif            
+            if(!file_)
+                return EOF;
+            if(fixp() < 0)
+                return EOF;
+            if(buffer_size_ == 0) {
+                int c = ::fgetc(file_);
+                if(c==EOF) {
+                    return EOF;
+                }
+                last_char_ = c;
+                setg(&last_char_,&last_char_,&last_char_ + 1);
+                return c;
+            }
+            make_buffer();
+            size_t n = ::fread(buffer_,1,buffer_size_,file_);
+            setg(buffer_,buffer_,buffer_+n);
+            if(n == 0)
+                return EOF;
+            return std::char_traits<char>::to_int_type(*gptr());
+        }
+
+        int pbackfail(int)
+        {
+            return pubseekoff(-1,std::ios::cur);
+        }
+
+        std::streampos seekoff(std::streamoff off,
+                            std::ios_base::seekdir seekdir,
+                            std::ios_base::openmode /*m*/)
+        {
+#ifdef BOOST_NOWIDE_DEBUG_FILEBUF
+            print_guard g(this,__FUNCTION__);
+#endif            
+            if(!file_)
+                return EOF;
+            if(fixp() < 0 || fixg() < 0)
+                return EOF;
+            if(seekdir == std::ios_base::cur) {
+                if( ::fseek(file_,off,SEEK_CUR) < 0)
+                    return EOF;
+            }
+            else if(seekdir == std::ios_base::beg) {
+                if( ::fseek(file_,off,SEEK_SET) < 0)
+                    return EOF;
+            }
+            else if(seekdir == std::ios_base::end) {
+                if( ::fseek(file_,off,SEEK_END) < 0)
+                    return EOF;
+            }
+            else
+                return -1;
+            return ftell(file_);
+        }
+        std::streampos seekpos(std::streampos off,std::ios_base::openmode m)
+        {
+            return seekoff(std::streamoff(off),std::ios_base::beg,m);
+        }
+    private:
+        int fixg()
+        {
+            if(gptr()!=egptr()) {
+                std::streamsize off = gptr() - egptr();
+                setg(0,0,0);
+                if(fseek(file_,off,SEEK_CUR) != 0)
+                    return -1;
+            }
+            setg(0,0,0);
+            return 0;
+        }
+        
+        int fixp()
+        {
+            if(pptr()!=0) {
+                int r = sync();
+                setp(0,0);
+                return r;
+            }
+            return 0;
+        }
+
+        void reset(FILE *f = 0)
+        {
+            sync();
+            if(file_) {
+                fclose(file_);
+                file_ = 0;
+            }
+            file_ = f;
+        }
+        
+        
+        static wchar_t const *get_mode(std::ios_base::openmode mode)
+        {
+            //
+            // done according to n2914 table 106 27.9.1.4
+            //
+
+            // note can't use switch case as overload operator can't be used
+            // in constant expression
+            if(mode == (std::ios_base::out))
+                return L"w";
+            if(mode == (std::ios_base::out | std::ios_base::app))
+                return L"a";
+            if(mode == (std::ios_base::app))
+                return L"a";
+            if(mode == (std::ios_base::out | std::ios_base::trunc))
+                return L"w";
+            if(mode == (std::ios_base::in))
+                return L"r";
+            if(mode == (std::ios_base::in | std::ios_base::out))
+                return L"r+";
+            if(mode == (std::ios_base::in | std::ios_base::out | std::ios_base::trunc))
+                return L"w+";
+            if(mode == (std::ios_base::in | std::ios_base::out | std::ios_base::app))
+                return L"a+";
+            if(mode == (std::ios_base::in | std::ios_base::app))
+                return L"a+";
+            if(mode == (std::ios_base::binary | std::ios_base::out))
+                return L"wb";
+            if(mode == (std::ios_base::binary | std::ios_base::out | std::ios_base::app))
+                return L"ab";
+            if(mode == (std::ios_base::binary | std::ios_base::app))
+                return L"ab";
+            if(mode == (std::ios_base::binary | std::ios_base::out | std::ios_base::trunc))
+                return L"wb";
+            if(mode == (std::ios_base::binary | std::ios_base::in))
+                return L"rb";
+            if(mode == (std::ios_base::binary | std::ios_base::in | std::ios_base::out))
+                return L"r+b";
+            if(mode == (std::ios_base::binary | std::ios_base::in | std::ios_base::out | std::ios_base::trunc))
+                return L"w+b";
+            if(mode == (std::ios_base::binary | std::ios_base::in | std::ios_base::out | std::ios_base::app))
+                return L"a+b";
+            if(mode == (std::ios_base::binary | std::ios_base::in | std::ios_base::app))
+                return L"a+b";
+            return 0;    
+        }
+        
+        size_t buffer_size_;
+        char *buffer_;
+        FILE *file_;
+        bool own_;
+        char last_char_;
+        std::ios::openmode mode_;
+    };
+    
+    ///
+    /// \brief Convinience typedef
+    ///
+    typedef basic_filebuf<char> filebuf;
+    
+    #endif // windows
+    
+} // nowide
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+
+#endif
+
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/fstream.hpp

@@ -0,0 +1,283 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_FSTREAM_INCLUDED_HPP
+#define BOOST_NOWIDE_FSTREAM_INCLUDED_HPP
+
+//#include <iosfwd>
+#include <boost/config.hpp>
+#include <boost/nowide/convert.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <fstream>
+#include <memory>
+#include <boost/nowide/filebuf.hpp>
+
+namespace boost {
+///
+/// \brief This namespace includes implementation of the standard library functios
+/// such that they accept UTF-8 strings on Windows. On other platforms it is just an alias
+/// of std namespace (i.e. not on Windows)
+///
+namespace nowide {
+#if !defined(BOOST_WINDOWS)  && !defined(BOOST_NOWIDE_FSTREAM_TESTS) && !defined(BOOST_NOWIDE_DOXYGEN)
+
+    using std::basic_ifstream;
+    using std::basic_ofstream;
+    using std::basic_fstream;
+    using std::ifstream;
+    using std::ofstream;
+    using std::fstream;
+
+#else
+    ///
+    /// \brief Same as std::basic_ifstream<char> but accepts UTF-8 strings under Windows
+    ///
+    template<typename CharType,typename Traits = std::char_traits<CharType> >
+    class basic_ifstream : public std::basic_istream<CharType,Traits>
+    {
+    public:
+        typedef basic_filebuf<CharType,Traits> internal_buffer_type;
+        typedef std::basic_istream<CharType,Traits> internal_stream_type;
+
+        basic_ifstream() : 
+            internal_stream_type(0)
+        {
+            buf_.reset(new internal_buffer_type());
+            std::ios::rdbuf(buf_.get());
+        }
+        
+        explicit basic_ifstream(char const *file_name,std::ios_base::openmode mode = std::ios_base::in) : 
+            internal_stream_type(0) 
+        {
+            buf_.reset(new internal_buffer_type());
+            std::ios::rdbuf(buf_.get());
+            open(file_name,mode);
+        }
+
+        explicit basic_ifstream(std::string const &file_name,std::ios_base::openmode mode = std::ios_base::in) : 
+            internal_stream_type(0) 
+        {
+            buf_.reset(new internal_buffer_type());
+            std::ios::rdbuf(buf_.get());
+            open(file_name,mode);
+        }
+
+        
+        void open(std::string const &file_name,std::ios_base::openmode mode = std::ios_base::in)
+        {
+            open(file_name.c_str(),mode);
+        }
+        void open(char const *file_name,std::ios_base::openmode mode = std::ios_base::in)
+        {
+            if(!buf_->open(file_name,mode | std::ios_base::in)) {
+                this->setstate(std::ios_base::failbit);
+            }
+            else {
+                this->clear();
+            }
+        }
+        bool is_open()
+        {
+            return buf_->is_open();
+        }
+        bool is_open() const
+        {
+            return buf_->is_open();
+        }
+        void close()
+        {
+            if(!buf_->close())
+                this->setstate(std::ios_base::failbit);
+            else
+                this->clear();
+        }
+
+        internal_buffer_type *rdbuf() const
+        {
+            return buf_.get();
+        }
+        ~basic_ifstream()
+        {
+            buf_->close();
+        }
+            
+    private:
+        boost::scoped_ptr<internal_buffer_type> buf_;
+    };
+
+    ///
+    /// \brief Same as std::basic_ofstream<char> but accepts UTF-8 strings under Windows
+    ///
+
+    template<typename CharType,typename Traits = std::char_traits<CharType> >
+    class basic_ofstream : public std::basic_ostream<CharType,Traits>
+    {
+    public:
+        typedef basic_filebuf<CharType,Traits> internal_buffer_type;
+        typedef std::basic_ostream<CharType,Traits> internal_stream_type;
+
+        basic_ofstream() : 
+            internal_stream_type(0)
+        {
+            buf_.reset(new internal_buffer_type());
+            std::ios::rdbuf(buf_.get());
+        }
+        explicit basic_ofstream(char const *file_name,std::ios_base::openmode mode = std::ios_base::out) :
+            internal_stream_type(0)
+        {
+            buf_.reset(new internal_buffer_type());
+            std::ios::rdbuf(buf_.get());
+            open(file_name,mode);
+        }
+        explicit basic_ofstream(std::string const &file_name,std::ios_base::openmode mode = std::ios_base::out) :
+            internal_stream_type(0)
+        {
+            buf_.reset(new internal_buffer_type());
+            std::ios::rdbuf(buf_.get());
+            open(file_name,mode);
+        }
+        void open(std::string const &file_name,std::ios_base::openmode mode = std::ios_base::out)
+        {
+            open(file_name.c_str(),mode);
+        }
+        void open(char const *file_name,std::ios_base::openmode mode = std::ios_base::out)
+        {
+            if(!buf_->open(file_name,mode | std::ios_base::out)) {
+                this->setstate(std::ios_base::failbit);
+            }
+            else {
+                this->clear();
+            }
+        }
+        bool is_open()
+        {
+            return buf_->is_open();
+        }
+        bool is_open() const
+        {
+            return buf_->is_open();
+        }
+        void close()
+        {
+            if(!buf_->close())
+                this->setstate(std::ios_base::failbit);
+            else
+                this->clear();
+        }
+
+        internal_buffer_type *rdbuf() const
+        {
+            return buf_.get();
+        }
+        ~basic_ofstream()
+        {
+            buf_->close();
+        }
+            
+    private:
+        boost::scoped_ptr<internal_buffer_type> buf_;
+    };
+
+    ///
+    /// \brief Same as std::basic_fstream<char> but accepts UTF-8 strings under Windows
+    ///
+
+    template<typename CharType,typename Traits = std::char_traits<CharType> >
+    class basic_fstream : public std::basic_iostream<CharType,Traits>
+    {
+    public:
+        typedef basic_filebuf<CharType,Traits> internal_buffer_type;
+        typedef std::basic_iostream<CharType,Traits> internal_stream_type;
+
+        basic_fstream() : 
+            internal_stream_type(0)
+        {
+            buf_.reset(new internal_buffer_type());
+            std::ios::rdbuf(buf_.get());
+        }
+        explicit basic_fstream(char const *file_name,std::ios_base::openmode mode = std::ios_base::out | std::ios_base::in) :
+            internal_stream_type(0)
+        {
+            buf_.reset(new internal_buffer_type());
+            std::ios::rdbuf(buf_.get());
+            open(file_name,mode);
+        }
+        explicit basic_fstream(std::string const &file_name,std::ios_base::openmode mode = std::ios_base::out | std::ios_base::in) :
+            internal_stream_type(0)
+        {
+            buf_.reset(new internal_buffer_type());
+            std::ios::rdbuf(buf_.get());
+            open(file_name,mode);
+        }
+        void open(std::string const &file_name,std::ios_base::openmode mode = std::ios_base::out | std::ios_base::out)
+        {
+            open(file_name.c_str(),mode);
+        }
+        void open(char const *file_name,std::ios_base::openmode mode = std::ios_base::out | std::ios_base::out)
+        {
+            if(!buf_->open(file_name,mode)) {
+                this->setstate(std::ios_base::failbit);
+            }
+            else {
+                this->clear();
+            }
+        }
+        bool is_open()
+        {
+            return buf_->is_open();
+        }
+        bool is_open() const
+        {
+            return buf_->is_open();
+        }
+        void close()
+        {
+            if(!buf_->close())
+                this->setstate(std::ios_base::failbit);
+            else
+                this->clear();
+        }
+
+        internal_buffer_type *rdbuf() const
+        {
+            return buf_.get();
+        }
+        ~basic_fstream()
+        {
+            buf_->close();
+        }
+            
+    private:
+        boost::scoped_ptr<internal_buffer_type> buf_;
+    };
+
+
+    ///
+    /// \brief Same as std::filebuf but accepts UTF-8 strings under Windows
+    ///
+    typedef basic_filebuf<char> filebuf;
+    ///
+    /// Same as std::ifstream but accepts UTF-8 strings under Windows
+    ///
+    typedef basic_ifstream<char> ifstream;
+    ///
+    /// Same as std::ofstream but accepts UTF-8 strings under Windows
+    ///
+    typedef basic_ofstream<char> ofstream;
+    ///
+    /// Same as std::fstream but accepts UTF-8 strings under Windows
+    ///
+    typedef basic_fstream<char> fstream;
+
+#endif
+} // nowide
+} // namespace boost
+
+
+
+#endif
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/integration/filesystem.hpp

@@ -0,0 +1,28 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_INTEGRATION_FILESYSTEM_HPP_INCLUDED
+#define BOOST_NOWIDE_INTEGRATION_FILESYSTEM_HPP_INCLUDED
+
+#include <boost/filesystem/path.hpp>
+#include <boost/nowide/utf8_codecvt.hpp>
+namespace boost {
+    namespace nowide {
+        ///
+        /// Instal utf8_codecvt facet into  boost::filesystem::path such all char strings are interpreted as utf-8 strings
+        ///
+        inline void nowide_filesystem()
+        {
+            std::locale tmp = std::locale(std::locale(),new boost::nowide::utf8_codecvt<wchar_t>());
+            boost::filesystem::path::imbue(tmp);
+        }
+    } // nowide
+} // boost
+
+#endif
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/iostream.cpp

@@ -0,0 +1,261 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#define BOOST_NOWIDE_SOURCE
+#include <boost/nowide/iostream.hpp>
+#include <boost/nowide/convert.hpp>
+#include <stdio.h>
+#include <vector>
+
+#ifdef BOOST_WINDOWS
+
+#ifndef NOMINMAX
+# define NOMINMAX
+#endif
+
+
+#include <windows.h>
+
+namespace boost {
+namespace nowide {
+namespace details {
+    class console_output_buffer : public std::streambuf {
+    public:
+        console_output_buffer(HANDLE h) :
+            handle_(h),
+            isatty_(false)
+        {
+            if(handle_) {
+                DWORD dummy;
+                isatty_ = GetConsoleMode(handle_,&dummy) == TRUE;
+            }
+        }
+    protected:
+        int sync()
+        {
+            return overflow(EOF);
+        }
+        int overflow(int c)
+        {
+            if(!handle_)
+                return -1;
+            int n = pptr() - pbase();
+            int r = 0;
+            
+            if(n > 0 && (r=write(pbase(),n)) < 0)
+                    return -1;
+            if(r < n) {
+                memmove(pbase(),pbase() + r,n-r);
+            }
+            setp(buffer_, buffer_ + buffer_size);
+            pbump(n-r);
+            if(c!=EOF)
+                sputc(c);
+            return 0;
+        }
+    private:
+        
+        int write(char const *p,int n)
+        {
+            namespace uf = boost::locale::utf;
+            char const *b = p;
+            char const *e = p+n;
+            DWORD size=0;
+            if(!isatty_) {
+                if(!WriteFile(handle_,p,n,&size,0) || static_cast<int>(size) != n)
+                    return -1;
+                return n;
+            }
+            if(n > buffer_size)
+                return -1;
+            wchar_t *out = wbuffer_;
+            uf::code_point c;
+            size_t decoded = 0;
+            while(p < e && (c = uf::utf_traits<char>::decode(p,e))!=uf::illegal && c!=uf::incomplete) {
+                out = uf::utf_traits<wchar_t>::encode(c,out);
+                decoded = p-b;
+            }
+            if(c==uf::illegal)
+                return -1;
+            if(!WriteConsoleW(handle_,wbuffer_,out - wbuffer_,&size,0))
+                return -1;
+            return decoded;
+        }
+        
+        static const int buffer_size = 1024;
+        char buffer_[buffer_size];
+        wchar_t wbuffer_[buffer_size]; // for null
+        HANDLE handle_;
+        bool isatty_;
+    };
+    
+    class console_input_buffer: public std::streambuf {
+    public:
+        console_input_buffer(HANDLE h) :
+            handle_(h),
+            isatty_(false),
+            wsize_(0)
+        {
+            if(handle_) {
+                DWORD dummy;
+                isatty_ = GetConsoleMode(handle_,&dummy) == TRUE;
+            }
+        } 
+        
+    protected:
+        int pbackfail(int c)
+        {
+            if(c==EOF)
+                return EOF;
+            
+            if(gptr()!=eback()) {
+                gbump(-1);
+                *gptr() = c;
+                return 0;
+            }
+            
+            if(pback_buffer_.empty()) {
+                pback_buffer_.resize(4);
+                char *b = &pback_buffer_[0];
+                char *e = b + pback_buffer_.size();
+                setg(b,e-1,e);
+                *gptr() = c;
+            }
+            else {
+                size_t n = pback_buffer_.size();
+                std::vector<char> tmp;
+                tmp.resize(n*2);
+                memcpy(&tmp[n],&pback_buffer_[0],n);
+                tmp.swap(pback_buffer_);
+                char *b = &pback_buffer_[0];
+                char *e = b + n * 2;
+                char *p = b+n-1;
+                *p = c;
+                setg(b,p,e);
+            }
+          
+            return 0;
+        }
+
+        int underflow()
+        {
+            if(!handle_)
+                return -1;
+            if(!pback_buffer_.empty())
+                pback_buffer_.clear();
+            
+            size_t n = read();
+            setg(buffer_,buffer_,buffer_+n);
+            if(n == 0)
+                return EOF;
+            return std::char_traits<char>::to_int_type(*gptr());
+        }
+        
+    private:
+        
+        size_t read()
+        {
+            namespace uf = boost::locale::utf;
+            if(!isatty_) {
+                DWORD read_bytes = 0;
+                if(!ReadFile(handle_,buffer_,buffer_size,&read_bytes,0))
+                    return 0;
+                return read_bytes;
+            }
+            DWORD read_wchars = 0;
+            size_t n = wbuffer_size - wsize_;
+            if(!ReadConsoleW(handle_,wbuffer_,n,&read_wchars,0))
+                return 0;
+            wsize_ += read_wchars;
+            char *out = buffer_;
+            wchar_t *b = wbuffer_;
+            wchar_t *e = b + wsize_;
+            wchar_t *p = b;
+            uf::code_point c;
+            wsize_ = e-p;
+            while(p < e && (c = uf::utf_traits<wchar_t>::decode(p,e))!=uf::illegal && c!=uf::incomplete) {
+                out = uf::utf_traits<char>::encode(c,out);
+                wsize_ = e-p;
+            }
+            
+            if(c==uf::illegal)
+                return -1;
+            
+            
+            if(c==uf::incomplete) {
+                memmove(b,e-wsize_,sizeof(wchar_t)*wsize_);
+            }
+            
+            return out - buffer_;
+        }
+        
+        static const size_t buffer_size = 1024 * 3;
+        static const size_t wbuffer_size = 1024;
+        char buffer_[buffer_size];
+        wchar_t wbuffer_[buffer_size]; // for null
+        HANDLE handle_;
+        bool isatty_;
+        int wsize_;
+        std::vector<char> pback_buffer_;
+    };
+
+    winconsole_ostream::winconsole_ostream(int fd) : std::ostream(0)
+    {
+        HANDLE h = 0;
+        switch(fd) {
+        case 1:
+            h = GetStdHandle(STD_OUTPUT_HANDLE);
+            break;
+        case 2:
+            h = GetStdHandle(STD_ERROR_HANDLE);
+            break;
+        }
+        d.reset(new console_output_buffer(h));
+        std::ostream::rdbuf(d.get());
+    }
+    
+    winconsole_ostream::~winconsole_ostream()
+    {
+    }
+
+    winconsole_istream::winconsole_istream() : std::istream(0)
+    {
+        HANDLE h = GetStdHandle(STD_INPUT_HANDLE);
+        d.reset(new console_input_buffer(h));
+        std::istream::rdbuf(d.get());
+    }
+    
+    winconsole_istream::~winconsole_istream()
+    {
+    }
+    
+} // details
+    
+BOOST_NOWIDE_DECL details::winconsole_istream cin;
+BOOST_NOWIDE_DECL details::winconsole_ostream cout(1);
+BOOST_NOWIDE_DECL details::winconsole_ostream cerr(2);
+BOOST_NOWIDE_DECL details::winconsole_ostream clog(2);
+    
+namespace {
+    struct initialize {
+        initialize()
+        {
+            boost::nowide::cin.tie(&boost::nowide::cout);
+            boost::nowide::cerr.tie(&boost::nowide::cout);
+            boost::nowide::clog.tie(&boost::nowide::cout);
+        }
+    } inst;
+}
+
+
+    
+} // nowide
+} // namespace boost
+
+#endif
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/iostream.hpp

@@ -0,0 +1,99 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_IOSTREAM_HPP_INCLUDED
+#define BOOST_NOWIDE_IOSTREAM_HPP_INCLUDED
+
+#include <boost/nowide/config.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <iostream>
+#include <ostream>
+#include <istream>
+
+#ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable : 4251)
+#endif
+
+
+namespace boost {
+namespace nowide {
+    #if !defined(BOOST_WINDOWS) && !defined(BOOST_NOWIDE_DOXYGEN)
+    using std::cout;
+    using std::cerr;
+    using std::cin;
+    using std::clog;
+    #else
+    
+    /// \cond INTERNAL 
+    namespace details {
+        class console_output_buffer;
+        class console_input_buffer;
+        
+        class BOOST_NOWIDE_DECL winconsole_ostream : public std::ostream {
+            winconsole_ostream(winconsole_ostream const &);
+            void operator=(winconsole_ostream const &);
+        public:
+            winconsole_ostream(int fd);
+            ~winconsole_ostream();
+        private:
+            boost::scoped_ptr<console_output_buffer> d;
+        };
+
+        class BOOST_NOWIDE_DECL winconsole_istream : public std::istream {
+            winconsole_istream(winconsole_istream const &);
+            void operator=(winconsole_istream const &);
+        public:
+            
+            winconsole_istream();
+            ~winconsole_istream();
+        private:
+            struct data;
+            boost::scoped_ptr<console_input_buffer> d;
+        };
+    } // details 
+    
+    /// \endcond
+
+    ///
+    /// \brief Same as std::cin, but uses UTF-8
+    ///
+    /// Note, the stream is not synchronized with stdio and not affected by std::ios::sync_with_stdio
+    /// 
+    extern BOOST_NOWIDE_DECL details::winconsole_istream cin;
+    ///
+    /// \brief Same as std::cout, but uses UTF-8
+    ///
+    /// Note, the stream is not synchronized with stdio and not affected by std::ios::sync_with_stdio
+    /// 
+    extern BOOST_NOWIDE_DECL details::winconsole_ostream cout;
+    ///
+    /// \brief Same as std::cerr, but uses UTF-8
+    ///
+    /// Note, the stream is not synchronized with stdio and not affected by std::ios::sync_with_stdio
+    /// 
+    extern BOOST_NOWIDE_DECL details::winconsole_ostream cerr;
+    ///
+    /// \brief Same as std::clog, but uses UTF-8
+    ///
+    /// Note, the stream is not synchronized with stdio and not affected by std::ios::sync_with_stdio
+    /// 
+    extern BOOST_NOWIDE_DECL details::winconsole_ostream clog;
+
+    #endif
+
+} // nowide
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
+
+#endif
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/stackstring.hpp

@@ -0,0 +1,154 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_DETAILS_WIDESTR_H_INCLUDED
+#define BOOST_NOWIDE_DETAILS_WIDESTR_H_INCLUDED
+#include <boost/nowide/convert.hpp>
+#include <string.h>
+#include <algorithm>
+
+namespace boost {
+namespace nowide {
+
+///
+/// \brief A class that allows to create a temporary wide or narrow UTF strings from
+/// wide or narrow UTF source.
+///
+/// It uses on stack buffer of the string is short enough
+/// and allocated a buffer on the heap if the size of the buffer is too small
+///    
+template<typename CharOut=wchar_t,typename CharIn = char,size_t BufferSize = 256>
+class basic_stackstring {
+public:
+   
+    static const size_t buffer_size = BufferSize; 
+    typedef CharOut output_char;
+    typedef CharIn input_char;
+
+    basic_stackstring(basic_stackstring const &other) : 
+    mem_buffer_(0)
+    {
+        clear();
+        if(other.mem_buffer_) {
+            size_t len = 0;
+            while(other.mem_buffer_[len])
+                len ++;
+            mem_buffer_ = new output_char[len + 1];
+            memcpy(mem_buffer_,other.mem_buffer_,sizeof(output_char) * (len+1));
+        }
+        else {
+            memcpy(buffer_,other.buffer_,buffer_size * sizeof(output_char));
+        }
+    }
+    
+    void swap(basic_stackstring &other)
+    {
+        std::swap(mem_buffer_,other.mem_buffer_);
+        for(size_t i=0;i<buffer_size;i++)
+            std::swap(buffer_[i],other.buffer_[i]);
+    }
+    basic_stackstring &operator=(basic_stackstring const &other)
+    {
+        if(this != &other) {
+            basic_stackstring tmp(other);
+            swap(tmp);            
+        }
+        return *this;
+    }
+
+    basic_stackstring() : mem_buffer_(0)
+    {
+    }
+    bool convert(input_char const *input)
+    {
+        return convert(input,details::basic_strend(input));
+    }
+    bool convert(input_char const *begin,input_char const *end)
+    {
+        clear();
+
+        size_t space = get_space(sizeof(input_char),sizeof(output_char),end - begin) + 1;
+        if(space <= buffer_size) {
+            if(basic_convert(buffer_,buffer_size,begin,end))
+                return true;
+            clear();
+            return false;
+        }
+        else {
+            mem_buffer_ = new output_char[space];
+            if(!basic_convert(mem_buffer_,space,begin,end)) {
+                clear();
+                return false;
+            }
+            return true;
+        }
+
+    }
+    output_char *c_str()
+    {
+        if(mem_buffer_)
+            return mem_buffer_;
+        return buffer_;
+    }
+    output_char const *c_str() const
+    {
+        if(mem_buffer_)
+            return mem_buffer_;
+        return buffer_;
+    }
+    void clear()
+    {
+        if(mem_buffer_) {
+            delete [] mem_buffer_;
+            mem_buffer_=0;
+        }
+        buffer_[0] = 0;
+    }
+    ~basic_stackstring()
+    {
+        clear();
+    }
+private:
+    static size_t get_space(size_t insize,size_t outsize,size_t in)
+    {
+        if(insize <= outsize)
+            return in;
+        else if(insize == 2 && outsize == 1) 
+            return 3 * in;
+        else if(insize == 4 && outsize == 1) 
+            return 4 * in;
+        else  // if(insize == 4 && outsize == 2) 
+            return 2 * in;
+    }
+    output_char buffer_[buffer_size];
+    output_char *mem_buffer_;
+};  //basic_stackstring
+
+///
+/// Convinience typedef
+///
+typedef basic_stackstring<wchar_t,char,256> wstackstring;
+///
+/// Convinience typedef
+///
+typedef basic_stackstring<char,wchar_t,256> stackstring;
+///
+/// Convinience typedef
+///
+typedef basic_stackstring<wchar_t,char,16> wshort_stackstring;
+///
+/// Convinience typedef
+///
+typedef basic_stackstring<char,wchar_t,16> short_stackstring;
+
+
+} // nowide
+} // namespace boost
+
+#endif
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/system.hpp

@@ -0,0 +1,46 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_CSTDLIB_HPP
+#define BOOST_NOWIDE_CSTDLIB_HPP
+
+#include <stdlib.h>
+#include <errno.h>
+#include <boost/nowide/stackstring.hpp>
+namespace boost {
+namespace nowide {
+
+#if !defined(BOOST_WINDOWS) && !defined(BOOST_NOWIDE_DOXYGEN)
+
+using ::system;
+
+#else // Windows
+
+///
+/// Same as std::system but cmd is UTF-8.
+///
+/// If the input is not valid UTF-8, -1 returned and errno set to EINVAL
+///
+inline int system(char const *cmd)
+{
+    if(!cmd)
+        return _wsystem(0);
+    wstackstring wcmd;
+    if(!wcmd.convert(cmd)) {
+        errno = EINVAL;
+        return -1;
+    }
+    return _wsystem(wcmd.c_str());
+}
+
+#endif
+} // nowide
+} // namespace boost
+
+#endif
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/utf8_codecvt.hpp

@@ -0,0 +1,499 @@
+//
+//  Copyright (c) 2015 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_UTF8_CODECVT_HPP
+#define BOOST_NOWIDE_UTF8_CODECVT_HPP
+
+#include <boost/locale/utf.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/static_assert.hpp>
+#include <locale>
+
+namespace boost {
+namespace nowide {
+
+//
+// Make sure that mbstate can keep 16 bit of UTF-16 sequence
+//
+BOOST_STATIC_ASSERT(sizeof(std::mbstate_t)>=2);
+
+#ifdef _MSC_VER
+// MSVC do_length is non-standard it counts wide characters instead of narrow and does not change mbstate
+#define BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST
+#endif
+
+template<typename CharType,int CharSize=sizeof(CharType)>
+class utf8_codecvt;
+
+template<typename CharType>
+class utf8_codecvt<CharType,2> : public std::codecvt<CharType,char,std::mbstate_t>
+{
+public:
+    utf8_codecvt(size_t refs = 0) : std::codecvt<CharType,char,std::mbstate_t>(refs)
+    {
+    }
+protected:
+
+    typedef CharType uchar;
+
+    virtual std::codecvt_base::result do_unshift(std::mbstate_t &s,char *from,char * /*to*/,char *&next) const
+    {
+        boost::uint16_t &state = *reinterpret_cast<boost::uint16_t *>(&s);
+#ifdef DEBUG_CODECVT            
+        std::cout << "Entering unshift " << std::hex << state << std::dec << std::endl;
+#endif            
+        if(state != 0)
+            return std::codecvt_base::error;
+        next=from;
+        return std::codecvt_base::ok;
+    }
+    virtual int do_encoding() const throw()
+    {
+        return 0;
+    }
+    virtual int do_max_length() const throw()
+    {
+        return 4;
+    }
+    virtual bool do_always_noconv() const throw()
+    {
+        return false;
+    }
+
+    virtual int
+    do_length(  std::mbstate_t 
+    #ifdef BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST
+            const   
+    #endif
+            &std_state,
+            char const *from,
+            char const *from_end,
+            size_t max) const
+    {
+        #ifndef BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST
+        char const *save_from = from;
+        boost::uint16_t &state = *reinterpret_cast<boost::uint16_t *>(&std_state);
+        #else
+        size_t save_max = max;
+        boost::uint16_t state = *reinterpret_cast<boost::uint16_t const *>(&std_state);
+        #endif
+        while(max > 0 && from < from_end){
+            char const *prev_from = from;
+            boost::uint32_t ch=boost::locale::utf::utf_traits<char>::decode(from,from_end);
+            if(ch==boost::locale::utf::incomplete || ch==boost::locale::utf::illegal) {
+                from = prev_from;
+                break;
+            }
+            max --;
+            if(ch > 0xFFFF) {
+                if(state == 0) {
+                    from = prev_from;
+                    state = 1;
+                }
+                else {
+                    state = 0;
+                }
+            }        
+        }
+        #ifndef BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST
+        return from - save_from;
+        #else
+        return int(save_max - max);
+        #endif
+    }
+
+    
+    virtual std::codecvt_base::result 
+    do_in(  std::mbstate_t &std_state,
+            char const *from,
+            char const *from_end,
+            char const *&from_next,
+            uchar *to,
+            uchar *to_end,
+            uchar *&to_next) const
+    {
+        std::codecvt_base::result r=std::codecvt_base::ok;
+        
+        // mbstate_t is POD type and should be initialized to 0 (i.a. state = stateT())
+        // according to standard. We use it to keep a flag 0/1 for surrogate pair writing
+        //
+        // if 0 no code above >0xFFFF observed, of 1 a code above 0xFFFF observerd
+        // and first pair is written, but no input consumed
+        boost::uint16_t &state = *reinterpret_cast<boost::uint16_t *>(&std_state);
+        while(to < to_end && from < from_end)
+        {
+#ifdef DEBUG_CODECVT            
+            std::cout << "Entering IN--------------" << std::endl;
+            std::cout << "State " << std::hex << state <<std::endl;
+            std::cout << "Left in " << std::dec << from_end - from << " out " << to_end -to << std::endl;
+#endif           
+            char const *from_saved = from;
+            
+            uint32_t ch=boost::locale::utf::utf_traits<char>::decode(from,from_end);
+            
+            if(ch==boost::locale::utf::illegal) {
+                from = from_saved;
+                r=std::codecvt_base::error;
+                break;
+            }
+            if(ch==boost::locale::utf::incomplete) {
+                from = from_saved;
+                r=std::codecvt_base::partial;
+                break;
+            }
+            // Normal codepoints go direcly to stream
+            if(ch <= 0xFFFF) {
+                *to++=ch;
+            }
+            else {
+                // for  other codepoints we do following
+                //
+                // 1. We can't consume our input as we may find ourselfs
+                //    in state where all input consumed but not all output written,i.e. only
+                //    1st pair is written
+                // 2. We only write first pair and mark this in the state, we also revert back
+                //    the from pointer in order to make sure this codepoint would be read
+                //    once again and then we would consume our input together with writing
+                //    second surrogate pair
+                ch-=0x10000;
+                boost::uint16_t vh = ch >> 10;
+                boost::uint16_t vl = ch & 0x3FF;
+                boost::uint16_t w1 = vh + 0xD800;
+                boost::uint16_t w2 = vl + 0xDC00;
+                if(state == 0) {
+                    from = from_saved;
+                    *to++ = w1;
+                    state = 1;
+                }
+                else {
+                    *to++ = w2;
+                    state = 0;
+                }
+            }
+        }
+        from_next=from;
+        to_next=to;
+        if(r == std::codecvt_base::ok && (from!=from_end || state!=0))
+            r = std::codecvt_base::partial;
+#ifdef DEBUG_CODECVT            
+        std::cout << "Returning ";
+        switch(r) {
+        case std::codecvt_base::ok:
+            std::cout << "ok" << std::endl;
+            break;
+        case std::codecvt_base::partial:
+            std::cout << "partial" << std::endl;
+            break;
+        case std::codecvt_base::error:
+            std::cout << "error" << std::endl;
+            break;
+        default:
+            std::cout << "other" << std::endl;
+            break;
+        }
+        std::cout << "State " << std::hex << state <<std::endl;
+        std::cout << "Left in " << std::dec << from_end - from << " out " << to_end -to << std::endl;
+#endif            
+        return r;
+    }
+    
+    virtual std::codecvt_base::result 
+    do_out( std::mbstate_t &std_state,
+            uchar const *from,
+            uchar const *from_end,
+            uchar const *&from_next,
+            char *to,
+            char *to_end,
+            char *&to_next) const
+    {
+        std::codecvt_base::result r=std::codecvt_base::ok;
+        // mbstate_t is POD type and should be initialized to 0 (i.a. state = stateT())
+        // according to standard. We assume that sizeof(mbstate_t) >=2 in order
+        // to be able to store first observerd surrogate pair
+        //
+        // State: state!=0 - a first surrogate pair was observerd (state = first pair),
+        // we expect the second one to come and then zero the state
+        ///
+        boost::uint16_t &state = *reinterpret_cast<boost::uint16_t *>(&std_state);
+        while(to < to_end && from < from_end)
+        {
+#ifdef DEBUG_CODECVT            
+        std::cout << "Entering OUT --------------" << std::endl;
+        std::cout << "State " << std::hex << state <<std::endl;
+        std::cout << "Left in " << std::dec << from_end - from << " out " << to_end -to << std::endl;
+#endif            
+            boost::uint32_t ch=0;
+            if(state != 0) {
+                // if the state idecates that 1st surrogate pair was written
+                // we should make sure that the second one that comes is actually
+                // second surrogate
+                boost::uint16_t w1 = state;
+                boost::uint16_t w2 = *from; 
+                // we don't forward from as writing may fail to incomplete or
+                // partial conversion
+                if(0xDC00 <= w2 && w2<=0xDFFF) {
+                    boost::uint16_t vh = w1 - 0xD800;
+                    boost::uint16_t vl = w2 - 0xDC00;
+                    ch=((uint32_t(vh) << 10)  | vl) + 0x10000;
+                }
+                else {
+                    // Invalid surrogate
+                    r=std::codecvt_base::error;
+                    break;
+                }
+            }
+            else {
+                ch = *from;
+                if(0xD800 <= ch && ch<=0xDBFF) {
+                    // if this is a first surrogate pair we put
+                    // it into the state and consume it, note we don't
+                    // go forward as it should be illegal so we increase
+                    // the from pointer manually
+                    state = ch;
+                    from++;
+                    continue;
+                }
+                else if(0xDC00 <= ch && ch<=0xDFFF) {
+                    // if we observe second surrogate pair and 
+                    // first only may be expected we should break from the loop with error
+                    // as it is illegal input
+                    r=std::codecvt_base::error;
+                    break;
+                }
+            }
+            if(!boost::locale::utf::is_valid_codepoint(ch)) {
+                r=std::codecvt_base::error;
+                break;
+            }
+            int len = boost::locale::utf::utf_traits<char>::width(ch);
+            if(to_end - to < len) {
+                r=std::codecvt_base::partial;
+                break;
+            }
+            to = boost::locale::utf::utf_traits<char>::encode(ch,to);
+            state = 0;
+            from++;
+        }
+        from_next=from;
+        to_next=to;
+        if(r==std::codecvt_base::ok && from!=from_end)
+            r = std::codecvt_base::partial;
+#ifdef DEBUG_CODECVT            
+        std::cout << "Returning ";
+        switch(r) {
+        case std::codecvt_base::ok:
+            std::cout << "ok" << std::endl;
+            break;
+        case std::codecvt_base::partial:
+            std::cout << "partial" << std::endl;
+            break;
+        case std::codecvt_base::error:
+            std::cout << "error" << std::endl;
+            break;
+        default:
+            std::cout << "other" << std::endl;
+            break;
+        }
+        std::cout << "State " << std::hex << state <<std::endl;
+        std::cout << "Left in " << std::dec << from_end - from << " out " << to_end -to << std::endl;
+#endif            
+        return r;
+    }
+    
+};
+
+template<typename CharType>
+class utf8_codecvt<CharType,4> : public std::codecvt<CharType,char,std::mbstate_t>
+{
+public:
+    utf8_codecvt(size_t refs = 0) : std::codecvt<CharType,char,std::mbstate_t>(refs)
+    {
+    }
+protected:
+
+    typedef CharType uchar;
+
+    virtual std::codecvt_base::result do_unshift(std::mbstate_t &/*s*/,char *from,char * /*to*/,char *&next) const
+    {
+        next=from;
+        return std::codecvt_base::ok;
+    }
+    virtual int do_encoding() const throw()
+    {
+        return 0;
+    }
+    virtual int do_max_length() const throw()
+    {
+        return 4;
+    }
+    virtual bool do_always_noconv() const throw()
+    {
+        return false;
+    }
+
+    virtual int
+    do_length(  std::mbstate_t 
+    #ifdef BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST
+            const   
+    #endif    
+            &/*state*/,
+            char const *from,
+            char const *from_end,
+            size_t max) const
+    {
+        #ifndef BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST 
+        char const *start_from = from;
+        #else
+        size_t save_max = max;
+        #endif
+        
+        while(max > 0 && from < from_end){
+            char const *save_from = from;
+            boost::uint32_t ch=boost::locale::utf::utf_traits<char>::decode(from,from_end);
+            if(ch==boost::locale::utf::incomplete || ch==boost::locale::utf::illegal) {
+                from = save_from;
+                break;
+            }
+            max--;
+        }
+        #ifndef BOOST_NOWIDE_DO_LENGTH_MBSTATE_CONST 
+        return from - start_from;
+        #else
+        return save_max - max;
+        #endif
+    }
+
+    
+    virtual std::codecvt_base::result 
+    do_in(  std::mbstate_t &/*state*/,
+            char const *from,
+            char const *from_end,
+            char const *&from_next,
+            uchar *to,
+            uchar *to_end,
+            uchar *&to_next) const
+    {
+        std::codecvt_base::result r=std::codecvt_base::ok;
+        
+        // mbstate_t is POD type and should be initialized to 0 (i.a. state = stateT())
+        // according to standard. We use it to keep a flag 0/1 for surrogate pair writing
+        //
+        // if 0 no code above >0xFFFF observed, of 1 a code above 0xFFFF observerd
+        // and first pair is written, but no input consumed
+        while(to < to_end && from < from_end)
+        {
+#ifdef DEBUG_CODECVT            
+            std::cout << "Entering IN--------------" << std::endl;
+            std::cout << "State " << std::hex << state <<std::endl;
+            std::cout << "Left in " << std::dec << from_end - from << " out " << to_end -to << std::endl;
+#endif           
+            char const *from_saved = from;
+            
+            uint32_t ch=boost::locale::utf::utf_traits<char>::decode(from,from_end);
+            
+            if(ch==boost::locale::utf::illegal) {
+                r=std::codecvt_base::error;
+                from = from_saved;
+                break;
+            }
+            if(ch==boost::locale::utf::incomplete) {
+                r=std::codecvt_base::partial;
+                from=from_saved;
+                break;
+            }
+            *to++=ch;
+        }
+        from_next=from;
+        to_next=to;
+        if(r == std::codecvt_base::ok && from!=from_end)
+            r = std::codecvt_base::partial;
+#ifdef DEBUG_CODECVT            
+        std::cout << "Returning ";
+        switch(r) {
+        case std::codecvt_base::ok:
+            std::cout << "ok" << std::endl;
+            break;
+        case std::codecvt_base::partial:
+            std::cout << "partial" << std::endl;
+            break;
+        case std::codecvt_base::error:
+            std::cout << "error" << std::endl;
+            break;
+        default:
+            std::cout << "other" << std::endl;
+            break;
+        }
+        std::cout << "State " << std::hex << state <<std::endl;
+        std::cout << "Left in " << std::dec << from_end - from << " out " << to_end -to << std::endl;
+#endif            
+        return r;
+    }
+    
+    virtual std::codecvt_base::result 
+    do_out( std::mbstate_t &std_state,
+            uchar const *from,
+            uchar const *from_end,
+            uchar const *&from_next,
+            char *to,
+            char *to_end,
+            char *&to_next) const
+    {
+        std::codecvt_base::result r=std::codecvt_base::ok;
+        while(to < to_end && from < from_end)
+        {
+#ifdef DEBUG_CODECVT            
+        std::cout << "Entering OUT --------------" << std::endl;
+        std::cout << "State " << std::hex << state <<std::endl;
+        std::cout << "Left in " << std::dec << from_end - from << " out " << to_end -to << std::endl;
+#endif            
+            boost::uint32_t ch=0;
+            ch = *from;
+            if(!boost::locale::utf::is_valid_codepoint(ch)) {
+                r=std::codecvt_base::error;
+                break;
+            }
+            int len = boost::locale::utf::utf_traits<char>::width(ch);
+            if(to_end - to < len) {
+                r=std::codecvt_base::partial;
+                break;
+            }
+            to = boost::locale::utf::utf_traits<char>::encode(ch,to);
+            from++;
+        }
+        from_next=from;
+        to_next=to;
+        if(r==std::codecvt_base::ok && from!=from_end)
+            r = std::codecvt_base::partial;
+#ifdef DEBUG_CODECVT            
+        std::cout << "Returning ";
+        switch(r) {
+        case std::codecvt_base::ok:
+            std::cout << "ok" << std::endl;
+            break;
+        case std::codecvt_base::partial:
+            std::cout << "partial" << std::endl;
+            break;
+        case std::codecvt_base::error:
+            std::cout << "error" << std::endl;
+            break;
+        default:
+            std::cout << "other" << std::endl;
+            break;
+        }
+        std::cout << "State " << std::hex << state <<std::endl;
+        std::cout << "Left in " << std::dec << from_end - from << " out " << to_end -to << std::endl;
+#endif            
+        return r;
+    }
+};
+
+} // nowide
+} // namespace boost
+
+#endif
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/boost/nowide/windows.hpp

@@ -0,0 +1,39 @@
+//
+//  Copyright (c) 2012 Artyom Beilis (Tonkikh)
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_NOWIDE_WINDOWS_HPP_INCLUDED
+#define BOOST_NOWIDE_WINDOWS_HPP_INCLUDED
+
+#include <stddef.h>
+
+#ifdef BOOST_NOWIDE_USE_WINDOWS_H
+#include <windows.h>
+#else
+
+//
+// These are function prototypes... Allow to to include windows.h
+//
+extern "C" {
+
+__declspec(dllimport) wchar_t*        __stdcall GetEnvironmentStringsW(void);
+__declspec(dllimport) int             __stdcall FreeEnvironmentStringsW(wchar_t *);
+__declspec(dllimport) wchar_t*        __stdcall GetCommandLineW(void);
+__declspec(dllimport) wchar_t**       __stdcall CommandLineToArgvW(wchar_t const *,int *);
+__declspec(dllimport) unsigned long   __stdcall GetLastError();
+__declspec(dllimport) void*           __stdcall LocalFree(void *);
+__declspec(dllimport) int             __stdcall SetEnvironmentVariableW(wchar_t const *,wchar_t const *);
+__declspec(dllimport) unsigned long   __stdcall GetEnvironmentVariableW(wchar_t const *,wchar_t *,unsigned long);
+
+}
+
+#endif 
+
+
+
+#endif
+///
+// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

src/build-utils/CMakeLists.txt

@@ -0,0 +1,50 @@
+
+option(SLIC3R_ENC_CHECK "Verify encoding of source files" 1)
+
+if (IS_CROSS_COMPILE)
+    # Force disable due to cross compilation. This fact is already printed on cli for users
+    set(SLIC3R_ENC_CHECK OFF CACHE BOOL "" FORCE)
+endif ()
+
+if (SLIC3R_ENC_CHECK)
+    add_executable(encoding-check encoding-check.cpp)
+
+    # A global no-op target which depends on all encodings checks,
+    # and on which in turn all checked targets depend.
+    # This is done to make encoding checks the first thing to be
+    # performed before actually compiling any sources of the checked targets
+    # to make the check fail as early as possible.
+    add_custom_target(global-encoding-check
+        ALL
+        DEPENDS encoding-check
+    )
+endif()
+
+# Function that adds source file encoding check to a target
+# using the above encoding-check binary
+
+function(encoding_check TARGET)
+    if (SLIC3R_ENC_CHECK)
+        # Obtain target source files
+        get_target_property(T_SOURCES ${TARGET} SOURCES)
+
+        # Define top-level encoding check target for this ${TARGET}
+        add_custom_target(encoding-check-${TARGET}
+            DEPENDS encoding-check ${T_SOURCES}
+            COMMENT "Checking source files encodings for target ${TARGET}"
+        )
+
+        # Add checking of each source file as a subcommand of encoding-check-${TARGET}
+        foreach(file ${T_SOURCES})
+            add_custom_command(TARGET encoding-check-${TARGET}
+                COMMAND $<TARGET_FILE:encoding-check> ${TARGET} ${file}
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+            )
+        endforeach()
+
+        # This adds dependency on encoding-check-${TARGET} to ${TARET}
+        # via the global-encoding-check
+        add_dependencies(global-encoding-check encoding-check-${TARGET})
+        add_dependencies(${TARGET} global-encoding-check)
+    endif()
+endfunction()

src/build-utils/encoding-check.cpp

@@ -0,0 +1,119 @@
+#include <vector>
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+
+
+/*
+ * The utf8_check() function scans the '\0'-terminated string starting
+ * at s. It returns a pointer to the first byte of the first malformed
+ * or overlong UTF-8 sequence found, or NULL if the string contains
+ * only correct UTF-8. It also spots UTF-8 sequences that could cause
+ * trouble if converted to UTF-16, namely surrogate characters
+ * (U+D800..U+DFFF) and non-Unicode positions (U+FFFE..U+FFFF). This
+ * routine is very likely to find a malformed sequence if the input
+ * uses any other encoding than UTF-8. It therefore can be used as a
+ * very effective heuristic for distinguishing between UTF-8 and other
+ * encodings.
+ *
+ * I wrote this code mainly as a specification of functionality; there
+ * are no doubt performance optimizations possible for certain CPUs.
+ *
+ * Markus Kuhn <http://www.cl.cam.ac.uk/~mgk25/> -- 2005-03-30
+ * License: http://www.cl.cam.ac.uk/~mgk25/short-license.html
+ */
+
+unsigned char *utf8_check(unsigned char *s)
+{
+    while (*s) {
+        if (*s < 0x80) {
+            // 0xxxxxxx
+            s++;
+        } else if ((s[0] & 0xe0) == 0xc0) {
+            // 110xxxxx 10xxxxxx
+            if ((s[1] & 0xc0) != 0x80 ||
+                (s[0] & 0xfe) == 0xc0) {         // overlong?
+                return s;
+            } else {
+                s += 2;
+            }
+        } else if ((s[0] & 0xf0) == 0xe0) {
+            // 1110xxxx 10xxxxxx 10xxxxxx
+            if ((s[1] & 0xc0) != 0x80 ||
+                (s[2] & 0xc0) != 0x80 ||
+                (s[0] == 0xe0 && (s[1] & 0xe0) == 0x80) || // overlong?
+                (s[0] == 0xed && (s[1] & 0xe0) == 0xa0) || // surrogate?
+                (s[0] == 0xef && s[1] == 0xbf &&
+                (s[2] & 0xfe) == 0xbe)) {                  // U+FFFE or U+FFFF?
+                return s;
+            } else {
+                s += 3;
+            }
+        } else if ((s[0] & 0xf8) == 0xf0) {
+            // 11110xxX 10xxxxxx 10xxxxxx 10xxxxxx
+            if ((s[1] & 0xc0) != 0x80 ||
+                (s[2] & 0xc0) != 0x80 ||
+                (s[3] & 0xc0) != 0x80 ||
+                (s[0] == 0xf0 && (s[1] & 0xf0) == 0x80) ||      // overlong?
+                (s[0] == 0xf4 && s[1] > 0x8f) || s[0] > 0xf4) { // > U+10FFFF?
+                return s;
+            } else {
+                s += 4;
+            }
+        } else {
+            return s;
+        }
+    }
+
+    return NULL;
+}
+
+
+int main(int argc, char const *argv[])
+{
+    if (argc != 3) {
+        std::cerr << "Usage: " << argv[0] << " <program/library> <file>" << std::endl;
+        return -1;
+    }
+
+    const char* target = argv[1];
+    const char* filename = argv[2];
+
+    const auto error_exit = [=](const char* error) {
+        std::cerr << "\n\tError: " << error << ": " << filename << "\n"
+            << "\tTarget: " << target << "\n"
+            << std::endl;
+        std::exit(-2);
+    };
+
+    std::ifstream file(filename, std::ios::binary | std::ios::ate);
+    const auto size = file.tellg();
+
+    if (size == 0) {
+        return 0;
+    }
+
+    file.seekg(0, std::ios::beg);
+    std::vector<char> buffer(size);
+
+    if (file.read(buffer.data(), size)) {
+        buffer.push_back('\0');
+
+        // Check UTF-8 validity
+        if (utf8_check(reinterpret_cast<unsigned char*>(buffer.data())) != nullptr) {
+            error_exit("Source file does not contain (valid) UTF-8");
+        }
+
+        // Check against a BOM mark
+        if (buffer.size() >= 3
+            && buffer[0] == '\xef'
+            && buffer[1] == '\xbb'
+            && buffer[2] == '\xbf') {
+            error_exit("Source file is valid UTF-8 but contains a BOM mark");
+        }
+    } else {
+        error_exit("Could not read source file");
+    }
+
+    return 0;
+}

src/clipper/CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 2.8.12)
+project(clipper)
+
+add_library(clipper STATIC
+# We are using ClipperLib compiled as part of the libslic3r project using Slic3r::Point as its base type.
+#    clipper.cpp
+#    clipper.hpp
+    clipper_z.cpp
+    clipper_z.hpp
+)
+
+if(SLIC3R_PROFILE)
+    target_link_libraries(clipper Shiny)
+endif()

src/clipper/clipper.hpp

@@ -0,0 +1,574 @@
+/*******************************************************************************
+*                                                                              *
+* Author    :  Angus Johnson                                                   *
+* Version   :  6.2.9                                                           *
+* Date      :  16 February 2015                                                *
+* Website   :  http://www.angusj.com                                           *
+* Copyright :  Angus Johnson 2010-2015                                         *
+*                                                                              *
+* License:                                                                     *
+* Use, modification & distribution is subject to Boost Software License Ver 1. *
+* http://www.boost.org/LICENSE_1_0.txt                                         *
+*                                                                              *
+* Attributions:                                                                *
+* The code in this library is an extension of Bala Vatti's clipping algorithm: *
+* "A generic solution to polygon clipping"                                     *
+* Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63.             *
+* http://portal.acm.org/citation.cfm?id=129906                                 *
+*                                                                              *
+* Computer graphics and geometric modeling: implementation and algorithms      *
+* By Max K. Agoston                                                            *
+* Springer; 1 edition (January 4, 2005)                                        *
+* http://books.google.com/books?q=vatti+clipping+agoston                       *
+*                                                                              *
+* See also:                                                                    *
+* "Polygon Offsetting by Computing Winding Numbers"                            *
+* Paper no. DETC2005-85513 pp. 565-575                                         *
+* ASME 2005 International Design Engineering Technical Conferences             *
+* and Computers and Information in Engineering Conference (IDETC/CIE2005)      *
+* September 24-28, 2005 , Long Beach, California, USA                          *
+* http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf              *
+*                                                                              *
+*******************************************************************************/
+
+#ifndef clipper_hpp
+#define clipper_hpp
+
+#include <inttypes.h>
+#include <functional>
+
+#include <Eigen/Geometry> 
+
+#define CLIPPER_VERSION "6.2.6"
+
+//CLIPPERLIB_USE_XYZ: adds a Z member to IntPoint. Adds a minor cost to perfomance.
+//#define CLIPPERLIB_USE_XYZ
+
+//use_lines: Enables line clipping. Adds a very minor cost to performance.
+#define use_lines
+  
+//use_deprecated: Enables temporary support for the obsolete functions
+//#define use_deprecated  
+
+#include <vector>
+#include <deque>
+#include <stdexcept>
+#include <cstring>
+#include <cstdlib>
+#include <ostream>
+#include <functional>
+#include <queue>
+
+#ifdef CLIPPERLIB_NAMESPACE_PREFIX
+  namespace CLIPPERLIB_NAMESPACE_PREFIX {
+#endif // CLIPPERLIB_NAMESPACE_PREFIX
+
+#ifdef CLIPPERLIB_USE_XYZ
+  namespace ClipperLib_Z {
+#else
+  namespace ClipperLib {
+#endif
+
+enum ClipType { ctIntersection, ctUnion, ctDifference, ctXor };
+enum PolyType { ptSubject, ptClip };
+//By far the most widely used winding rules for polygon filling are
+//EvenOdd & NonZero (GDI, GDI+, XLib, OpenGL, Cairo, AGG, Quartz, SVG, Gr32)
+//Others rules include Positive, Negative and ABS_GTR_EQ_TWO (only in OpenGL)
+//see http://glprogramming.com/red/chapter11.html
+enum PolyFillType { pftEvenOdd, pftNonZero, pftPositive, pftNegative };
+
+// If defined, Clipper will work with 32bit signed int coordinates to reduce memory
+// consumption and to speed up exact orientation predicate calculation.
+// In that case, coordinates and their differences (vectors of the coordinates) have to fit int32_t.
+#define CLIPPERLIB_INT32
+
+// Point coordinate type
+#ifdef CLIPPERLIB_INT32
+  // Coordinates and their differences (vectors of the coordinates) have to fit int32_t.
+  typedef int32_t cInt;
+#else
+  typedef int64_t cInt;
+  // Maximum cInt value to allow a cross product calculation using 32bit expressions.
+  static constexpr cInt const loRange = 0x3FFFFFFF; // 0x3FFFFFFF = 1 073 741 823
+  // Maximum allowed cInt value.
+  static constexpr cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL;
+#endif // CLIPPERLIB_INT32
+
+#ifdef CLIPPERLIB_INTPOINT_TYPE
+using IntPoint = CLIPPERLIB_INTPOINT_TYPE;
+#else // CLIPPERLIB_INTPOINT_TYPE
+using IntPoint = Eigen::Matrix<cInt, 
+#ifdef CLIPPERLIB_USE_XYZ
+  3
+#else // CLIPPERLIB_USE_XYZ
+  2
+#endif // CLIPPERLIB_USE_XYZ
+  , 1, Eigen::DontAlign>;
+#endif // CLIPPERLIB_INTPOINT_TYPE
+
+using DoublePoint = Eigen::Matrix<double, 2, 1, Eigen::DontAlign>;
+
+//------------------------------------------------------------------------------
+
+typedef std::vector<IntPoint> Path;
+typedef std::vector<Path> Paths;
+
+inline Path& operator <<(Path& poly, const IntPoint& p) {poly.push_back(p); return poly;}
+inline Paths& operator <<(Paths& polys, const Path& p) {polys.push_back(p); return polys;}
+
+std::ostream& operator <<(std::ostream &s, const IntPoint &p);
+std::ostream& operator <<(std::ostream &s, const Path &p);
+std::ostream& operator <<(std::ostream &s, const Paths &p);
+
+//------------------------------------------------------------------------------
+
+#ifdef CLIPPERLIB_USE_XYZ
+typedef std::function<void(const IntPoint& e1bot, const IntPoint& e1top, const IntPoint& e2bot, const IntPoint& e2top, IntPoint& pt)> ZFillCallback;
+#endif
+
+enum InitOptions {ioReverseSolution = 1, ioStrictlySimple = 2, ioPreserveCollinear = 4};
+enum JoinType {jtSquare, jtRound, jtMiter};
+enum EndType {etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound};
+
+class PolyNode;
+typedef std::vector< PolyNode* > PolyNodes;
+
+class PolyNode 
+{ 
+public:
+    PolyNode() : Childs(), Parent(0), Index(0), m_IsOpen(false) {}
+    virtual ~PolyNode(){};
+    Path Contour;
+    PolyNodes Childs;
+    PolyNode* Parent;
+    // Traversal of the polygon tree in a depth first fashion.
+    PolyNode* GetNext() const { return Childs.empty() ? GetNextSiblingUp() : Childs.front(); }
+    bool IsHole() const;
+    bool IsOpen() const { return m_IsOpen; }  
+    int  ChildCount() const { return (int)Childs.size(); }
+private:
+    unsigned Index; //node index in Parent.Childs
+    bool m_IsOpen;
+    JoinType m_jointype;
+    EndType m_endtype;
+    PolyNode* GetNextSiblingUp() const { return Parent ? ((Index == Parent->Childs.size() - 1) ? Parent->GetNextSiblingUp() : Parent->Childs[Index + 1]) : nullptr; }
+    void AddChild(PolyNode& child);
+    friend class Clipper; //to access Index
+    friend class ClipperOffset;
+    friend class PolyTree; //to implement the PolyTree::move operator
+};
+
+class PolyTree: public PolyNode
+{ 
+public:
+    PolyTree() {}
+    PolyTree(PolyTree &&src) { *this = std::move(src); }
+    virtual ~PolyTree(){Clear();};
+    PolyTree& operator=(PolyTree &&src) { 
+        AllNodes   = std::move(src.AllNodes);
+        Contour    = std::move(src.Contour);
+        Childs     = std::move(src.Childs);
+        Parent     = nullptr;
+        Index      = src.Index;
+        m_IsOpen   = src.m_IsOpen;
+        m_jointype = src.m_jointype;
+        m_endtype  = src.m_endtype;
+        for (size_t i = 0; i < Childs.size(); ++ i)
+          Childs[i]->Parent = this;
+        return *this; 
+    }
+    PolyNode* GetFirst() const { return Childs.empty() ? nullptr : Childs.front(); }
+    void Clear() {  AllNodes.clear(); Childs.clear(); }
+    int Total() const;
+    void RemoveOutermostPolygon();
+private:
+    PolyTree(const PolyTree &src) = delete;
+    PolyTree& operator=(const PolyTree &src) = delete;
+    std::vector<PolyNode> AllNodes;
+    friend class Clipper; //to access AllNodes
+};
+
+double Area(const Path &poly);
+inline bool Orientation(const Path &poly) { return Area(poly) >= 0; }
+int PointInPolygon(const IntPoint &pt, const Path &path);
+
+Paths SimplifyPolygon(const Path &in_poly, PolyFillType fillType = pftEvenOdd);
+
+void CleanPolygon(const Path& in_poly, Path& out_poly, double distance = 1.415);
+void CleanPolygon(Path& poly, double distance = 1.415);
+void CleanPolygons(const Paths& in_polys, Paths& out_polys, double distance = 1.415);
+void CleanPolygons(Paths& polys, double distance = 1.415);
+
+void MinkowskiSum(const Path& pattern, const Path& path, Paths& solution, bool pathIsClosed);
+void MinkowskiSum(const Path& pattern, const Paths& paths, Paths& solution, bool pathIsClosed);
+void MinkowskiDiff(const Path& poly1, const Path& poly2, Paths& solution);
+
+void PolyTreeToPaths(const PolyTree& polytree, Paths& paths);
+void ClosedPathsFromPolyTree(const PolyTree& polytree, Paths& paths);
+void OpenPathsFromPolyTree(PolyTree& polytree, Paths& paths);
+
+void ReversePath(Path& p);
+void ReversePaths(Paths& p);
+
+struct IntRect { cInt left; cInt top; cInt right; cInt bottom; };
+
+//enums that are used internally ...
+enum EdgeSide { esLeft = 1, esRight = 2};
+
+// namespace Internal {
+  //forward declarations (for stuff used internally) ...
+  struct TEdge {
+    // Bottom point of this edge (with minimum Y).
+    IntPoint Bot;
+    // Current position.
+    IntPoint Curr;
+    // Top point of this edge (with maximum Y).
+    IntPoint Top;
+    // Vector from Bot to Top.
+    IntPoint Delta;
+    // Slope (dx/dy). For horiontal edges, the slope is set to HORIZONTAL (-1.0E+40).
+    double Dx;
+    PolyType PolyTyp;
+    EdgeSide Side;
+    // Winding number delta. 1 or -1 depending on winding direction, 0 for open paths and flat closed paths.
+    int WindDelta;
+    int WindCnt;
+    int WindCnt2; //winding count of the opposite polytype
+    int OutIdx;
+    // Next edge in the input path.
+    TEdge *Next;
+    // Previous edge in the input path.
+    TEdge *Prev;
+    // Next edge in the Local Minima List chain.
+    TEdge *NextInLML;
+    TEdge *NextInAEL;
+    TEdge *PrevInAEL;
+    TEdge *NextInSEL;
+    TEdge *PrevInSEL;
+  };
+
+  struct IntersectNode {
+    IntersectNode(TEdge *Edge1, TEdge *Edge2, IntPoint Pt) :
+      Edge1(Edge1), Edge2(Edge2), Pt(Pt) {}
+    TEdge          *Edge1;
+    TEdge          *Edge2;
+    IntPoint        Pt;
+  };
+
+  struct LocalMinimum {
+    cInt          Y;
+    TEdge        *LeftBound;
+    TEdge        *RightBound;
+  };
+
+  // Point of an output polygon.
+  // 36B on 64bit system without CLIPPERLIB_USE_XYZ.
+  struct OutPt {
+    // 4B
+    int       Idx;
+    // 16B without CLIPPERLIB_USE_XYZ / 24B with CLIPPERLIB_USE_XYZ
+    IntPoint  Pt;
+    // 4B on 32bit system, 8B on 64bit system
+    OutPt    *Next;
+    // 4B on 32bit system, 8B on 64bit system
+    OutPt    *Prev;
+  };
+
+  struct OutRec;
+  struct Join {
+    Join(OutPt *OutPt1, OutPt *OutPt2, IntPoint OffPt) :
+      OutPt1(OutPt1), OutPt2(OutPt2), OffPt(OffPt) {}
+    OutPt    *OutPt1;
+    OutPt    *OutPt2;
+    IntPoint  OffPt;
+  };
+// }; // namespace Internal
+
+//------------------------------------------------------------------------------
+
+//ClipperBase is the ancestor to the Clipper class. It should not be
+//instantiated directly. This class simply abstracts the conversion of sets of
+//polygon coordinates into edge objects that are stored in a LocalMinima list.
+class ClipperBase
+{
+public:
+  ClipperBase() : 
+#ifndef CLIPPERLIB_INT32
+    m_UseFullRange(false), 
+#endif // CLIPPERLIB_INT32
+    m_HasOpenPaths(false) {}
+  ~ClipperBase() { Clear(); }
+  bool AddPath(const Path &pg, PolyType PolyTyp, bool Closed);
+
+  template<typename PathsProvider>
+  bool AddPaths(PathsProvider &&paths_provider, PolyType PolyTyp, bool Closed)
+  {
+    size_t num_paths = paths_provider.size();
+    if (num_paths == 0)
+        return false;
+    if (num_paths == 1)
+        return AddPath(*paths_provider.begin(), PolyTyp, Closed);
+
+    std::vector<int> num_edges(num_paths, 0);
+    int num_edges_total = 0;
+    size_t i = 0;
+    for (const Path &pg : paths_provider) {
+      // Remove duplicate end point from a closed input path.
+      // Remove duplicate points from the end of the input path.
+      int highI = (int)pg.size() -1;
+      if (Closed) 
+        while (highI > 0 && (pg[highI] == pg[0])) 
+          --highI;
+      while (highI > 0 && (pg[highI] == pg[highI -1])) 
+        --highI;
+      if ((Closed && highI < 2) || (!Closed && highI < 1))
+        highI = -1;
+      num_edges[i ++] = highI + 1;
+      num_edges_total += highI + 1;
+    }
+    if (num_edges_total == 0)
+      return false;
+
+    // Allocate a new edge array.
+    std::vector<TEdge> edges(num_edges_total);
+    // Fill in the edge array.
+    bool result = false;
+    TEdge *p_edge = edges.data();
+    i = 0;
+    for (const Path &pg : paths_provider) {
+      if (num_edges[i]) {
+        bool res = AddPathInternal(pg, num_edges[i] - 1, PolyTyp, Closed, p_edge);
+        if (res) {
+          p_edge += num_edges[i];
+          result = true;
+        }
+      }
+      ++ i;
+    }
+    if (result)
+      // At least some edges were generated. Remember the edge array.
+      m_edges.emplace_back(std::move(edges));
+    return result;
+  }
+
+  void Clear();
+  IntRect GetBounds();
+  // By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before clipping.
+  // When enabled the PreserveCollinear property prevents this default behavior to allow these inner vertices to appear in the solution.
+  bool PreserveCollinear() const {return m_PreserveCollinear;};
+  void PreserveCollinear(bool value) {m_PreserveCollinear = value;};
+protected:
+  bool AddPathInternal(const Path &pg, int highI, PolyType PolyTyp, bool Closed, TEdge* edges);
+  TEdge* AddBoundsToLML(TEdge *e, bool IsClosed);
+  void Reset();
+  TEdge* ProcessBound(TEdge* E, bool IsClockwise);
+  TEdge* DescendToMin(TEdge *&E);
+  void AscendToMax(TEdge *&E, bool Appending, bool IsClosed);
+
+  // Local minima (Y, left edge, right edge) sorted by ascending Y.
+  std::vector<LocalMinimum> m_MinimaList;
+
+#ifdef CLIPPERLIB_INT32
+  static constexpr const bool m_UseFullRange = false;
+#else // CLIPPERLIB_INT32
+  // True if the input polygons have abs values higher than loRange, but lower than hiRange.
+  // False if the input polygons have abs values lower or equal to loRange.
+  bool              m_UseFullRange;
+#endif // CLIPPERLIB_INT32
+
+  // A vector of edges per each input path.
+  std::vector<std::vector<TEdge>> m_edges;
+  // Don't remove intermediate vertices of a collinear sequence of points.
+  bool             m_PreserveCollinear;
+  // Is any of the paths inserted by AddPath() or AddPaths() open?
+  bool             m_HasOpenPaths;
+};
+//------------------------------------------------------------------------------
+
+class Clipper : public ClipperBase
+{
+public:
+  Clipper(int initOptions = 0);
+  ~Clipper() { Clear(); }
+  void Clear() { ClipperBase::Clear(); DisposeAllOutRecs(); }
+  bool Execute(ClipType clipType,
+      Paths &solution,
+      PolyFillType fillType = pftEvenOdd) 
+    { return Execute(clipType, solution, fillType, fillType); }
+  bool Execute(ClipType clipType,
+      Paths &solution,
+      PolyFillType subjFillType,
+      PolyFillType clipFillType);
+  bool Execute(ClipType clipType,
+      PolyTree &polytree,
+      PolyFillType fillType = pftEvenOdd)
+    { return Execute(clipType, polytree, fillType, fillType); }
+  bool Execute(ClipType clipType,
+      PolyTree &polytree,
+      PolyFillType subjFillType,
+      PolyFillType clipFillType);
+  bool ReverseSolution() const { return m_ReverseOutput; };
+  void ReverseSolution(bool value) {m_ReverseOutput = value;};
+  bool StrictlySimple() const {return m_StrictSimple;};
+  void StrictlySimple(bool value) {m_StrictSimple = value;};
+  //set the callback function for z value filling on intersections (otherwise Z is 0)
+#ifdef CLIPPERLIB_USE_XYZ
+  void ZFillFunction(ZFillCallback zFillFunc) { m_ZFill = zFillFunc; }
+#endif
+protected:
+  void Reset();
+  virtual bool ExecuteInternal();
+private:
+  
+  // Output polygons.
+  std::vector<OutRec*>  m_PolyOuts;
+  // Output points, allocated by a continuous sets of m_OutPtsChunkSize.
+  std::vector<OutPt*>   m_OutPts;
+  // List of free output points, to be used before taking a point from m_OutPts or allocating a new chunk.
+  OutPt                *m_OutPtsFree;
+  size_t                m_OutPtsChunkSize;
+  size_t                m_OutPtsChunkLast;
+
+  std::vector<Join>     m_Joins;
+  std::vector<Join>     m_GhostJoins;
+  std::vector<IntersectNode> m_IntersectList;
+  ClipType              m_ClipType;
+  // A priority queue (a binary heap) of Y coordinates.
+  std::priority_queue<cInt> m_Scanbeam;
+  // Maxima are collected by ProcessEdgesAtTopOfScanbeam(), consumed by ProcessHorizontal().
+  std::vector<cInt>     m_Maxima;
+  TEdge                *m_ActiveEdges;
+  TEdge                *m_SortedEdges;
+  PolyFillType          m_ClipFillType;
+  PolyFillType          m_SubjFillType;
+  bool                  m_ReverseOutput;
+  // Does the result go to a PolyTree or Paths?
+  bool                  m_UsingPolyTree; 
+  bool                  m_StrictSimple;
+#ifdef CLIPPERLIB_USE_XYZ
+  ZFillCallback         m_ZFill; //custom callback 
+#endif
+  void SetWindingCount(TEdge& edge) const;
+  bool IsEvenOddFillType(const TEdge& edge) const 
+    { return (edge.PolyTyp == ptSubject) ? m_SubjFillType == pftEvenOdd : m_ClipFillType == pftEvenOdd; }
+  bool IsEvenOddAltFillType(const TEdge& edge) const
+    { return (edge.PolyTyp == ptSubject) ? m_ClipFillType == pftEvenOdd : m_SubjFillType == pftEvenOdd; }
+  void InsertLocalMinimaIntoAEL(const cInt botY);
+  void InsertEdgeIntoAEL(TEdge *edge, TEdge* startEdge);
+  void AddEdgeToSEL(TEdge *edge);
+  void CopyAELToSEL();
+  void DeleteFromSEL(TEdge *e);
+  void DeleteFromAEL(TEdge *e);
+  void UpdateEdgeIntoAEL(TEdge *&e);
+  void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2);
+  bool IsContributing(const TEdge& edge) const;
+  bool IsTopHorz(const cInt XPos);
+  void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2);
+  void DoMaxima(TEdge *e);
+  void ProcessHorizontals();
+  void ProcessHorizontal(TEdge *horzEdge);
+  void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
+  OutPt* AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
+  OutRec* GetOutRec(int idx);
+  void AppendPolygon(TEdge *e1, TEdge *e2) const;
+  void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt);
+  OutRec* CreateOutRec();
+  OutPt* AddOutPt(TEdge *e, const IntPoint &pt);
+  OutPt* GetLastOutPt(TEdge *e);
+  OutPt* AllocateOutPt();
+  OutPt* DupOutPt(OutPt* outPt, bool InsertAfter);
+  // Add the point to a list of free points.
+  void DisposeOutPt(OutPt *pt) { pt->Next = m_OutPtsFree; m_OutPtsFree = pt; }
+  void DisposeOutPts(OutPt*& pp) { if (pp != nullptr) { pp->Prev->Next = m_OutPtsFree; m_OutPtsFree = pp; } }
+  void DisposeAllOutRecs();
+  bool ProcessIntersections(const cInt topY);
+  void BuildIntersectList(const cInt topY);
+  void ProcessEdgesAtTopOfScanbeam(const cInt topY);
+  void BuildResult(Paths& polys);
+  void BuildResult2(PolyTree& polytree);
+  void SetHoleState(TEdge *e, OutRec *outrec) const;
+  bool FixupIntersectionOrder();
+  void FixupOutPolygon(OutRec &outrec);
+  void FixupOutPolyline(OutRec &outrec);
+  bool FindOwnerFromSplitRecs(OutRec &outRec, OutRec *&currOrfl);
+  void FixHoleLinkage(OutRec &outrec);
+  bool JoinPoints(Join *j, OutRec* outRec1, OutRec* outRec2);
+  bool JoinHorz(OutPt* op1, OutPt* op1b, OutPt* op2, OutPt* op2b, const IntPoint &Pt, bool DiscardLeft);
+  void JoinCommonEdges();
+  void DoSimplePolygons();
+  void FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec) const;
+  void FixupFirstLefts2(OutRec* OldOutRec, OutRec* NewOutRec) const;
+#ifdef CLIPPERLIB_USE_XYZ
+  void SetZ(IntPoint& pt, TEdge& e1, TEdge& e2);
+#endif
+};
+//------------------------------------------------------------------------------
+
+class ClipperOffset 
+{
+public:
+  ClipperOffset(double miterLimit = 2.0, double roundPrecision = 0.25, double shortestEdgeLength = 0.) :
+    MiterLimit(miterLimit), ArcTolerance(roundPrecision), ShortestEdgeLength(shortestEdgeLength), m_lowest(-1, 0) {}
+  ~ClipperOffset() { Clear(); }
+  void AddPath(const Path& path, JoinType joinType, EndType endType);
+  template<typename PathsProvider>
+  void AddPaths(PathsProvider &&paths, JoinType joinType, EndType endType) {
+    for (const Path &path : paths)
+      AddPath(path, joinType, endType);
+  }
+  void Execute(Paths& solution, double delta);
+  void Execute(PolyTree& solution, double delta);
+  void Clear();
+  double MiterLimit;
+  double ArcTolerance;
+  double ShortestEdgeLength;
+
+private:
+  Paths m_destPolys;
+  Path m_srcPoly;
+  Path m_destPoly;
+  std::vector<DoublePoint> m_normals;
+  double m_delta, m_sinA, m_sin, m_cos;
+  double m_miterLim, m_StepsPerRad;
+  // x: index of the lowest contour in m_polyNodes
+  // y: index of the lowest point in the lowest contour
+  IntPoint m_lowest;
+  PolyNode m_polyNodes;
+
+  void FixOrientations();
+  void DoOffset(double delta);
+  void OffsetPoint(int j, int& k, JoinType jointype);
+  void DoSquare(int j, int k);
+  void DoMiter(int j, int k, double r);
+  void DoRound(int j, int k);
+};
+//------------------------------------------------------------------------------
+
+class clipperException : public std::exception
+{
+  public:
+    clipperException(const char* description): m_descr(description) {}
+    virtual ~clipperException() throw() {}
+    virtual const char* what() const throw() {return m_descr.c_str();}
+  private:
+    std::string m_descr;
+};
+//------------------------------------------------------------------------------
+
+template<typename PathsProvider>
+inline Paths SimplifyPolygons(PathsProvider &&in_polys, PolyFillType fillType = pftEvenOdd) {
+    Clipper c;
+    c.StrictlySimple(true);
+    c.AddPaths(std::forward<PathsProvider>(in_polys), ptSubject, true);
+    Paths out;
+    c.Execute(ctUnion, out, fillType, fillType);
+    return out;
+}
+
+} //ClipperLib namespace
+
+#ifdef CLIPPERLIB_NAMESPACE_PREFIX
+} // namespace CLIPPERLIB_NAMESPACE_PREFIX
+#endif // CLIPPERLIB_NAMESPACE_PREFIX
+
+#endif //clipper_hpp

src/clipper/clipper_z.cpp

@@ -0,0 +1,7 @@
+// Hackish wrapper around the ClipperLib library to compile the Clipper library with the Z support.
+
+// Enable the Z coordinate support.
+#define CLIPPERLIB_USE_XYZ
+
+// and let it compile
+#include "clipper.cpp"

src/clipper/clipper_z.hpp

@@ -0,0 +1,18 @@
+// Hackish wrapper around the ClipperLib library to compile the Clipper library with the Z support.
+
+#ifndef clipper_z_hpp
+#ifdef clipper_hpp
+#error "You should include clipper_z.hpp before clipper.hpp"
+#endif
+
+#define clipper_z_hpp
+
+// Enable the Z coordinate support.
+#define CLIPPERLIB_USE_XYZ
+
+#include "clipper.hpp"
+
+#undef clipper_hpp
+#undef CLIPPERLIB_USE_XYZ
+
+#endif // clipper_z_hpp

src/eigen/COPYING.README

@@ -0,0 +1,18 @@
+Eigen is primarily MPL2 licensed. See COPYING.MPL2 and these links:
+  http://www.mozilla.org/MPL/2.0/
+  http://www.mozilla.org/MPL/2.0/FAQ.html
+
+Some files contain third-party code under BSD or LGPL licenses, whence the other
+COPYING.* files here.
+
+All the LGPL code is either LGPL 2.1-only, or LGPL 2.1-or-later.
+For this reason, the COPYING.LGPL file contains the LGPL 2.1 text.
+
+If you want to guarantee that the Eigen code that you are #including is licensed
+under the MPL2 and possibly more permissive licenses (like BSD), #define this
+preprocessor symbol:
+  EIGEN_MPL2_ONLY
+For example, with most compilers, you could add this to your project CXXFLAGS:
+  -DEIGEN_MPL2_ONLY
+This will cause a compilation error to be generated if you #include any code that is
+LGPL licensed.

src/eigen/Eigen/CMakeLists.txt

@@ -0,0 +1,19 @@
+include(RegexUtils)
+test_escape_string_as_regex()
+
+file(GLOB Eigen_directory_files "*")
+
+escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+
+foreach(f ${Eigen_directory_files})
+  if(NOT f MATCHES "\\.txt" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/src")
+    list(APPEND Eigen_directory_files_to_install ${f})
+  endif()
+endforeach(f ${Eigen_directory_files})
+
+install(FILES
+  ${Eigen_directory_files_to_install}
+  DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen COMPONENT Devel
+  )
+
+install(DIRECTORY src DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen COMPONENT Devel FILES_MATCHING PATTERN "*.h")

src/eigen/Eigen/Cholesky

@@ -0,0 +1,46 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CHOLESKY_MODULE_H
+#define EIGEN_CHOLESKY_MODULE_H
+
+#include "Core"
+#include "Jacobi"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Cholesky_Module Cholesky module
+  *
+  *
+  *
+  * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.
+  * Those decompositions are also accessible via the following methods:
+  *  - MatrixBase::llt()
+  *  - MatrixBase::ldlt()
+  *  - SelfAdjointView::llt()
+  *  - SelfAdjointView::ldlt()
+  *
+  * \code
+  * #include <Eigen/Cholesky>
+  * \endcode
+  */
+
+#include "src/Cholesky/LLT.h"
+#include "src/Cholesky/LDLT.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/Cholesky/LLT_LAPACKE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_CHOLESKY_MODULE_H
+/* vim: set filetype=cpp et sw=2 ts=2 ai: */

src/eigen/Eigen/CholmodSupport

@@ -0,0 +1,48 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CHOLMODSUPPORT_MODULE_H
+#define EIGEN_CHOLMODSUPPORT_MODULE_H
+
+#include "SparseCore"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+extern "C" {
+  #include <cholmod.h>
+}
+
+/** \ingroup Support_modules
+  * \defgroup CholmodSupport_Module CholmodSupport module
+  *
+  * This module provides an interface to the Cholmod library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
+  * It provides the two following main factorization classes:
+  * - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization.
+  * - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial).
+  *
+  * For the sake of completeness, this module also propose the two following classes:
+  * - class CholmodSimplicialLLT
+  * - class CholmodSimplicialLDLT
+  * Note that these classes does not bring any particular advantage compared to the built-in
+  * SimplicialLLT and SimplicialLDLT factorization classes.
+  *
+  * \code
+  * #include <Eigen/CholmodSupport>
+  * \endcode
+  *
+  * In order to use this module, the cholmod headers must be accessible from the include paths, and your binary must be linked to the cholmod library and its dependencies.
+  * The dependencies depend on how cholmod has been compiled.
+  * For a cmake based project, you can use our FindCholmod.cmake module to help you in this task.
+  *
+  */
+
+#include "src/CholmodSupport/CholmodSupport.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_CHOLMODSUPPORT_MODULE_H
+

src/eigen/Eigen/Core

@@ -0,0 +1,537 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+// Copyright (C) 2007-2011 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_CORE_H
+#define EIGEN_CORE_H
+
+// first thing Eigen does: stop the compiler from committing suicide
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#if defined(__CUDACC__) && !defined(EIGEN_NO_CUDA)
+  #define EIGEN_CUDACC __CUDACC__
+#endif
+
+#if defined(__CUDA_ARCH__) && !defined(EIGEN_NO_CUDA)
+  #define EIGEN_CUDA_ARCH __CUDA_ARCH__
+#endif
+
+#if defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 9)
+#define EIGEN_CUDACC_VER  ((__CUDACC_VER_MAJOR__ * 10000) + (__CUDACC_VER_MINOR__ * 100))
+#elif defined(__CUDACC_VER__)
+#define EIGEN_CUDACC_VER __CUDACC_VER__
+#else
+#define EIGEN_CUDACC_VER 0
+#endif
+
+// Handle NVCC/CUDA/SYCL
+#if defined(__CUDACC__) || defined(__SYCL_DEVICE_ONLY__)
+  // Do not try asserts on CUDA and SYCL!
+  #ifndef EIGEN_NO_DEBUG
+  #define EIGEN_NO_DEBUG
+  #endif
+
+  #ifdef EIGEN_INTERNAL_DEBUGGING
+  #undef EIGEN_INTERNAL_DEBUGGING
+  #endif
+
+  #ifdef EIGEN_EXCEPTIONS
+  #undef EIGEN_EXCEPTIONS
+  #endif
+
+  // All functions callable from CUDA code must be qualified with __device__
+  #ifdef __CUDACC__
+    // Do not try to vectorize on CUDA and SYCL!
+    #ifndef EIGEN_DONT_VECTORIZE
+    #define EIGEN_DONT_VECTORIZE
+    #endif
+
+    #define EIGEN_DEVICE_FUNC __host__ __device__
+    // We need cuda_runtime.h to ensure that that EIGEN_USING_STD_MATH macro
+    // works properly on the device side
+    #include <cuda_runtime.h>
+  #else
+    #define EIGEN_DEVICE_FUNC
+  #endif
+
+#else
+  #define EIGEN_DEVICE_FUNC
+
+#endif
+
+// When compiling CUDA device code with NVCC, pull in math functions from the
+// global namespace.  In host mode, and when device doee with clang, use the
+// std versions.
+#if defined(__CUDA_ARCH__) && defined(__NVCC__)
+  #define EIGEN_USING_STD_MATH(FUNC) using ::FUNC;
+#else
+  #define EIGEN_USING_STD_MATH(FUNC) using std::FUNC;
+#endif
+
+#if (defined(_CPPUNWIND) || defined(__EXCEPTIONS)) && !defined(__CUDA_ARCH__) && !defined(EIGEN_EXCEPTIONS) && !defined(EIGEN_USE_SYCL)
+  #define EIGEN_EXCEPTIONS
+#endif
+
+#ifdef EIGEN_EXCEPTIONS
+  #include <new>
+#endif
+
+// then include this file where all our macros are defined. It's really important to do it first because
+// it's where we do all the alignment settings (platform detection and honoring the user's will if he
+// defined e.g. EIGEN_DONT_ALIGN) so it needs to be done before we do anything with vectorization.
+#include "src/Core/util/Macros.h"
+
+// Disable the ipa-cp-clone optimization flag with MinGW 6.x or newer (enabled by default with -O3)
+// See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556 for details.
+#if EIGEN_COMP_MINGW && EIGEN_GNUC_AT_LEAST(4,6)
+  #pragma GCC optimize ("-fno-ipa-cp-clone")
+#endif
+
+#include <complex>
+
+// this include file manages BLAS and MKL related macros
+// and inclusion of their respective header files
+#include "src/Core/util/MKL_support.h"
+
+// if alignment is disabled, then disable vectorization. Note: EIGEN_MAX_ALIGN_BYTES is the proper check, it takes into
+// account both the user's will (EIGEN_MAX_ALIGN_BYTES,EIGEN_DONT_ALIGN) and our own platform checks
+#if EIGEN_MAX_ALIGN_BYTES==0
+  #ifndef EIGEN_DONT_VECTORIZE
+    #define EIGEN_DONT_VECTORIZE
+  #endif
+#endif
+
+#if EIGEN_COMP_MSVC
+  #include <malloc.h> // for _aligned_malloc -- need it regardless of whether vectorization is enabled
+  #if (EIGEN_COMP_MSVC >= 1500) // 2008 or later
+    // Remember that usage of defined() in a #define is undefined by the standard.
+    // a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP.
+    #if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || EIGEN_ARCH_x86_64
+      #define EIGEN_SSE2_ON_MSVC_2008_OR_LATER
+    #endif
+  #endif
+#else
+  // Remember that usage of defined() in a #define is undefined by the standard
+  #if (defined __SSE2__) && ( (!EIGEN_COMP_GNUC) || EIGEN_COMP_ICC || EIGEN_GNUC_AT_LEAST(4,2) )
+    #define EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC
+  #endif
+#endif
+
+#ifndef EIGEN_DONT_VECTORIZE
+
+  #if defined (EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC) || defined(EIGEN_SSE2_ON_MSVC_2008_OR_LATER)
+
+    // Defines symbols for compile-time detection of which instructions are
+    // used.
+    // EIGEN_VECTORIZE_YY is defined if and only if the instruction set YY is used
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_SSE
+    #define EIGEN_VECTORIZE_SSE2
+
+    // Detect sse3/ssse3/sse4:
+    // gcc and icc defines __SSE3__, ...
+    // there is no way to know about this on msvc. You can define EIGEN_VECTORIZE_SSE* if you
+    // want to force the use of those instructions with msvc.
+    #ifdef __SSE3__
+      #define EIGEN_VECTORIZE_SSE3
+    #endif
+    #ifdef __SSSE3__
+      #define EIGEN_VECTORIZE_SSSE3
+    #endif
+    #ifdef __SSE4_1__
+      #define EIGEN_VECTORIZE_SSE4_1
+    #endif
+    #ifdef __SSE4_2__
+      #define EIGEN_VECTORIZE_SSE4_2
+    #endif
+    #ifdef __AVX__
+      #define EIGEN_VECTORIZE_AVX
+      #define EIGEN_VECTORIZE_SSE3
+      #define EIGEN_VECTORIZE_SSSE3
+      #define EIGEN_VECTORIZE_SSE4_1
+      #define EIGEN_VECTORIZE_SSE4_2
+    #endif
+    #ifdef __AVX2__
+      #define EIGEN_VECTORIZE_AVX2
+    #endif
+    #ifdef __FMA__
+      #define EIGEN_VECTORIZE_FMA
+    #endif
+    #if defined(__AVX512F__) && defined(EIGEN_ENABLE_AVX512)
+      #define EIGEN_VECTORIZE_AVX512
+      #define EIGEN_VECTORIZE_AVX2
+      #define EIGEN_VECTORIZE_AVX
+      #define EIGEN_VECTORIZE_FMA
+      #ifdef __AVX512DQ__
+        #define EIGEN_VECTORIZE_AVX512DQ
+      #endif
+      #ifdef __AVX512ER__
+        #define EIGEN_VECTORIZE_AVX512ER
+      #endif
+    #endif
+
+    // include files
+
+    // This extern "C" works around a MINGW-w64 compilation issue
+    // https://sourceforge.net/tracker/index.php?func=detail&aid=3018394&group_id=202880&atid=983354
+    // In essence, intrin.h is included by windows.h and also declares intrinsics (just as emmintrin.h etc. below do).
+    // However, intrin.h uses an extern "C" declaration, and g++ thus complains of duplicate declarations
+    // with conflicting linkage.  The linkage for intrinsics doesn't matter, but at that stage the compiler doesn't know;
+    // so, to avoid compile errors when windows.h is included after Eigen/Core, ensure intrinsics are extern "C" here too.
+    // notice that since these are C headers, the extern "C" is theoretically needed anyways.
+    extern "C" {
+      // In theory we should only include immintrin.h and not the other *mmintrin.h header files directly.
+      // Doing so triggers some issues with ICC. However old gcc versions seems to not have this file, thus:
+      #if EIGEN_COMP_ICC >= 1110
+        #include <immintrin.h>
+      #else
+        #include <mmintrin.h>
+        #include <emmintrin.h>
+        #include <xmmintrin.h>
+        #ifdef  EIGEN_VECTORIZE_SSE3
+        #include <pmmintrin.h>
+        #endif
+        #ifdef EIGEN_VECTORIZE_SSSE3
+        #include <tmmintrin.h>
+        #endif
+        #ifdef EIGEN_VECTORIZE_SSE4_1
+        #include <smmintrin.h>
+        #endif
+        #ifdef EIGEN_VECTORIZE_SSE4_2
+        #include <nmmintrin.h>
+        #endif
+        #if defined(EIGEN_VECTORIZE_AVX) || defined(EIGEN_VECTORIZE_AVX512)
+        #include <immintrin.h>
+        #endif
+      #endif
+    } // end extern "C"
+  #elif defined __VSX__
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_VSX
+    #include <altivec.h>
+    // We need to #undef all these ugly tokens defined in <altivec.h>
+    // => use __vector instead of vector
+    #undef bool
+    #undef vector
+    #undef pixel
+  #elif defined __ALTIVEC__
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_ALTIVEC
+    #include <altivec.h>
+    // We need to #undef all these ugly tokens defined in <altivec.h>
+    // => use __vector instead of vector
+    #undef bool
+    #undef vector
+    #undef pixel
+  #elif (defined  __ARM_NEON) || (defined __ARM_NEON__)
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_NEON
+    #include <arm_neon.h>
+  #elif (defined __s390x__ && defined __VEC__)
+    #define EIGEN_VECTORIZE
+    #define EIGEN_VECTORIZE_ZVECTOR
+    #include <vecintrin.h>
+  #endif
+#endif
+
+#if defined(__F16C__) && !defined(EIGEN_COMP_CLANG)
+  // We can use the optimized fp16 to float and float to fp16 conversion routines
+  #define EIGEN_HAS_FP16_C
+#endif
+
+#if defined __CUDACC__
+  #define EIGEN_VECTORIZE_CUDA
+  #include <vector_types.h>
+  #if EIGEN_CUDACC_VER >= 70500
+    #define EIGEN_HAS_CUDA_FP16
+  #endif
+#endif
+
+#if defined EIGEN_HAS_CUDA_FP16
+  #include <host_defines.h>
+  #include <cuda_fp16.h>
+#endif
+
+#if (defined _OPENMP) && (!defined EIGEN_DONT_PARALLELIZE)
+  #define EIGEN_HAS_OPENMP
+#endif
+
+#ifdef EIGEN_HAS_OPENMP
+#include <omp.h>
+#endif
+
+// MSVC for windows mobile does not have the errno.h file
+#if !(EIGEN_COMP_MSVC && EIGEN_OS_WINCE) && !EIGEN_COMP_ARM
+#define EIGEN_HAS_ERRNO
+#endif
+
+#ifdef EIGEN_HAS_ERRNO
+#include <cerrno>
+#endif
+#include <cstddef>
+#include <cstdlib>
+#include <cmath>
+#include <cassert>
+#include <functional>
+#include <iosfwd>
+#include <cstring>
+#include <string>
+#include <limits>
+#include <climits> // for CHAR_BIT
+// for min/max:
+#include <algorithm>
+
+// for std::is_nothrow_move_assignable
+#ifdef EIGEN_INCLUDE_TYPE_TRAITS
+#include <type_traits>
+#endif
+
+// for outputting debug info
+#ifdef EIGEN_DEBUG_ASSIGN
+#include <iostream>
+#endif
+
+// required for __cpuid, needs to be included after cmath
+#if EIGEN_COMP_MSVC && EIGEN_ARCH_i386_OR_x86_64 && !EIGEN_OS_WINCE
+  #include <intrin.h>
+#endif
+
+/** \brief Namespace containing all symbols from the %Eigen library. */
+namespace Eigen {
+
+inline static const char *SimdInstructionSetsInUse(void) {
+#if defined(EIGEN_VECTORIZE_AVX512)
+  return "AVX512, FMA, AVX2, AVX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
+#elif defined(EIGEN_VECTORIZE_AVX)
+  return "AVX SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
+#elif defined(EIGEN_VECTORIZE_SSE4_2)
+  return "SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
+#elif defined(EIGEN_VECTORIZE_SSE4_1)
+  return "SSE, SSE2, SSE3, SSSE3, SSE4.1";
+#elif defined(EIGEN_VECTORIZE_SSSE3)
+  return "SSE, SSE2, SSE3, SSSE3";
+#elif defined(EIGEN_VECTORIZE_SSE3)
+  return "SSE, SSE2, SSE3";
+#elif defined(EIGEN_VECTORIZE_SSE2)
+  return "SSE, SSE2";
+#elif defined(EIGEN_VECTORIZE_ALTIVEC)
+  return "AltiVec";
+#elif defined(EIGEN_VECTORIZE_VSX)
+  return "VSX";
+#elif defined(EIGEN_VECTORIZE_NEON)
+  return "ARM NEON";
+#elif defined(EIGEN_VECTORIZE_ZVECTOR)
+  return "S390X ZVECTOR";
+#else
+  return "None";
+#endif
+}
+
+} // end namespace Eigen
+
+#if defined EIGEN2_SUPPORT_STAGE40_FULL_EIGEN3_STRICTNESS || defined EIGEN2_SUPPORT_STAGE30_FULL_EIGEN3_API || defined EIGEN2_SUPPORT_STAGE20_RESOLVE_API_CONFLICTS || defined EIGEN2_SUPPORT_STAGE10_FULL_EIGEN2_API || defined EIGEN2_SUPPORT
+// This will generate an error message:
+#error Eigen2-support is only available up to version 3.2. Please go to "http://eigen.tuxfamily.org/index.php?title=Eigen2" for further information
+#endif
+
+namespace Eigen {
+
+// we use size_t frequently and we'll never remember to prepend it with std:: everytime just to
+// ensure QNX/QCC support
+using std::size_t;
+// gcc 4.6.0 wants std:: for ptrdiff_t
+using std::ptrdiff_t;
+
+}
+
+/** \defgroup Core_Module Core module
+  * This is the main module of Eigen providing dense matrix and vector support
+  * (both fixed and dynamic size) with all the features corresponding to a BLAS library
+  * and much more...
+  *
+  * \code
+  * #include <Eigen/Core>
+  * \endcode
+  */
+
+#include "src/Core/util/Constants.h"
+#include "src/Core/util/Meta.h"
+#include "src/Core/util/ForwardDeclarations.h"
+#include "src/Core/util/StaticAssert.h"
+#include "src/Core/util/XprHelper.h"
+#include "src/Core/util/Memory.h"
+
+#include "src/Core/NumTraits.h"
+#include "src/Core/MathFunctions.h"
+#include "src/Core/GenericPacketMath.h"
+#include "src/Core/MathFunctionsImpl.h"
+#include "src/Core/arch/Default/ConjHelper.h"
+
+#if defined EIGEN_VECTORIZE_AVX512
+  #include "src/Core/arch/SSE/PacketMath.h"
+  #include "src/Core/arch/AVX/PacketMath.h"
+  #include "src/Core/arch/AVX512/PacketMath.h"
+  #include "src/Core/arch/AVX512/MathFunctions.h"
+#elif defined EIGEN_VECTORIZE_AVX
+  // Use AVX for floats and doubles, SSE for integers
+  #include "src/Core/arch/SSE/PacketMath.h"
+  #include "src/Core/arch/SSE/Complex.h"
+  #include "src/Core/arch/SSE/MathFunctions.h"
+  #include "src/Core/arch/AVX/PacketMath.h"
+  #include "src/Core/arch/AVX/MathFunctions.h"
+  #include "src/Core/arch/AVX/Complex.h"
+  #include "src/Core/arch/AVX/TypeCasting.h"
+  #include "src/Core/arch/SSE/TypeCasting.h"
+#elif defined EIGEN_VECTORIZE_SSE
+  #include "src/Core/arch/SSE/PacketMath.h"
+  #include "src/Core/arch/SSE/MathFunctions.h"
+  #include "src/Core/arch/SSE/Complex.h"
+  #include "src/Core/arch/SSE/TypeCasting.h"
+#elif defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)
+  #include "src/Core/arch/AltiVec/PacketMath.h"
+  #include "src/Core/arch/AltiVec/MathFunctions.h"
+  #include "src/Core/arch/AltiVec/Complex.h"
+#elif defined EIGEN_VECTORIZE_NEON
+  #include "src/Core/arch/NEON/PacketMath.h"
+  #include "src/Core/arch/NEON/MathFunctions.h"
+  #include "src/Core/arch/NEON/Complex.h"
+#elif defined EIGEN_VECTORIZE_ZVECTOR
+  #include "src/Core/arch/ZVector/PacketMath.h"
+  #include "src/Core/arch/ZVector/MathFunctions.h"
+  #include "src/Core/arch/ZVector/Complex.h"
+#endif
+
+// Half float support
+#include "src/Core/arch/CUDA/Half.h"
+#include "src/Core/arch/CUDA/PacketMathHalf.h"
+#include "src/Core/arch/CUDA/TypeCasting.h"
+
+#if defined EIGEN_VECTORIZE_CUDA
+  #include "src/Core/arch/CUDA/PacketMath.h"
+  #include "src/Core/arch/CUDA/MathFunctions.h"
+#endif
+
+#include "src/Core/arch/Default/Settings.h"
+
+#include "src/Core/functors/TernaryFunctors.h"
+#include "src/Core/functors/BinaryFunctors.h"
+#include "src/Core/functors/UnaryFunctors.h"
+#include "src/Core/functors/NullaryFunctors.h"
+#include "src/Core/functors/StlFunctors.h"
+#include "src/Core/functors/AssignmentFunctors.h"
+
+// Specialized functors to enable the processing of complex numbers
+// on CUDA devices
+#include "src/Core/arch/CUDA/Complex.h"
+
+#include "src/Core/IO.h"
+#include "src/Core/DenseCoeffsBase.h"
+#include "src/Core/DenseBase.h"
+#include "src/Core/MatrixBase.h"
+#include "src/Core/EigenBase.h"
+
+#include "src/Core/Product.h"
+#include "src/Core/CoreEvaluators.h"
+#include "src/Core/AssignEvaluator.h"
+
+#ifndef EIGEN_PARSED_BY_DOXYGEN // work around Doxygen bug triggered by Assign.h r814874
+                                // at least confirmed with Doxygen 1.5.5 and 1.5.6
+  #include "src/Core/Assign.h"
+#endif
+
+#include "src/Core/ArrayBase.h"
+#include "src/Core/util/BlasUtil.h"
+#include "src/Core/DenseStorage.h"
+#include "src/Core/NestByValue.h"
+
+// #include "src/Core/ForceAlignedAccess.h"
+
+#include "src/Core/ReturnByValue.h"
+#include "src/Core/NoAlias.h"
+#include "src/Core/PlainObjectBase.h"
+#include "src/Core/Matrix.h"
+#include "src/Core/Array.h"
+#include "src/Core/CwiseTernaryOp.h"
+#include "src/Core/CwiseBinaryOp.h"
+#include "src/Core/CwiseUnaryOp.h"
+#include "src/Core/CwiseNullaryOp.h"
+#include "src/Core/CwiseUnaryView.h"
+#include "src/Core/SelfCwiseBinaryOp.h"
+#include "src/Core/Dot.h"
+#include "src/Core/StableNorm.h"
+#include "src/Core/Stride.h"
+#include "src/Core/MapBase.h"
+#include "src/Core/Map.h"
+#include "src/Core/Ref.h"
+#include "src/Core/Block.h"
+#include "src/Core/VectorBlock.h"
+#include "src/Core/Transpose.h"
+#include "src/Core/DiagonalMatrix.h"
+#include "src/Core/Diagonal.h"
+#include "src/Core/DiagonalProduct.h"
+#include "src/Core/Redux.h"
+#include "src/Core/Visitor.h"
+#include "src/Core/Fuzzy.h"
+#include "src/Core/Swap.h"
+#include "src/Core/CommaInitializer.h"
+#include "src/Core/GeneralProduct.h"
+#include "src/Core/Solve.h"
+#include "src/Core/Inverse.h"
+#include "src/Core/SolverBase.h"
+#include "src/Core/PermutationMatrix.h"
+#include "src/Core/Transpositions.h"
+#include "src/Core/TriangularMatrix.h"
+#include "src/Core/SelfAdjointView.h"
+#include "src/Core/products/GeneralBlockPanelKernel.h"
+#include "src/Core/products/Parallelizer.h"
+#include "src/Core/ProductEvaluators.h"
+#include "src/Core/products/GeneralMatrixVector.h"
+#include "src/Core/products/GeneralMatrixMatrix.h"
+#include "src/Core/SolveTriangular.h"
+#include "src/Core/products/GeneralMatrixMatrixTriangular.h"
+#include "src/Core/products/SelfadjointMatrixVector.h"
+#include "src/Core/products/SelfadjointMatrixMatrix.h"
+#include "src/Core/products/SelfadjointProduct.h"
+#include "src/Core/products/SelfadjointRank2Update.h"
+#include "src/Core/products/TriangularMatrixVector.h"
+#include "src/Core/products/TriangularMatrixMatrix.h"
+#include "src/Core/products/TriangularSolverMatrix.h"
+#include "src/Core/products/TriangularSolverVector.h"
+#include "src/Core/BandMatrix.h"
+#include "src/Core/CoreIterators.h"
+#include "src/Core/ConditionEstimator.h"
+
+#include "src/Core/BooleanRedux.h"
+#include "src/Core/Select.h"
+#include "src/Core/VectorwiseOp.h"
+#include "src/Core/Random.h"
+#include "src/Core/Replicate.h"
+#include "src/Core/Reverse.h"
+#include "src/Core/ArrayWrapper.h"
+
+#ifdef EIGEN_USE_BLAS
+#include "src/Core/products/GeneralMatrixMatrix_BLAS.h"
+#include "src/Core/products/GeneralMatrixVector_BLAS.h"
+#include "src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h"
+#include "src/Core/products/SelfadjointMatrixMatrix_BLAS.h"
+#include "src/Core/products/SelfadjointMatrixVector_BLAS.h"
+#include "src/Core/products/TriangularMatrixMatrix_BLAS.h"
+#include "src/Core/products/TriangularMatrixVector_BLAS.h"
+#include "src/Core/products/TriangularSolverMatrix_BLAS.h"
+#endif // EIGEN_USE_BLAS
+
+#ifdef EIGEN_USE_MKL_VML
+#include "src/Core/Assign_MKL.h"
+#endif
+
+#include "src/Core/GlobalFunctions.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_CORE_H

src/eigen/Eigen/Dense

@@ -0,0 +1,7 @@
+#include "Core"
+#include "LU"
+#include "Cholesky"
+#include "QR"
+#include "SVD"
+#include "Geometry"
+#include "Eigenvalues"

src/eigen/Eigen/Eigen

@@ -0,0 +1,2 @@
+#include "Dense"
+#include "Sparse"

src/eigen/Eigen/Eigenvalues

@@ -0,0 +1,61 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_EIGENVALUES_MODULE_H
+#define EIGEN_EIGENVALUES_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#include "Cholesky"
+#include "Jacobi"
+#include "Householder"
+#include "LU"
+#include "Geometry"
+
+/** \defgroup Eigenvalues_Module Eigenvalues module
+  *
+  *
+  *
+  * This module mainly provides various eigenvalue solvers.
+  * This module also provides some MatrixBase methods, including:
+  *  - MatrixBase::eigenvalues(),
+  *  - MatrixBase::operatorNorm()
+  *
+  * \code
+  * #include <Eigen/Eigenvalues>
+  * \endcode
+  */
+
+#include "src/misc/RealSvd2x2.h"
+#include "src/Eigenvalues/Tridiagonalization.h"
+#include "src/Eigenvalues/RealSchur.h"
+#include "src/Eigenvalues/EigenSolver.h"
+#include "src/Eigenvalues/SelfAdjointEigenSolver.h"
+#include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h"
+#include "src/Eigenvalues/HessenbergDecomposition.h"
+#include "src/Eigenvalues/ComplexSchur.h"
+#include "src/Eigenvalues/ComplexEigenSolver.h"
+#include "src/Eigenvalues/RealQZ.h"
+#include "src/Eigenvalues/GeneralizedEigenSolver.h"
+#include "src/Eigenvalues/MatrixBaseEigenvalues.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/Eigenvalues/RealSchur_LAPACKE.h"
+#include "src/Eigenvalues/ComplexSchur_LAPACKE.h"
+#include "src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_EIGENVALUES_MODULE_H
+/* vim: set filetype=cpp et sw=2 ts=2 ai: */

src/eigen/Eigen/Geometry

@@ -0,0 +1,62 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_GEOMETRY_MODULE_H
+#define EIGEN_GEOMETRY_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+#include "SVD"
+#include "LU"
+#include <limits>
+
+/** \defgroup Geometry_Module Geometry module
+  *
+  * This module provides support for:
+  *  - fixed-size homogeneous transformations
+  *  - translation, scaling, 2D and 3D rotations
+  *  - \link Quaternion quaternions \endlink
+  *  - cross products (\ref MatrixBase::cross, \ref MatrixBase::cross3)
+  *  - orthognal vector generation (\ref MatrixBase::unitOrthogonal)
+  *  - some linear components: \link ParametrizedLine parametrized-lines \endlink and \link Hyperplane hyperplanes \endlink
+  *  - \link AlignedBox axis aligned bounding boxes \endlink
+  *  - \link umeyama least-square transformation fitting \endlink
+  *
+  * \code
+  * #include <Eigen/Geometry>
+  * \endcode
+  */
+
+#include "src/Geometry/OrthoMethods.h"
+#include "src/Geometry/EulerAngles.h"
+
+#include "src/Geometry/Homogeneous.h"
+#include "src/Geometry/RotationBase.h"
+#include "src/Geometry/Rotation2D.h"
+#include "src/Geometry/Quaternion.h"
+#include "src/Geometry/AngleAxis.h"
+#include "src/Geometry/Transform.h"
+#include "src/Geometry/Translation.h"
+#include "src/Geometry/Scaling.h"
+#include "src/Geometry/Hyperplane.h"
+#include "src/Geometry/ParametrizedLine.h"
+#include "src/Geometry/AlignedBox.h"
+#include "src/Geometry/Umeyama.h"
+
+// Use the SSE optimized version whenever possible. At the moment the
+// SSE version doesn't compile when AVX is enabled
+#if defined EIGEN_VECTORIZE_SSE && !defined EIGEN_VECTORIZE_AVX
+#include "src/Geometry/arch/Geometry_SSE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_GEOMETRY_MODULE_H
+/* vim: set filetype=cpp et sw=2 ts=2 ai: */
+

src/eigen/Eigen/Householder

@@ -0,0 +1,30 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_HOUSEHOLDER_MODULE_H
+#define EIGEN_HOUSEHOLDER_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Householder_Module Householder module
+  * This module provides Householder transformations.
+  *
+  * \code
+  * #include <Eigen/Householder>
+  * \endcode
+  */
+
+#include "src/Householder/Householder.h"
+#include "src/Householder/HouseholderSequence.h"
+#include "src/Householder/BlockHouseholder.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_HOUSEHOLDER_MODULE_H
+/* vim: set filetype=cpp et sw=2 ts=2 ai: */

src/eigen/Eigen/IterativeLinearSolvers

@@ -0,0 +1,48 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
+#define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
+
+#include "SparseCore"
+#include "OrderingMethods"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** 
+  * \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module
+  *
+  * This module currently provides iterative methods to solve problems of the form \c A \c x = \c b, where \c A is a squared matrix, usually very large and sparse.
+  * Those solvers are accessible via the following classes:
+  *  - ConjugateGradient for selfadjoint (hermitian) matrices,
+  *  - LeastSquaresConjugateGradient for rectangular least-square problems,
+  *  - BiCGSTAB for general square matrices.
+  *
+  * These iterative solvers are associated with some preconditioners:
+  *  - IdentityPreconditioner - not really useful
+  *  - DiagonalPreconditioner - also called Jacobi preconditioner, work very well on diagonal dominant matrices.
+  *  - IncompleteLUT - incomplete LU factorization with dual thresholding
+  *
+  * Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport, UmfPackSupport, SuperLUSupport.
+  *
+    \code
+    #include <Eigen/IterativeLinearSolvers>
+    \endcode
+  */
+
+#include "src/IterativeLinearSolvers/SolveWithGuess.h"
+#include "src/IterativeLinearSolvers/IterativeSolverBase.h"
+#include "src/IterativeLinearSolvers/BasicPreconditioners.h"
+#include "src/IterativeLinearSolvers/ConjugateGradient.h"
+#include "src/IterativeLinearSolvers/LeastSquareConjugateGradient.h"
+#include "src/IterativeLinearSolvers/BiCGSTAB.h"
+#include "src/IterativeLinearSolvers/IncompleteLUT.h"
+#include "src/IterativeLinearSolvers/IncompleteCholesky.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_ITERATIVELINEARSOLVERS_MODULE_H

src/eigen/Eigen/Jacobi

@@ -0,0 +1,33 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_JACOBI_MODULE_H
+#define EIGEN_JACOBI_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup Jacobi_Module Jacobi module
+  * This module provides Jacobi and Givens rotations.
+  *
+  * \code
+  * #include <Eigen/Jacobi>
+  * \endcode
+  *
+  * In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation:
+  *  - MatrixBase::applyOnTheLeft()
+  *  - MatrixBase::applyOnTheRight().
+  */
+
+#include "src/Jacobi/Jacobi.h"
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_JACOBI_MODULE_H
+/* vim: set filetype=cpp et sw=2 ts=2 ai: */
+

src/eigen/Eigen/LU

@@ -0,0 +1,50 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// This Source Code Form is subject to the terms of the Mozilla
+// Public License v. 2.0. If a copy of the MPL was not distributed
+// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef EIGEN_LU_MODULE_H
+#define EIGEN_LU_MODULE_H
+
+#include "Core"
+
+#include "src/Core/util/DisableStupidWarnings.h"
+
+/** \defgroup LU_Module LU module
+  * This module includes %LU decomposition and related notions such as matrix inversion and determinant.
+  * This module defines the following MatrixBase methods:
+  *  - MatrixBase::inverse()
+  *  - MatrixBase::determinant()
+  *
+  * \code
+  * #include <Eigen/LU>
+  * \endcode
+  */
+
+#include "src/misc/Kernel.h"
+#include "src/misc/Image.h"
+#include "src/LU/FullPivLU.h"
+#include "src/LU/PartialPivLU.h"
+#ifdef EIGEN_USE_LAPACKE
+#ifdef EIGEN_USE_MKL
+#include "mkl_lapacke.h"
+#else
+#include "src/misc/lapacke.h"
+#endif
+#include "src/LU/PartialPivLU_LAPACKE.h"
+#endif
+#include "src/LU/Determinant.h"
+#include "src/LU/InverseImpl.h"
+
+// Use the SSE optimized version whenever possible. At the moment the
+// SSE version doesn't compile when AVX is enabled
+#if defined EIGEN_VECTORIZE_SSE && !defined EIGEN_VECTORIZE_AVX
+  #include "src/LU/arch/Inverse_SSE.h"
+#endif
+
+#include "src/Core/util/ReenableStupidWarnings.h"
+
+#endif // EIGEN_LU_MODULE_H
+/* vim: set filetype=cpp et sw=2 ts=2 ai: */