, 1 April 1990\r\n Ty Coon, President of Vice\r\n\r\nThat's all there is to it!\r\n\r\n\r\n"
},
{
"path": "OSM2World/lib/lp_solve/README.html",
"content": "\r\n\r\n\r\nUsing lp_solve 5.5 in Java programs\r\n\r\n\r\n\r\n\r\n\r\n\r\nUsing lp_solve 5.5 in Java programs
\r\n\r\nContents
\r\n\r\n1. Introduction
\r\n2. Installation
\r\n3. Usage
\r\n4. Implementation notes
\r\n5. Building from source
\r\n6. Calling lp_solve from Python/Jython
\r\n\r\n\r\n\r\n\r\n\r\nlp_solve is a free (see LGPL for the GNU lesser general public license) linear\r\n(integer) programming solver based on the revised simplex method and the Branch-and-bound method\r\nfor the integers. lp_solve has its own community via the Yahoo group\r\nhttp://groups.yahoo.com/group/lp_solve.\r\nThere you can find the latest sources, executables for the common platforms, examples, manuals\r\nand a message board where people can share their thoughts on lp_solve.
\r\n\r\nlp_solve is written in ANSI C and can be compiled on many different platforms like Linux and Windows.\r\nBasically, lp_solve is a library, a set of routines, that can be called\r\neasily from programming languages like C, C++, C# and VB. Unfortunately, there is no simple and\r\nstraightforward way to use native C libraries like lp_solve in Java programs.\r\nThis library (also called "Java wrapper") is designed to remedy this shortcoming. It\r\nconsists of two main parts:
\r\n\r\n\r\n- A Java class library that is used by Java client programs. It gives access to all\r\n lp_solve routines through the
LpSolve class. \r\n\r\n- A native library written in C++, also called 'stub' library, that uses the JNI\r\n (Java Native Interface) API to translate Java method calls into calls to the\r\n corresponding routines of the lp_solve library. Java client\r\n programs do not interact directly with the stub library.\r\n This library must be compiled for each target platform.\r\n Precompiled binaries are included for Windows and Linux operating systems.\r\n There is also a build script for compiling the stub library on Mac OS X.
\r\n
\r\n\r\nThis document should help you getting started using the Java wrapper and lp_solve in your\r\nJava programs. Read it in addition to the documentation that comes with lp_solve.\r\nAlways refer to the lp_solve docs as ultimate reference for\r\nusing the routines of the optimization library.\r\nBug reports, succes stories and requests for changes concerning the Java wrapper are welcome\r\nby email at juergen.ebert@web.de or in the lp_solve discussion group.
\r\n\r\nThe current wrapper version was written to work with lp_solve 5.5.0.9 and was tested\r\n under Windows XP and Linux. As long as the API stays the same, other versions of lp_solve\r\n are likely to work as well. The wrapper requires a Java Runtime Environment 1.3 or later.
\r\n\r\nThe latest version of the Java wrapper can be found in the files section of the lp_solve group.\r\nThe wrapper is released under the same LGPL license conditions as lp_solve. A copy of\r\nthe LGPL text is contained in the distribution archive.
\r\n\r\n\r\n\r\n\r\n\r\n\r\n- Copy the lp_solve dynamic libraries from the archives
lp_solve_5.5_dev.(zip or tar.gz)\r\n and lp_solve_5.5_exe.(zip or tar.gz) to a standard library directory for your target platform.\r\n On Windows, a typical place would be \\WINDOWS or \\WINDOWS\\SYSTEM32.\r\n On Linux, a typical place would be the directory /usr/local/lib.\r\n \r\n\r\n- Unzip the Java wrapper distribution file to new directory of your choice.
\r\n\r\n- On Windows, copy the wrapper stub library
lpsolve55j.dll\r\n to the directory that already contains lpsolve55.dll.\r\n \r\n\r\n- On Linux, copy the wrapper stub library
liblpsolve55j.so\r\n to the directory that already contains liblpsolve55.so. Run ldconfig to include\r\n the library in the shared libray cache.\r\n \r\n
\r\n\r\n\r\n\r\n\r\n\r\n\r\nTo create a Java application that uses lp_solve routines, you must perform the\r\nfollowing steps:
\r\n\r\n\r\n- Make sure you have a Java Runtime Environment 1.3 or later installed.
\r\n\r\n- Install lp_solve and the Java wrapper as described above.
\r\n\r\n- Copy the archive file
lpsolve55j.jar from the Java wrapper distribution to a\r\n directory that is included in the CLASSPATH of your java program. \r\n\r\n- Add an import statement for the package
lpsolve.* at the beginning of your\r\n source file. \r\n\r\n- Call
LpSolve.makeLp(...) or one of the other static factory methods of the LpSolve\r\n class to create a LpSolve instance. Each LpSolve instance represents an optimization\r\n problem. \r\n\r\n- Call the methods of the
LpSolve instance to define the problem and obtain the solution.\r\n Use the examples and implementation notes later in this documentation for further\r\n information. \r\n\r\n- When you run your Java file make sure to include
lpsolve55j.jar in the CLASSPATH.\r\n Also, on Windows, if you installed the native stub library in a directory that is not included\r\n in the PATH variable, you have to define the Java system variable java.library.path\r\n which must point to the installation directory. On Linux, the equivalent of the Windows PATH\r\n variable is called LD_LIBRARY_PATH. \r\n
\r\n\r\n\r\n\r\n\r\nThe following program is a very simple example that shows how to program with lp_solve in Java.\r\n
\r\n\r\n\r\nimport lpsolve.*;\r\n\r\npublic class Demo {\r\n\r\n public static void main(String[] args) {\r\n try {\r\n // Create a problem with 4 variables and 0 constraints\r\n LpSolve solver = LpSolve.makeLp(0, 4);\r\n\r\n // add constraints\r\n solver.strAddConstraint(\"3 2 2 1\", LpSolve.LE, 4);\r\n solver.strAddConstraint(\"0 4 3 1\", LpSolve.GE, 3);\r\n\r\n // set objective function\r\n solver.strSetObjFn(\"2 3 -2 3\");\r\n\r\n // solve the problem\r\n solver.solve();\r\n\r\n // print solution\r\n System.out.println(\"Value of objective function: \" + solver.getObjective());\r\n double[] var = solver.getPtrVariables();\r\n for (int i = 0; i < var.length; i++) {\r\n System.out.println(\"Value of var[\" + i + \"] = \" + var[i]);\r\n }\r\n\r\n // delete the problem and free memory\r\n solver.deleteLp();\r\n }\r\n catch (LpSolveException e) {\r\n e.printStackTrace();\r\n }\r\n }\r\n\r\n}\r\n\r\n\r\n\r\n\r\nThe following code fragment shows you how to use callbacks in Java.\r\nThe example defines an anonymous inner class that implements the AbortListener\r\ninterface which is then passed to the putAbortfunc method.
\r\n\r\n\r\n LpSolve solver = LpSolve.makeLp(0, 4);\r\n AbortListener abortfunc = new AbortListener() {\r\n public boolean abortfunc(LpSolve problem, Object handle) {\r\n System.out.println(\"Java abortfunc called, handle = \" + handle);\r\n return false;\r\n }\r\n };\r\n solver.putAbortfunc(abortfunc, new Integer(123));\r\n\r\n\r\n\r\n\r\n\r\nFollow these steps to run the demo application, which is a port of the C demo\r\nprogram that comes with lp_solve to the Java language. You will need a Java Runtime\r\nEnvironment (JRE) on your machine in order to run the demo. You can download the\r\nlatest JRE from http://java.sun.com
\r\n\r\n\r\n- Install lp_solve and the Java wrapper as described above.
\r\n- On Windows, go to the
demo directory and\r\nstart the batch script "run_demo.bat". \r\n- On Linux, go to the
demo directory of the wrapper distribution and\r\nrun "sh run_demo". \r\n
\r\n\r\n\r\n\r\nIn the demo directory you will find\r\nthe file LpSolveTest.java which contains more than 100\r\nJUnit test cases (see http://www.junit.org for\r\ndetails about this highly useful software)\r\nto strengthen the faith in the Java wrapper implementation. The test cases\r\nmay also seve as examples of basic lp_solve usage in Java. You will need\r\nthe library junit.jar in your CLASSPATH to run the test cases.\r\njunit.jar is included in the lib directory of the Java wrapper. You\r\ncan run the test cases directly by starting the batch script "run_unittests.bat" on Windows\r\nor "sh run_unittests" on Linux.\r\n
\r\n\r\n\r\n\r\n\r\n\r\n- In general, the Java API tries to follow the original C/C++ API of lp_solve as\r\n closely as possible to make ist easier for programmers who have to write programs for\r\n lp_solve in multiple different programming languages. However, because of fundamental\r\n differences between the Java programming language and C/C++ this is not always strictly\r\n possible. For example, it is not possible in Java to pass simple datatypes by reference.
\r\n\r\n- Method names have been kept, but changed to Java convention, i.e. underscores have been\r\n removed, the following character is capitalized. For example
str_add_constraint\r\n becomes strAddConstraint in Java. \r\n\r\n- The
lprec* argument taken by almost all lp_solve API routines is hidden\r\n completely inside the LpSolve class. All methods that create new lprec\r\n structures were made static methods of the LpSolve class. \r\n\r\n- Return values denoting fatal internal errors have been changed to Java Exceptions. For\r\n example
set_row_name returns FALSE if an error has occured. In Java, \r\n setRowName is of type void and throws a LpSolveException. \r\n\r\n- Routines that have arguments or return values of type unsigned char, but only allow for TRUE or\r\n FALSE as legal values have been changed to type
boolean. Example: \r\n set_debug(lprec *lp, unsigned char debug) is setDebug(boolean debug) in Java.\r\n \r\n\r\n- Multiple problems may be solved concurrently by multiple threads, as long as a single\r\n
LpSolve object, which represents a problem, is only used by one thread at a\r\n time. \r\n\r\n- lp_solve does not require client programs to keep argument buffers allocated between calls\r\n to different library routines, because all input arguments are copied to internal buffers.\r\n Thus, it is easy to avoid memory leaks in the stub library. All objects returned by the\r\n Java wrapper routines are allocated by the JVM and are subject to the standard garbage\r\n collection process.
\r\n\r\n- The methods
get_ptr_sensitivity_rhs, get_ptr_reduced_costs,\r\n get_ptr_sensitivity_obj, and get_ptr_sensitivity_objex are not implemented,\r\n because it is not possible in Java to pass pointers by reference to a method. Use the corresponding\r\n methods without the Ptr part in the method name instead, which require allocation\r\n of the resulting arrays by the caller. \r\n\r\n- See the file
reference.html for details on how the lp_solve API functions\r\nare mapped to the Java methods. \r\n
\r\n\r\n\r\n\r\n\r\n\r\nThe Java wrapper archive contains precompiled binary libraries for Windows and Linux.\r\nIf you just want to use the wrapper there should be no need to build the libs from the sources.\r\nBut if you absolutely have to, follow the guidelines in this chapter.
\r\n\r\n\r\n\r\nThe following prerequisites must be met in order to build the wrapper C library from source\r\non Windows operating systems:\r\n\r\n\r\n- Microsoft Visual C++ compiler (I used V 7, others might work)
\r\n- Visual Studio envirement variables must be set.
\r\n- Sun Java Development Kit 1.4.x installed and JAVA_HOME environment variable set
\r\n- lp_solve Windows development archive
lp_solve_5.5_dev.zip unpacked \r\n
\r\n\r\nChange to the lib directory and edit the file build.bat.\r\nChange the path to the directory where you unpacked the lp_solve Windows\r\narchive. Run the script to build lpsolve55j.dll.\r\nThe dll will be created in directory win32 or win64 depending on the OS.\r\n\r\n\r\n\r\n\r\nThe following prerequisites must be met in order to build the wrapper C library from source\r\non Linux operating systems:\r\n\r\n\r\n- gcc and g++ compiler installed (I used gcc Version 3.3.1)
\r\n- Sun Java Development Kit 1.4.x installed
\r\n- lp_solve Linux development archive
lp_solve_5.5_dev.tar.gz unpacked \r\n
\r\n\r\nChange to the lib directory and edit the file build.\r\nChange the paths to the directory where you unpacked the lp_solve linux archive\r\nand where the JDK is installed.\r\nRun sh build to build liblpsolve55j.so.\r\nThe dll will be created in directory ux32 or ux64 depending on the OS.\r\n\r\n\r\n\r\n\r\nChange to the lib/mac directory and edit the file build_osx.\r\nChange the directory paths as indicated in the comments.\r\nThanks to Sean P. Kane (spkane@genomatica.com) who provided this build script.
\r\n\r\n\r\n\r\n\r\n\r\nJython (http://www.jython.org) is a 100% Java implementation of\r\nthe popular scripting language Python.\r\nOne of the most remarkable features of Jython is the seamless interaction between Python and Java.\r\nJava programmers can add the Jython libraries to their system to allow end users to write scripts that add\r\nfunctionality to the application. On the other hand, Python/Jython programs can interact with Java packages\r\nor with running Java applications.\r\n
\r\n\r\nlp_solve functions can be called via the Java wrapper from Python/Jython programs.\r\nSee the file demo.py in the demo directory of the Java wrapper distribution\r\nfor an example program.\r\nTo run this program, you must install lp_solve, the Java wrapper, and Jython. Don't forget\r\nto include lpsolve55j.jar in the Java CLASSPATH when you run Jython.\r\n
\r\n\r\n\r\n\r\n\r\n"
},
{
"path": "OSM2World/lib/osmosis/copying.txt",
"content": "Osmosis consists of all files in this archive with the exception of the\nthird party libraries in the lib and repo subdirectories.\n\nOsmosis is placed into the public domain and where this is not legally\npossible everybody is granted a perpetual, irrevocable license to use\nthis work for any purpose whatsoever.\n\nDISCLAIMERS\nBy making Osmosis publicly available, it is hoped that users will find the\nsoftware useful. However:\n* Osmosis comes without any warranty, to the extent permitted by applicable\nlaw.\n* Unless required by applicable law, no liability will be accepted by\nthe authors and distributors of this software for any damages caused\nas a result of its use. \n"
},
{
"path": "OSM2World/lib/poly2tri/LICENSE.txt",
"content": "Poly2Tri\nCopyright (c) 2009-2010, Poly2Tri Contributors\nhttp://code.google.com/p/poly2tri/\n\nAll rights reserved.\nRedistribution and use in source and binary forms, with or without modification,\nare permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice,\n this list of conditions and the following disclaimer.\n* Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n* Neither the name of Poly2Tri nor the names of its contributors may be\n used to endorse or promote products derived from this software without specific\n prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\nCONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\nEXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\nPROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\nPROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\nLIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\nNEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n"
},
{
"path": "OSM2World/lib/slf4j/LICENSE.txt",
"content": "Copyright (c) 2004-2008 QOS.ch\r\nAll rights reserved.\r\n\r\nPermission is hereby granted, free of charge, to any person obtaining\r\na copy of this software and associated documentation files (the\r\n\"Software\"), to deal in the Software without restriction, including\r\nwithout limitation the rights to use, copy, modify, merge, publish,\r\ndistribute, sublicense, and/or sell copies of the Software, and to\r\npermit persons to whom the Software is furnished to do so, subject to\r\nthe following conditions:\r\n\r\nThe above copyright notice and this permission notice shall be\r\nincluded in all copies or substantial portions of the Software.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\r\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r\nLIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r\n\r\n\r\n\r\n"
},
{
"path": "OSM2World/lib/trove/AUTHORS.txt",
"content": "Rob Eden \r\nJohan Parent \r\nJeff Randall \r\nEric D. Friedman \r\n\r\nPlease do NOT email bug reports or feature requests.\r\n\r\nInstead use the very fine bug tracking system and feature request\r\nservice on SourceForge: http://sourceforge.net/projects/trove4j/\r\nWe'll read your issue just as quickly, and the project's issues will\r\nremain out in the open where everyone can see them. We also monitor\r\nthe project forums, so feel free to use those too.\r\n"
},
{
"path": "OSM2World/lib/trove/LICENSE.txt",
"content": " GNU LESSER GENERAL PUBLIC LICENSE\r\n Version 2.1, February 1999\r\n\r\n Copyright (C) 1991, 1999 Free Software Foundation, Inc.\r\n 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r\n Everyone is permitted to copy and distribute verbatim copies\r\n of this license document, but changing it is not allowed.\r\n\r\n[This is the first released version of the Lesser GPL. It also counts\r\n as the successor of the GNU Library Public License, version 2, hence\r\n the version number 2.1.]\r\n\r\n Preamble\r\n\r\n The licenses for most software are designed to take away your\r\nfreedom to share and change it. By contrast, the GNU General Public\r\nLicenses are intended to guarantee your freedom to share and change\r\nfree software--to make sure the software is free for all its users.\r\n\r\n This license, the Lesser General Public License, applies to some\r\nspecially designated software packages--typically libraries--of the\r\nFree Software Foundation and other authors who decide to use it. You\r\ncan use it too, but we suggest you first think carefully about whether\r\nthis license or the ordinary General Public License is the better\r\nstrategy to use in any particular case, based on the explanations below.\r\n\r\n When we speak of free software, we are referring to freedom of use,\r\nnot price. Our General Public Licenses are designed to make sure that\r\nyou have the freedom to distribute copies of free software (and charge\r\nfor this service if you wish); that you receive source code or can get\r\nit if you want it; that you can change the software and use pieces of\r\nit in new free programs; and that you are informed that you can do\r\nthese things.\r\n\r\n To protect your rights, we need to make restrictions that forbid\r\ndistributors to deny you these rights or to ask you to surrender these\r\nrights. These restrictions translate to certain responsibilities for\r\nyou if you distribute copies of the library or if you modify it.\r\n\r\n For example, if you distribute copies of the library, whether gratis\r\nor for a fee, you must give the recipients all the rights that we gave\r\nyou. You must make sure that they, too, receive or can get the source\r\ncode. If you link other code with the library, you must provide\r\ncomplete object files to the recipients, so that they can relink them\r\nwith the library after making changes to the library and recompiling\r\nit. And you must show them these terms so they know their rights.\r\n\r\n We protect your rights with a two-step method: (1) we copyright the\r\nlibrary, and (2) we offer you this license, which gives you legal\r\npermission to copy, distribute and/or modify the library.\r\n\r\n To protect each distributor, we want to make it very clear that\r\nthere is no warranty for the free library. Also, if the library is\r\nmodified by someone else and passed on, the recipients should know\r\nthat what they have is not the original version, so that the original\r\nauthor's reputation will not be affected by problems that might be\r\nintroduced by others.\r\n\f\r\n Finally, software patents pose a constant threat to the existence of\r\nany free program. We wish to make sure that a company cannot\r\neffectively restrict the users of a free program by obtaining a\r\nrestrictive license from a patent holder. Therefore, we insist that\r\nany patent license obtained for a version of the library must be\r\nconsistent with the full freedom of use specified in this license.\r\n\r\n Most GNU software, including some libraries, is covered by the\r\nordinary GNU General Public License. This license, the GNU Lesser\r\nGeneral Public License, applies to certain designated libraries, and\r\nis quite different from the ordinary General Public License. We use\r\nthis license for certain libraries in order to permit linking those\r\nlibraries into non-free programs.\r\n\r\n When a program is linked with a library, whether statically or using\r\na shared library, the combination of the two is legally speaking a\r\ncombined work, a derivative of the original library. The ordinary\r\nGeneral Public License therefore permits such linking only if the\r\nentire combination fits its criteria of freedom. The Lesser General\r\nPublic License permits more lax criteria for linking other code with\r\nthe library.\r\n\r\n We call this license the \"Lesser\" General Public License because it\r\ndoes Less to protect the user's freedom than the ordinary General\r\nPublic License. It also provides other free software developers Less\r\nof an advantage over competing non-free programs. These disadvantages\r\nare the reason we use the ordinary General Public License for many\r\nlibraries. However, the Lesser license provides advantages in certain\r\nspecial circumstances.\r\n\r\n For example, on rare occasions, there may be a special need to\r\nencourage the widest possible use of a certain library, so that it becomes\r\na de-facto standard. To achieve this, non-free programs must be\r\nallowed to use the library. A more frequent case is that a free\r\nlibrary does the same job as widely used non-free libraries. In this\r\ncase, there is little to gain by limiting the free library to free\r\nsoftware only, so we use the Lesser General Public License.\r\n\r\n In other cases, permission to use a particular library in non-free\r\nprograms enables a greater number of people to use a large body of\r\nfree software. For example, permission to use the GNU C Library in\r\nnon-free programs enables many more people to use the whole GNU\r\noperating system, as well as its variant, the GNU/Linux operating\r\nsystem.\r\n\r\n Although the Lesser General Public License is Less protective of the\r\nusers' freedom, it does ensure that the user of a program that is\r\nlinked with the Library has the freedom and the wherewithal to run\r\nthat program using a modified version of the Library.\r\n\r\n The precise terms and conditions for copying, distribution and\r\nmodification follow. Pay close attention to the difference between a\r\n\"work based on the library\" and a \"work that uses the library\". The\r\nformer contains code derived from the library, whereas the latter must\r\nbe combined with the library in order to run.\r\n\f\r\n GNU LESSER GENERAL PUBLIC LICENSE\r\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\r\n\r\n 0. This License Agreement applies to any software library or other\r\nprogram which contains a notice placed by the copyright holder or\r\nother authorized party saying it may be distributed under the terms of\r\nthis Lesser General Public License (also called \"this License\").\r\nEach licensee is addressed as \"you\".\r\n\r\n A \"library\" means a collection of software functions and/or data\r\nprepared so as to be conveniently linked with application programs\r\n(which use some of those functions and data) to form executables.\r\n\r\n The \"Library\", below, refers to any such software library or work\r\nwhich has been distributed under these terms. A \"work based on the\r\nLibrary\" means either the Library or any derivative work under\r\ncopyright law: that is to say, a work containing the Library or a\r\nportion of it, either verbatim or with modifications and/or translated\r\nstraightforwardly into another language. (Hereinafter, translation is\r\nincluded without limitation in the term \"modification\".)\r\n\r\n \"Source code\" for a work means the preferred form of the work for\r\nmaking modifications to it. For a library, complete source code means\r\nall the source code for all modules it contains, plus any associated\r\ninterface definition files, plus the scripts used to control compilation\r\nand installation of the library.\r\n\r\n Activities other than copying, distribution and modification are not\r\ncovered by this License; they are outside its scope. The act of\r\nrunning a program using the Library is not restricted, and output from\r\nsuch a program is covered only if its contents constitute a work based\r\non the Library (independent of the use of the Library in a tool for\r\nwriting it). Whether that is true depends on what the Library does\r\nand what the program that uses the Library does.\r\n \r\n 1. You may copy and distribute verbatim copies of the Library's\r\ncomplete source code as you receive it, in any medium, provided that\r\nyou conspicuously and appropriately publish on each copy an\r\nappropriate copyright notice and disclaimer of warranty; keep intact\r\nall the notices that refer to this License and to the absence of any\r\nwarranty; and distribute a copy of this License along with the\r\nLibrary.\r\n\r\n You may charge a fee for the physical act of transferring a copy,\r\nand you may at your option offer warranty protection in exchange for a\r\nfee.\r\n\f\r\n 2. You may modify your copy or copies of the Library or any portion\r\nof it, thus forming a work based on the Library, and copy and\r\ndistribute such modifications or work under the terms of Section 1\r\nabove, provided that you also meet all of these conditions:\r\n\r\n a) The modified work must itself be a software library.\r\n\r\n b) You must cause the files modified to carry prominent notices\r\n stating that you changed the files and the date of any change.\r\n\r\n c) You must cause the whole of the work to be licensed at no\r\n charge to all third parties under the terms of this License.\r\n\r\n d) If a facility in the modified Library refers to a function or a\r\n table of data to be supplied by an application program that uses\r\n the facility, other than as an argument passed when the facility\r\n is invoked, then you must make a good faith effort to ensure that,\r\n in the event an application does not supply such function or\r\n table, the facility still operates, and performs whatever part of\r\n its purpose remains meaningful.\r\n\r\n (For example, a function in a library to compute square roots has\r\n a purpose that is entirely well-defined independent of the\r\n application. Therefore, Subsection 2d requires that any\r\n application-supplied function or table used by this function must\r\n be optional: if the application does not supply it, the square\r\n root function must still compute square roots.)\r\n\r\nThese requirements apply to the modified work as a whole. If\r\nidentifiable sections of that work are not derived from the Library,\r\nand can be reasonably considered independent and separate works in\r\nthemselves, then this License, and its terms, do not apply to those\r\nsections when you distribute them as separate works. But when you\r\ndistribute the same sections as part of a whole which is a work based\r\non the Library, the distribution of the whole must be on the terms of\r\nthis License, whose permissions for other licensees extend to the\r\nentire whole, and thus to each and every part regardless of who wrote\r\nit.\r\n\r\nThus, it is not the intent of this section to claim rights or contest\r\nyour rights to work written entirely by you; rather, the intent is to\r\nexercise the right to control the distribution of derivative or\r\ncollective works based on the Library.\r\n\r\nIn addition, mere aggregation of another work not based on the Library\r\nwith the Library (or with a work based on the Library) on a volume of\r\na storage or distribution medium does not bring the other work under\r\nthe scope of this License.\r\n\r\n 3. You may opt to apply the terms of the ordinary GNU General Public\r\nLicense instead of this License to a given copy of the Library. To do\r\nthis, you must alter all the notices that refer to this License, so\r\nthat they refer to the ordinary GNU General Public License, version 2,\r\ninstead of to this License. (If a newer version than version 2 of the\r\nordinary GNU General Public License has appeared, then you can specify\r\nthat version instead if you wish.) Do not make any other change in\r\nthese notices.\r\n\f\r\n Once this change is made in a given copy, it is irreversible for\r\nthat copy, so the ordinary GNU General Public License applies to all\r\nsubsequent copies and derivative works made from that copy.\r\n\r\n This option is useful when you wish to copy part of the code of\r\nthe Library into a program that is not a library.\r\n\r\n 4. You may copy and distribute the Library (or a portion or\r\nderivative of it, under Section 2) in object code or executable form\r\nunder the terms of Sections 1 and 2 above provided that you accompany\r\nit with the complete corresponding machine-readable source code, which\r\nmust be distributed under the terms of Sections 1 and 2 above on a\r\nmedium customarily used for software interchange.\r\n\r\n If distribution of object code is made by offering access to copy\r\nfrom a designated place, then offering equivalent access to copy the\r\nsource code from the same place satisfies the requirement to\r\ndistribute the source code, even though third parties are not\r\ncompelled to copy the source along with the object code.\r\n\r\n 5. A program that contains no derivative of any portion of the\r\nLibrary, but is designed to work with the Library by being compiled or\r\nlinked with it, is called a \"work that uses the Library\". Such a\r\nwork, in isolation, is not a derivative work of the Library, and\r\ntherefore falls outside the scope of this License.\r\n\r\n However, linking a \"work that uses the Library\" with the Library\r\ncreates an executable that is a derivative of the Library (because it\r\ncontains portions of the Library), rather than a \"work that uses the\r\nlibrary\". The executable is therefore covered by this License.\r\nSection 6 states terms for distribution of such executables.\r\n\r\n When a \"work that uses the Library\" uses material from a header file\r\nthat is part of the Library, the object code for the work may be a\r\nderivative work of the Library even though the source code is not.\r\nWhether this is true is especially significant if the work can be\r\nlinked without the Library, or if the work is itself a library. The\r\nthreshold for this to be true is not precisely defined by law.\r\n\r\n If such an object file uses only numerical parameters, data\r\nstructure layouts and accessors, and small macros and small inline\r\nfunctions (ten lines or less in length), then the use of the object\r\nfile is unrestricted, regardless of whether it is legally a derivative\r\nwork. (Executables containing this object code plus portions of the\r\nLibrary will still fall under Section 6.)\r\n\r\n Otherwise, if the work is a derivative of the Library, you may\r\ndistribute the object code for the work under the terms of Section 6.\r\nAny executables containing that work also fall under Section 6,\r\nwhether or not they are linked directly with the Library itself.\r\n\f\r\n 6. As an exception to the Sections above, you may also combine or\r\nlink a \"work that uses the Library\" with the Library to produce a\r\nwork containing portions of the Library, and distribute that work\r\nunder terms of your choice, provided that the terms permit\r\nmodification of the work for the customer's own use and reverse\r\nengineering for debugging such modifications.\r\n\r\n You must give prominent notice with each copy of the work that the\r\nLibrary is used in it and that the Library and its use are covered by\r\nthis License. You must supply a copy of this License. If the work\r\nduring execution displays copyright notices, you must include the\r\ncopyright notice for the Library among them, as well as a reference\r\ndirecting the user to the copy of this License. Also, you must do one\r\nof these things:\r\n\r\n a) Accompany the work with the complete corresponding\r\n machine-readable source code for the Library including whatever\r\n changes were used in the work (which must be distributed under\r\n Sections 1 and 2 above); and, if the work is an executable linked\r\n with the Library, with the complete machine-readable \"work that\r\n uses the Library\", as object code and/or source code, so that the\r\n user can modify the Library and then relink to produce a modified\r\n executable containing the modified Library. (It is understood\r\n that the user who changes the contents of definitions files in the\r\n Library will not necessarily be able to recompile the application\r\n to use the modified definitions.)\r\n\r\n b) Use a suitable shared library mechanism for linking with the\r\n Library. A suitable mechanism is one that (1) uses at run time a\r\n copy of the library already present on the user's computer system,\r\n rather than copying library functions into the executable, and (2)\r\n will operate properly with a modified version of the library, if\r\n the user installs one, as long as the modified version is\r\n interface-compatible with the version that the work was made with.\r\n\r\n c) Accompany the work with a written offer, valid for at\r\n least three years, to give the same user the materials\r\n specified in Subsection 6a, above, for a charge no more\r\n than the cost of performing this distribution.\r\n\r\n d) If distribution of the work is made by offering access to copy\r\n from a designated place, offer equivalent access to copy the above\r\n specified materials from the same place.\r\n\r\n e) Verify that the user has already received a copy of these\r\n materials or that you have already sent this user a copy.\r\n\r\n For an executable, the required form of the \"work that uses the\r\nLibrary\" must include any data and utility programs needed for\r\nreproducing the executable from it. However, as a special exception,\r\nthe materials to be distributed need not include anything that is\r\nnormally distributed (in either source or binary form) with the major\r\ncomponents (compiler, kernel, and so on) of the operating system on\r\nwhich the executable runs, unless that component itself accompanies\r\nthe executable.\r\n\r\n It may happen that this requirement contradicts the license\r\nrestrictions of other proprietary libraries that do not normally\r\naccompany the operating system. Such a contradiction means you cannot\r\nuse both them and the Library together in an executable that you\r\ndistribute.\r\n\f\r\n 7. You may place library facilities that are a work based on the\r\nLibrary side-by-side in a single library together with other library\r\nfacilities not covered by this License, and distribute such a combined\r\nlibrary, provided that the separate distribution of the work based on\r\nthe Library and of the other library facilities is otherwise\r\npermitted, and provided that you do these two things:\r\n\r\n a) Accompany the combined library with a copy of the same work\r\n based on the Library, uncombined with any other library\r\n facilities. This must be distributed under the terms of the\r\n Sections above.\r\n\r\n b) Give prominent notice with the combined library of the fact\r\n that part of it is a work based on the Library, and explaining\r\n where to find the accompanying uncombined form of the same work.\r\n\r\n 8. You may not copy, modify, sublicense, link with, or distribute\r\nthe Library except as expressly provided under this License. Any\r\nattempt otherwise to copy, modify, sublicense, link with, or\r\ndistribute the Library is void, and will automatically terminate your\r\nrights under this License. However, parties who have received copies,\r\nor rights, from you under this License will not have their licenses\r\nterminated so long as such parties remain in full compliance.\r\n\r\n 9. You are not required to accept this License, since you have not\r\nsigned it. However, nothing else grants you permission to modify or\r\ndistribute the Library or its derivative works. These actions are\r\nprohibited by law if you do not accept this License. Therefore, by\r\nmodifying or distributing the Library (or any work based on the\r\nLibrary), you indicate your acceptance of this License to do so, and\r\nall its terms and conditions for copying, distributing or modifying\r\nthe Library or works based on it.\r\n\r\n 10. Each time you redistribute the Library (or any work based on the\r\nLibrary), the recipient automatically receives a license from the\r\noriginal licensor to copy, distribute, link with or modify the Library\r\nsubject to these terms and conditions. You may not impose any further\r\nrestrictions on the recipients' exercise of the rights granted herein.\r\nYou are not responsible for enforcing compliance by third parties with\r\nthis License.\r\n\f\r\n 11. If, as a consequence of a court judgment or allegation of patent\r\ninfringement or for any other reason (not limited to patent issues),\r\nconditions are imposed on you (whether by court order, agreement or\r\notherwise) that contradict the conditions of this License, they do not\r\nexcuse you from the conditions of this License. If you cannot\r\ndistribute so as to satisfy simultaneously your obligations under this\r\nLicense and any other pertinent obligations, then as a consequence you\r\nmay not distribute the Library at all. For example, if a patent\r\nlicense would not permit royalty-free redistribution of the Library by\r\nall those who receive copies directly or indirectly through you, then\r\nthe only way you could satisfy both it and this License would be to\r\nrefrain entirely from distribution of the Library.\r\n\r\nIf any portion of this section is held invalid or unenforceable under any\r\nparticular circumstance, the balance of the section is intended to apply,\r\nand the section as a whole is intended to apply in other circumstances.\r\n\r\nIt is not the purpose of this section to induce you to infringe any\r\npatents or other property right claims or to contest validity of any\r\nsuch claims; this section has the sole purpose of protecting the\r\nintegrity of the free software distribution system which is\r\nimplemented by public license practices. Many people have made\r\ngenerous contributions to the wide range of software distributed\r\nthrough that system in reliance on consistent application of that\r\nsystem; it is up to the author/donor to decide if he or she is willing\r\nto distribute software through any other system and a licensee cannot\r\nimpose that choice.\r\n\r\nThis section is intended to make thoroughly clear what is believed to\r\nbe a consequence of the rest of this License.\r\n\r\n 12. If the distribution and/or use of the Library is restricted in\r\ncertain countries either by patents or by copyrighted interfaces, the\r\noriginal copyright holder who places the Library under this License may add\r\nan explicit geographical distribution limitation excluding those countries,\r\nso that distribution is permitted only in or among countries not thus\r\nexcluded. In such case, this License incorporates the limitation as if\r\nwritten in the body of this License.\r\n\r\n 13. The Free Software Foundation may publish revised and/or new\r\nversions of the Lesser General Public License from time to time.\r\nSuch new versions will be similar in spirit to the present version,\r\nbut may differ in detail to address new problems or concerns.\r\n\r\nEach version is given a distinguishing version number. If the Library\r\nspecifies a version number of this License which applies to it and\r\n\"any later version\", you have the option of following the terms and\r\nconditions either of that version or of any later version published by\r\nthe Free Software Foundation. If the Library does not specify a\r\nlicense version number, you may choose any version ever published by\r\nthe Free Software Foundation.\r\n\f\r\n 14. If you wish to incorporate parts of the Library into other free\r\nprograms whose distribution conditions are incompatible with these,\r\nwrite to the author to ask for permission. For software which is\r\ncopyrighted by the Free Software Foundation, write to the Free\r\nSoftware Foundation; we sometimes make exceptions for this. Our\r\ndecision will be guided by the two goals of preserving the free status\r\nof all derivatives of our free software and of promoting the sharing\r\nand reuse of software generally.\r\n\r\n NO WARRANTY\r\n\r\n 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO\r\nWARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\r\nEXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\r\nOTHER PARTIES PROVIDE THE LIBRARY \"AS IS\" WITHOUT WARRANTY OF ANY\r\nKIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE\r\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r\nPURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE\r\nLIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME\r\nTHE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\r\n\r\n 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\r\nWRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\r\nAND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU\r\nFOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR\r\nCONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE\r\nLIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING\r\nRENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A\r\nFAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF\r\nSUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH\r\nDAMAGES.\r\n\r\n END OF TERMS AND CONDITIONS\r\n\f\r\n How to Apply These Terms to Your New Libraries\r\n\r\n If you develop a new library, and you want it to be of the greatest\r\npossible use to the public, we recommend making it free software that\r\neveryone can redistribute and change. You can do so by permitting\r\nredistribution under these terms (or, alternatively, under the terms of the\r\nordinary General Public License).\r\n\r\n To apply these terms, attach the following notices to the library. It is\r\nsafest to attach them to the start of each source file to most effectively\r\nconvey the exclusion of warranty; and each file should have at least the\r\n\"copyright\" line and a pointer to where the full notice is found.\r\n\r\n \r\n Copyright (C) \r\n\r\n This library is free software; you can redistribute it and/or\r\n modify it under the terms of the GNU Lesser General Public\r\n License as published by the Free Software Foundation; either\r\n version 2.1 of the License, or (at your option) any later version.\r\n\r\n This library is distributed in the hope that it will be useful,\r\n but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r\n Lesser General Public License for more details.\r\n\r\n You should have received a copy of the GNU Lesser General Public\r\n License along with this library; if not, write to the Free Software\r\n Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\r\n\r\nAlso add information on how to contact you by electronic and paper mail.\r\n\r\nYou should also get your employer (if you work as a programmer) or your\r\nschool, if any, to sign a \"copyright disclaimer\" for the library, if\r\nnecessary. Here is a sample; alter the names:\r\n\r\n Yoyodyne, Inc., hereby disclaims all copyright interest in the\r\n library `Frob' (a library for tweaking knobs) written by James Random Hacker.\r\n\r\n , 1 April 1990\r\n Ty Coon, President of Vice\r\n\r\nThat's all there is to it!\r\n\r\n\r\n"
},
{
"path": "OSM2World/lib/trove/README-license.txt",
"content": "The Trove library is licensed under the Lesser GNU Public License,\r\nwhich is included with the distribution in a file called LICENSE.txt.\r\n\r\nOther license arrangements are possible, for a fee: contact \r\nericdf@users.sourceforge.net for terms/pricing.\r\n\r\nThe PrimeFinder and HashFunctions classes in Trove are subject to the\r\nfollowing license restrictions:\r\n\r\nCopyright (c) 1999 CERN - European Organization for Nuclear Research.\r\n\r\nPermission to use, copy, modify, distribute and sell this software and\r\nits documentation for any purpose is hereby granted without fee,\r\nprovided that the above copyright notice appear in all copies and that\r\nboth that copyright notice and this permission notice appear in\r\nsupporting documentation. CERN makes no representations about the\r\nsuitability of this software for any purpose. It is provided \"as is\"\r\nwithout expressed or implied warranty.\r\n\r\n\r\n"
},
{
"path": "OSM2World/lib/trove/README.txt",
"content": "\r\n GNU Trove: High performance collections for Java.\r\n\r\nObjectives\r\n\r\n The GNU Trove library has two objectives:\r\n 1. Provide \"free\" (as in \"free speech\" and \"free beer\"), fast,\r\n lightweight implementations of the java.util Collections API.\r\n These implementations are designed to be pluggable replacements\r\n for their JDK equivalents.\r\n 2. Whenever possible, provide the same collections support for\r\n primitive types. This gap in the JDK is often addressed by using\r\n the \"wrapper\" classes (java.lang.Integer, java.lang.Float, etc.)\r\n with Object-based collections. For most applications, however,\r\n collections which store primitives directly will require less\r\n space and yield significant performance gains.\r\n\r\nHashtable techniques\r\n\r\n The Trove maps/sets use open addressing instead of the chaining\r\n approach taken by the JDK hashtables. This eliminates the need to\r\n create Map.Entry wrappper objects for every item in a table and so\r\n reduces the O (big-oh) in the performance of the hashtable algorithm.\r\n The size of the tables used in Trove's maps/sets is always a prime\r\n number, improving the probability of an optimal distribution of\r\n entries across the table, and so reducing the likelihood of\r\n performance-degrading collisions. Trove sets are not backed by maps,\r\n and so using a THashSet does not result in the allocation of an unused\r\n \"values\" array.\r\n\r\nHashing strategies\r\n\r\n Trove's maps/sets support the use of custom hashing strategies,\r\n allowing you to tune collections based on characteristics of the input\r\n data. This feature also allows you to define hash functions when it is\r\n not feasible to override Object.hashCode(). For example, the\r\n java.lang.String class is final, and its implementation of hashCode()\r\n takes O(n) time to complete. In some applications, however, it may be\r\n possible for a custom hashing function to save time by skipping\r\n portions of the string that are invariant.\r\n\r\n Using java.util.HashMap, it is not possible to use Java language\r\n arrays as keys. For example, this code:\r\n char[] foo, bar;\r\n foo = new char[] {'a','b','c'};\r\n bar = new char[] {'a','b','c'};\r\n System.out.println(foo.hashCode() == bar.hashCode() ?\r\n \"equal\" : \"not equal\");\r\n System.out.println(foo.equals(bar) ? \"equal\" : \"not equal\");\r\n \r\n\r\n produces this output:\r\n not equal\r\n not equal\r\n \r\n\r\n And so an entry stored in a java.util.HashMap with foo as a key could\r\n not be retrieved with bar, since there is no way to override\r\n hashCode() or equals() on language array objects.\r\n\r\n In a gnu.trove.map.hash.TCustomHashMap, however, you can implement a\r\n gnu.trove.strategy.HashingStrategy to enable hashing on arrays:\r\n class CharArrayStrategy implements HashingStrategy {\r\n public int computeHashCode(Object o) {\r\n char[] c = (char[])o;\r\n // use the shift-add-xor class of string hashing functions\r\n // cf. Ramakrishna and Zobel,\r\n // \"Performance in Practice of String Hashing Functions\"\r\n int h = 31; // seed chosen at random\r\n for (int i = 0; i < c.length; i++) { // could skip invariants\r\n // L=5, R=2 works well for ASCII input\r\n h = h ^ ((h << 5) + (h >> 2) + c[i]);\r\n }\r\n return h;\r\n }\r\n\r\n public boolean equals(Object o1, Object o2) {\r\n char[] c1 = (char[])o1;\r\n char[] c2 = (char[])o2;\r\n // could drop this check for fixed-length keys\r\n if (c1.length != c2.length) {\r\n return false;\r\n }\r\n // could skip invariants\r\n for (int i = 0, len = c1.length; i < len; i++) {\r\n if (c1[i] != c2[i]) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n }\r\n \r\n\r\nIterators in primitive collections\r\n\r\n Trove's primitive mappings include access through Iterators as well\r\n as procedures and functions. The API documentation on those classes\r\n contains several examples showing how these can be used effectively\r\n and explaining why their semantics differ from those of\r\n java.util.Iterator.\r\n\r\n_________________________________________________________________\r\n\r\n Last modified: Sep 9, 2011\r\n"
},
{
"path": "OSM2World/osm2world-rel20160312-to-bdb0c396e899ee9.patch",
"content": "diff --git a/OSM2World/.classpath b/OSM2World/.classpath\nnew file mode 100644\nindex 0000000..6a3f3c9\n--- /dev/null\n+++ b/OSM2World/.classpath\n@@ -0,0 +1,79 @@\n+\n+\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\t\n+\ndiff --git a/OSM2World/.gitignore b/OSM2World/.gitignore\nnew file mode 100644\nindex 0000000..6cc54c9\n--- /dev/null\n+++ b/OSM2World/.gitignore\n@@ -0,0 +1,4 @@\n+/bin\n+/build\n+\n+/eclipse-bin/\ndiff --git a/OSM2World/.project b/OSM2World/.project\nnew file mode 100644\nindex 0000000..d66d464\n--- /dev/null\n+++ b/OSM2World/.project\n@@ -0,0 +1,28 @@\n+\n+\n+\tTouch Mapper OSM2World\n+\t\n+\t\n+\t\n+\t\n+\t\t\n+\t\t\torg.eclipse.jdt.core.javabuilder\n+\t\t\t\n+\t\t\t\n+\t\t\n+\t\n+\t\n+\t\torg.eclipse.jdt.core.javanature\n+\t\n+\t\n+\t\t\n+\t\t\t1477832440066\n+\t\t\t\n+\t\t\t22\n+\t\t\t\n+\t\t\t\torg.eclipse.ui.ide.multiFilter\n+\t\t\t\t1.0-name-matches-false-false-*.class\n+\t\t\t\n+\t\t\n+\t\n+\ndiff --git a/OSM2World/build.xml b/OSM2World/build.xml\nindex 9459e90..cdcc9aa 100644\n--- a/OSM2World/build.xml\n+++ b/OSM2World/build.xml\n@@ -31,12 +31,12 @@\n \n \n \t\n- \n+ \n \n \n \n \t\n- \n+ \n \n \t\n \ndiff --git a/OSM2World/src/org/osm2world/core/ConversionFacade.java b/OSM2World/src/org/osm2world/core/ConversionFacade.java\nindex e71693c..39cba67 100644\n--- a/OSM2World/src/org/osm2world/core/ConversionFacade.java\n+++ b/OSM2World/src/org/osm2world/core/ConversionFacade.java\n@@ -28,6 +28,7 @@ import org.osm2world.core.map_elevation.creation.TerrainInterpolator;\n import org.osm2world.core.map_elevation.creation.ZeroInterpolator;\n import org.osm2world.core.map_elevation.data.EleConnector;\n import org.osm2world.core.math.VectorXYZ;\n+import org.osm2world.core.math.AxisAlignedBoundingBoxXZ;\n import org.osm2world.core.osm.creation.JOSMFileHack;\n import org.osm2world.core.osm.creation.OsmosisReader;\n import org.osm2world.core.osm.data.OSMData;\n@@ -133,20 +134,20 @@ public class ConversionFacade {\n \t\t\t\tnew RoadModule(),\n \t\t\t\tnew RailwayModule(),\n \t\t\t\tnew BuildingModule(),\n-\t\t\t\tnew ParkingModule(),\n-\t\t\t\tnew TreeModule(),\n-\t\t\t\tnew StreetFurnitureModule(),\n-\t\t\t\tnew TrafficSignModule(),\n-\t\t\t\tnew WaterModule(),\n-\t\t\t\tnew PoolModule(),\n-\t\t\t\tnew GolfModule(),\n-\t\t\t\tnew CliffModule(),\n-\t\t\t\tnew BarrierModule(),\n-\t\t\t\tnew PowerModule(),\n-\t\t\t\tnew BridgeModule(),\n-\t\t\t\tnew TunnelModule(),\n-\t\t\t\tnew SurfaceAreaModule(),\n-\t\t\t\tnew InvisibleModule()\n+\t\t\t\t//new ParkingModule(),\n+\t\t\t\t//new TreeModule(),\n+\t\t\t\t//new StreetFurnitureModule(),\n+\t\t\t\t//new TrafficSignModule(),\n+\t\t\t\tnew WaterModule()\n+\t\t\t\t//new PoolModule(),\n+\t\t\t\t//new GolfModule(),\n+\t\t\t\t//new CliffModule(),\n+\t\t\t\t//new BarrierModule(),\n+\t\t\t\t//new PowerModule(),\n+\t\t\t\t//new BridgeModule(),\n+\t\t\t\t//new TunnelModule(),\n+\t\t\t\t//new SurfaceAreaModule(),\n+\t\t\t\t//new InvisibleModule()\n \t\t);\n \t\t\n \t}\n@@ -303,7 +304,7 @@ public class ConversionFacade {\n \t\t\t\t}\n \t\t\t}\n \t\t}\n-\t\t\n+\n \t\t/* create map data from OSM data */\n \t\tupdatePhase(Phase.MAP_DATA);\n \t\t\n@@ -313,6 +314,14 @@ public class ConversionFacade {\n \t\tOSMToMapDataConverter converter = new OSMToMapDataConverter(mapProjection, config);\n \t\tMapData mapData = converter.createMapData(osmData);\n \t\t\n+ AxisAlignedBoundingBoxXZ boundary = mapData.getBoundary();\n+ System.out.println(\"Map-boundary:[\"\n+ + \" minX=\" + boundary.minX\n+ + \" minZ=\" + boundary.minZ\n+ + \" maxX=\" + boundary.maxX\n+ + \" maxZ=\" + boundary.maxZ\n+ + \" ]\");\n+\t\t\n \t\t/* apply world modules */\n \t\tupdatePhase(Phase.REPRESENTATION);\n \t\t\ndiff --git a/OSM2World/src/org/osm2world/core/target/obj/ObjTarget.java b/OSM2World/src/org/osm2world/core/target/obj/ObjTarget.java\nindex 6be2959..17b2b1f 100644\n--- a/OSM2World/src/org/osm2world/core/target/obj/ObjTarget.java\n+++ b/OSM2World/src/org/osm2world/core/target/obj/ObjTarget.java\n@@ -13,10 +13,12 @@ import java.util.HashMap;\n import java.util.List;\n import java.util.Map;\n \n+import org.openstreetmap.josm.plugins.graphview.core.data.TagGroup;\n import org.osm2world.core.map_data.data.MapArea;\n import org.osm2world.core.map_data.data.MapElement;\n import org.osm2world.core.map_data.data.MapNode;\n import org.osm2world.core.map_data.data.MapWaySegment;\n+import org.osm2world.core.map_elevation.data.EleConnector;\n import org.osm2world.core.math.TriangleXYZ;\n import org.osm2world.core.math.TriangleXYZWithNormals;\n import org.osm2world.core.math.VectorXYZ;\n@@ -91,10 +93,21 @@ public class ObjTarget extends FaceTarget {\n \t\t\t/* start an object with the object's class\n \t\t\t * and the underlying OSM element's name/ref tags */\n \t\t\t\n+\t\t\tString roadSuffix = null;\n+\t\t\t\n \t\t\tMapElement element = object.getPrimaryMapElement();\n \t\t\tOSMElement osmElement;\n \t\t\tif (element instanceof MapNode) {\n \t\t\t\tosmElement = ((MapNode) element).getOsmNode();\n+\t\t\t\t\n+\t\t\t\tList connectedWaySegments = ((MapNode) element).getConnectedWaySegments();\n+\t\t\t\tint pedestrians = 0;\n+\t\t\t\tfor (MapWaySegment mapWaySegment : connectedWaySegments) {\n+\t\t\t\t\tpedestrians += isPath(mapWaySegment.getTags()) ? 1 : 0;\n+\t\t\t\t}\n+\t\t\t\tif (pedestrians >= (connectedWaySegments.size()+1) / 2) {\n+\t\t\t\t\troadSuffix = \"::pedestrian\";\n+\t\t\t\t}\n \t\t\t} else if (element instanceof MapWaySegment) {\n \t\t\t\tosmElement = ((MapWaySegment) element).getOsmWay();\n \t\t\t} else if (element instanceof MapArea) {\n@@ -103,18 +116,50 @@ public class ObjTarget extends FaceTarget {\n \t\t\t\tosmElement = null;\n \t\t\t}\n \t\t\t\n+\t\t\tif (roadSuffix == null) {\n+\t\t\t\troadSuffix = isPath(osmElement.tags) ? \"::pedestrian\" : \"\";\n+\t\t\t}\n+\t\t\t\n \t\t\tif (osmElement != null && osmElement.tags.containsKey(\"name\")) {\n-\t\t\t\tobjStream.println(\"o \" + object.getClass().getSimpleName() + \" \" + osmElement.tags.getValue(\"name\"));\n+\t\t\t\tobjStream.println(\"o \" + object.getClass().getSimpleName() + \" \" + osmElement.tags.getValue(\"name\") + roadSuffix);\n \t\t\t} else if (osmElement != null && osmElement.tags.containsKey(\"ref\")) {\n-\t\t\t\tobjStream.println(\"o \" + object.getClass().getSimpleName() + \" \" + osmElement.tags.getValue(\"ref\"));\n+\t\t\t\tobjStream.println(\"o \" + object.getClass().getSimpleName() + \" \" + osmElement.tags.getValue(\"ref\") + roadSuffix);\n \t\t\t} else {\n-\t\t\t\tobjStream.println(\"o \" + object.getClass().getSimpleName() + anonymousWOCounter ++);\n+\t\t\t\tobjStream.println(\"o \" + object.getClass().getSimpleName() + anonymousWOCounter ++ + roadSuffix);\n \t\t\t}\n \t\t\t\n \t\t}\n \t\t\n \t}\n \t\n+\tprivate static boolean isPath(TagGroup tags) {\n+\t\tString highwayValue = tags.getValue(\"highway\");\n+\t\tif (\"path\".equals(highwayValue)\n+\t\t\t|| \"footway\".equals(highwayValue)\n+\t\t\t|| \"cycleway\".equals(highwayValue)\n+\t\t\t|| \"service\".equals(highwayValue)\n+\t\t\t|| \"bridleway\".equals(highwayValue)\n+\t\t\t|| \"living_street\".equals(highwayValue)\n+\t\t\t|| \"pedestrian\".equals(highwayValue)\n+\t\t\t|| \"track\".equals(highwayValue)\n+\t\t\t|| \"steps\".equals(highwayValue)) {\n+\t\t\treturn true;\n+\t\t}\n+\t\tif (tags.containsKey(\"footway\")\n+\t\t\t\t|| tags.contains(\"tourism\", \"attraction\")\n+\t\t\t\t|| tags.contains(\"man_made\", \"pier\")\n+\t\t\t\t|| tags.contains(\"man_made\", \"breakwater\")) {\n+\t\t\treturn true;\n+\t\t}\n+\t\tString footValue = tags.getValue(\"foot\");\n+\t\tif (\"yes\".equals(footValue)\n+\t\t\t|| \"designated\".equals(footValue)) {\n+\t\t\treturn true;\n+\t\t}\n+\t\treturn false;\n+\t}\n+\n+\t\n \t@Override\n \tpublic void drawFace(Material material, List vs,\n \t\t\tList normals, List> texCoordLists) {\ndiff --git a/OSM2World/src/org/osm2world/core/world/modules/BuildingModule.java b/OSM2World/src/org/osm2world/core/world/modules/BuildingModule.java\nindex df24aa2..b9542b6 100644\n--- a/OSM2World/src/org/osm2world/core/world/modules/BuildingModule.java\n+++ b/OSM2World/src/org/osm2world/core/world/modules/BuildingModule.java\n@@ -76,8 +76,8 @@ public class BuildingModule extends ConfigurableWorldModule {\n \t@Override\n \tpublic void applyTo(MapData mapData) {\n \t\t\n-\t\tboolean useBuildingColors = config.getBoolean(\"useBuildingColors\", true);\n-\t\tboolean drawBuildingWindows = config.getBoolean(\"drawBuildingWindows\", true);\n+\t\tboolean useBuildingColors = config.getBoolean(\"useBuildingColors\", false);\n+\t\tboolean drawBuildingWindows = config.getBoolean(\"drawBuildingWindows\", false);\n \t\t\n \t\tfor (MapArea area : mapData.getMapAreas()) {\n \t\t\t\n@@ -111,23 +111,23 @@ public class BuildingModule extends ConfigurableWorldModule {\n \t\t\t\n \t\t\tthis.area = area;\n \t\t\t\n-\t\t\tfor (MapOverlap overlap : area.getOverlaps()) {\n-\t\t\t\tMapElement other = overlap.getOther(area);\n-\t\t\t\tif (other instanceof MapArea\n-\t\t\t\t\t\t&& other.getTags().containsKey(\"building:part\")) {\n-\t\t\t\t\t\n-\t\t\t\t\tMapArea otherArea = (MapArea)other;\n-\t\t\t\t\t\n-\t\t\t\t\t//TODO: check whether the building contains the part (instead of just touching it)\n-\t\t\t\t\tif (area.getPolygon().contains(\n-\t\t\t\t\t\t\totherArea.getPolygon().getOuter())) {\n-\t\t\t\t\t\tparts.add(new BuildingPart(this, otherArea,\n-\t\t\t\t\t\t\totherArea.getPolygon(), useBuildingColors,\n-\t\t\t\t\t\t\tdrawBuildingWindows));\n-\t\t\t\t\t}\n-\t\t\t\t\t\n-\t\t\t\t}\n-\t\t\t}\n+//\t\t\tfor (MapOverlap overlap : area.getOverlaps()) {\n+//\t\t\t\tMapElement other = overlap.getOther(area);\n+//\t\t\t\tif (other instanceof MapArea\n+//\t\t\t\t\t\t&& other.getTags().containsKey(\"building:part\")) {\n+//\t\t\t\t\t\n+//\t\t\t\t\tMapArea otherArea = (MapArea)other;\n+//\t\t\t\t\t\n+//\t\t\t\t\t//TODO: check whether the building contains the part (instead of just touching it)\n+//\t\t\t\t\tif (area.getPolygon().contains(\n+//\t\t\t\t\t\t\totherArea.getPolygon().getOuter())) {\n+//\t\t\t\t\t\tparts.add(new BuildingPart(this, otherArea,\n+//\t\t\t\t\t\t\totherArea.getPolygon(), useBuildingColors,\n+//\t\t\t\t\t\t\tdrawBuildingWindows));\n+//\t\t\t\t\t}\n+//\t\t\t\t\t\n+//\t\t\t\t}\n+//\t\t\t}\n \t\t\t\n \t\t\t/* add part(s) for area not covered by building:part polygons */\n \t\t\tboolean isBuildingPart = false;\n@@ -138,23 +138,23 @@ public class BuildingModule extends ConfigurableWorldModule {\n \t\t\t\tparts.add(new BuildingPart(this, area,\n \t\t\t\t\t\tarea.getPolygon(), useBuildingColors, drawBuildingWindows));\n \t\t\t} else {\n-\t\t\t\tList subtractPolygons = new ArrayList();\n-\t\t\t\t\n-\t\t\t\tfor (BuildingPart part : parts) {\n-\t\t\t\t\tsubtractPolygons.add(part.getPolygon().getOuter());\n-\t\t\t\t}\n-\t\t\t\tsubtractPolygons.addAll(area.getPolygon().getHoles());\n-\t\t\t\t\n-\t\t\t\tCollection remainingPolys =\n-\t\t\t\t\tCAGUtil.subtractPolygons(\n-\t\t\t\t\t\t\tarea.getPolygon().getOuter(),\n-\t\t\t\t\t\t\tsubtractPolygons);\n-\t\t\t\t\n-\t\t\t\tfor (PolygonWithHolesXZ remainingPoly : remainingPolys) {\n-\t\t\t\t\tparts.add(new BuildingPart(this, area, remainingPoly,\n-\t\t\t\t\t\t\tuseBuildingColors, drawBuildingWindows));\n-\t\t\t\t}\n-\t\t\t\t\n+//\t\t\t\tList subtractPolygons = new ArrayList();\n+//\t\t\t\t\n+//\t\t\t\tfor (BuildingPart part : parts) {\n+//\t\t\t\t\tsubtractPolygons.add(part.getPolygon().getOuter());\n+//\t\t\t\t}\n+//\t\t\t\tsubtractPolygons.addAll(area.getPolygon().getHoles());\n+//\t\t\t\t\n+//\t\t\t\tCollection remainingPolys =\n+//\t\t\t\t\tCAGUtil.subtractPolygons(\n+//\t\t\t\t\t\t\tarea.getPolygon().getOuter(),\n+//\t\t\t\t\t\t\tsubtractPolygons);\n+//\t\t\t\t\n+//\t\t\t\tfor (PolygonWithHolesXZ remainingPoly : remainingPolys) {\n+//\t\t\t\t\tparts.add(new BuildingPart(this, area, remainingPoly,\n+//\t\t\t\t\t\t\tuseBuildingColors, drawBuildingWindows));\n+//\t\t\t\t}\n+//\t\t\t\t\n \t\t\t}\n \n \t\t\t/* create connectors along the outline.\n@@ -319,19 +319,19 @@ public class BuildingModule extends ConfigurableWorldModule {\n \t\t\tthis.area = area;\n \t\t\tthis.polygon = polygon;\n \n-\t\t\tsetAttributes(useBuildingColors, drawBuildingWindows);\n-\t\t\t\n-\t\t\tfor (MapNode node : area.getBoundaryNodes()) {\n-\t\t\t\tif ((node.getTags().contains(\"building\", \"entrance\")\n-\t\t\t\t\t\t|| node.getTags().containsKey(\"entrance\"))\n-\t\t\t\t\t\t&& node.getRepresentations().isEmpty()) {\n-\t\t\t\t\t\n-\t\t\t\t\tBuildingEntrance entrance = new BuildingEntrance(this, node);\n-\t\t\t\t\tentrances.add(entrance);\n-\t\t\t\t\tnode.addRepresentation(entrance);\n-\t\t\t\t\t\n-\t\t\t\t}\n-\t\t\t}\n+\t\t\tsetAttributes(false, false);\n+\t\t\t\n+//\t\t\tfor (MapNode node : area.getBoundaryNodes()) {\n+//\t\t\t\tif ((node.getTags().contains(\"building\", \"entrance\")\n+//\t\t\t\t\t\t|| node.getTags().containsKey(\"entrance\"))\n+//\t\t\t\t\t\t&& node.getRepresentations().isEmpty()) {\n+//\t\t\t\t\t\n+//\t\t\t\t\tBuildingEntrance entrance = new BuildingEntrance(this, node);\n+//\t\t\t\t\tentrances.add(entrance);\n+//\t\t\t\t\tnode.addRepresentation(entrance);\n+//\t\t\t\t\t\n+//\t\t\t\t}\n+//\t\t\t}\n \t\t\t\n \t\t}\n \t\t\n@@ -349,10 +349,11 @@ public class BuildingModule extends ConfigurableWorldModule {\n \t\t\n \t\t@Override\n \t\tpublic void renderTo(Target target) {\n+\t\t\trenderFloor(target, 0);\n \t\t\t\n-\t\t\trenderWalls(target, roof);\n+//\t\t\trenderWalls(target, roof);\n \t\t\t\n-\t\t\troof.renderTo(target);\n+//\t\t\troof.renderTo(target);\n \t\t\t\n \t\t}\n \n@@ -380,8 +381,9 @@ public class BuildingModule extends ConfigurableWorldModule {\n \t\t\tdouble floorHeight = calculateFloorHeight(roof);\n \t\t\tboolean renderFloor = (floorHeight > 0);\n \t\t\t\n-\t\t\tif (area.getOverlaps().isEmpty()) {\n-\t\t\t\t\n+\t\t\tif (true || area.getOverlaps().isEmpty()) {\n+\t\t\t\t// Always draw buildings whole. Otherwise there may be\n+\t\t\t\t// eg. ground level tunnels through them, which would screw things up.\n \t\t\t\trenderWalls(target, roof.getPolygon(), false,\n \t\t\t\t\t\tbaseEle, floorHeight, roof);\n \t\t\t\t\n@@ -732,64 +734,68 @@ public class BuildingModule extends ConfigurableWorldModule {\n \t\t\t\n \t\t\t/* determine roof shape */\n \t\t\t\n-\t\t\tboolean explicitRoofTagging = true;\n-\t\t\t\n-\t\t\tif (!(\"no\".equals(area.getTags().getValue(\"roof:lines\"))) && hasComplexRoof(area)) {\n-\t\t\t\troof = new ComplexRoof();\n-\t\t\t} else {\n-\t\t\t\t\n-\t\t\t\tString roofShape = getValue(\"roof:shape\");\n-\t\t\t\tif (roofShape == null) { roofShape = getValue(\"building:roof:shape\"); }\n-\t\t\t\t\n-\t\t\t\tif (roofShape == null) {\n-\t\t\t\t\troofShape = defaultRoofShape;\n-\t\t\t\t\texplicitRoofTagging = false;\n-\t\t\t\t}\n-\t\t\t\t\n-\t\t\t\ttry {\n-\t\t\t\t\t\n-\t\t\t\t\tif (\"pyramidal\".equals(roofShape)) {\n-\t\t\t\t\t\troof = new PyramidalRoof();\n-\t\t\t\t\t} else if (\"onion\".equals(roofShape)) {\n-\t\t\t\t\t\troof = new OnionRoof();\n-\t\t\t\t\t} else if (\"skillion\".equals(roofShape)) {\n-\t\t\t\t\t\troof = new SkillionRoof();\n-\t\t\t\t\t} else if (\"gabled\".equals(roofShape)) {\n-\t\t\t\t\t\troof = new GabledRoof();\n-\t\t\t\t\t} else if (\"hipped\".equals(roofShape)) {\n-\t\t\t\t\t\troof = new HippedRoof();\n-\t\t\t\t\t} else if (\"half-hipped\".equals(roofShape)) {\n-\t\t\t\t\t\troof = new HalfHippedRoof();\n-\t\t\t\t\t} else if (\"gambrel\".equals(roofShape)) {\n-\t\t\t\t\t\troof = new GambrelRoof();\n-\t\t\t\t\t} else if (\"mansard\".equals(roofShape)) {\n-\t\t\t\t\t\troof = new MansardRoof();\n-\t\t\t\t\t} else if (\"dome\".equals(roofShape)) {\n-\t\t\t\t\t\troof = new DomeRoof();\n-\t\t\t\t\t} else if (\"round\".equals(roofShape)) {\n-\t\t\t\t\t\troof = new RoundRoof();\n-\t\t\t\t\t} else {\n-\t\t\t\t\t\troof = new FlatRoof();\n-\t\t\t\t\t}\n-\t\t\t\t\t\n-\t\t\t\t} catch (InvalidGeometryException e) {\n-\t\t\t\t\tSystem.err.println(\"falling back to FlatRoof: \" + e);\n-\t\t\t\t\troof = new FlatRoof();\n-\t\t\t\t\texplicitRoofTagging = false;\n-\t\t\t\t}\n-\t\t\t\t\n-\t\t\t}\n-\t\t\t\n+//\t\t\tboolean explicitRoofTagging = true;\n+//\t\t\t\n+//\t\t\tif (!(\"no\".equals(area.getTags().getValue(\"roof:lines\"))) && hasComplexRoof(area)) {\n+//\t\t\t\troof = new ComplexRoof();\n+//\t\t\t} else {\n+//\t\t\t\t\n+//\t\t\t\tString roofShape = getValue(\"roof:shape\");\n+//\t\t\t\tif (roofShape == null) { roofShape = getValue(\"building:roof:shape\"); }\n+//\t\t\t\t\n+//\t\t\t\tif (roofShape == null) {\n+//\t\t\t\t\troofShape = defaultRoofShape;\n+//\t\t\t\t\texplicitRoofTagging = false;\n+//\t\t\t\t}\n+//\t\t\t\t\n+//\t\t\t\ttry {\n+//\t\t\t\t\t\n+//\t\t\t\t\tif (\"pyramidal\".equals(roofShape)) {\n+//\t\t\t\t\t\troof = new PyramidalRoof();\n+//\t\t\t\t\t} else if (\"onion\".equals(roofShape)) {\n+//\t\t\t\t\t\troof = new OnionRoof();\n+//\t\t\t\t\t} else if (\"skillion\".equals(roofShape)) {\n+//\t\t\t\t\t\troof = new SkillionRoof();\n+//\t\t\t\t\t} else if (\"gabled\".equals(roofShape)) {\n+//\t\t\t\t\t\troof = new GabledRoof();\n+//\t\t\t\t\t} else if (\"hipped\".equals(roofShape)) {\n+//\t\t\t\t\t\troof = new HippedRoof();\n+//\t\t\t\t\t} else if (\"half-hipped\".equals(roofShape)) {\n+//\t\t\t\t\t\troof = new HalfHippedRoof();\n+//\t\t\t\t\t} else if (\"gambrel\".equals(roofShape)) {\n+//\t\t\t\t\t\troof = new GambrelRoof();\n+//\t\t\t\t\t} else if (\"mansard\".equals(roofShape)) {\n+//\t\t\t\t\t\troof = new MansardRoof();\n+//\t\t\t\t\t} else if (\"dome\".equals(roofShape)) {\n+//\t\t\t\t\t\troof = new DomeRoof();\n+//\t\t\t\t\t} else if (\"round\".equals(roofShape)) {\n+//\t\t\t\t\t\troof = new RoundRoof();\n+//\t\t\t\t\t} else {\n+//\t\t\t\t\t\troof = new FlatRoof();\n+//\t\t\t\t\t}\n+//\t\t\t\t\t\n+//\t\t\t\t} catch (InvalidGeometryException e) {\n+//\t\t\t\t\tSystem.err.println(\"falling back to FlatRoof: \" + e);\n+//\t\t\t\t\troof = new FlatRoof();\n+//\t\t\t\t\texplicitRoofTagging = false;\n+//\t\t\t\t}\n+//\t\t\t\t\n+//\t\t\t}\n+\n+\t\t\troof = new FlatRoof();\n+\t\t\tboolean explicitRoofTagging = false;\n+\n \t\t\t/* determine height */\n \t\t\t\n-\t\t\tdouble fallbackHeight = buildingLevels * defaultHeightPerLevel;\n-\t\t\t\n-\t\t\tfallbackHeight += roof.getRoofHeight();\n-\t\t\t\n-\t\t\tfallbackHeight = parseHeight(buildingTags, (float)fallbackHeight);\n-\t\t\t\n-\t\t\tdouble height = parseHeight(tags, (float)fallbackHeight);\n-\t\t heightWithoutRoof = height - roof.getRoofHeight();\n+//\t\t\tdouble fallbackHeight = buildingLevels * defaultHeightPerLevel;\n+//\t\t\t\n+//\t\t\tfallbackHeight += roof.getRoofHeight();\n+//\t\t\t\n+//\t\t\tfallbackHeight = parseHeight(buildingTags, (float)fallbackHeight);\n+//\t\t\t\n+//\t\t\tdouble height = parseHeight(tags, (float)fallbackHeight);\n+\t\t\tdouble height = 100f;\n+\t\t\theightWithoutRoof = height - roof.getRoofHeight();\n \t\t\t\n \t\t\t/* determine materials */\n \t\t \ndiff --git a/OSM2World/src/org/osm2world/core/world/modules/RailwayModule.java b/OSM2World/src/org/osm2world/core/world/modules/RailwayModule.java\nindex efaec57..11671b7 100644\n--- a/OSM2World/src/org/osm2world/core/world/modules/RailwayModule.java\n+++ b/OSM2World/src/org/osm2world/core/world/modules/RailwayModule.java\n@@ -40,7 +40,9 @@ public class RailwayModule extends ConfigurableWorldModule {\n \t\t\n \t\tfor (MapWaySegment segment : grid.getMapWaySegments()) {\n \t\t\tif (segment.getTags().containsAny(\"railway\", RAILWAY_VALUES)) {\n-\t\t\t\tsegment.addRepresentation(new Rail(segment));\n+\t\t\t\tif (! TunnelModule.isTunnel(segment.getTags())) {\n+\t\t\t\t\tsegment.addRepresentation(new Rail(segment));\n+\t\t\t\t}\n \t\t\t}\n \t\t}\n \t\t\n@@ -66,13 +68,16 @@ public class RailwayModule extends ConfigurableWorldModule {\n \t\n \tprivate static class Rail extends AbstractNetworkWaySegmentWorldObject\n \t\timplements RenderableToAllTargets, TerrainBoundaryWorldObject {\n+\n+\t\tprivate static float TM_SCALE = Float.parseFloat(System.getenv(\"TOUCH_MAPPER_SCALE\"));\n+\t\tprivate static float TM_EXTRUDER = Float.parseFloat(System.getenv(\"TOUCH_MAPPER_EXTRUDER_WIDTH\"));\n \t\t\n-\t\tprivate static final float GROUND_WIDTH = 2.25f;\n-\t\tprivate static final float RAIL_DIST = 1.5f;\n+\t\tprivate static float sizesScaling = TM_SCALE / 3100; // historically things were tuned for scale 3100\n+\n+\t\tprivate static final float GROUND_WIDTH = 2.25f * sizesScaling;\n+\t\tprivate static final float RAIL_DIST = 1.5f * sizesScaling;\n \t\n-\t\tprivate static final float SLEEPER_WIDTH = 2.0f;\n-\t\tprivate static final float SLEEPER_LENGTH = 0.75f;\n-\t\tprivate static final float SLEEPER_HEIGHT = 0.125f;\n+\t\tprivate static final float SLEEPER_HEIGHT = 0.125f * sizesScaling;\n \t\t\n \t\tprivate static final List RAIL_SHAPE = asList(\n \t\t\tnew VectorXYZ(-0.45f, 0, 0), new VectorXYZ(-0.1f, 0.1f, 0),\n@@ -132,37 +137,37 @@ public class RailwayModule extends ConfigurableWorldModule {\n \t\t\t\t\tgetOutline(false), getOutline(true),\n \t\t\t\t\t1 - ((GROUND_WIDTH - RAIL_DIST) / GROUND_WIDTH) / 2);\n \n-\t\t\tfor (List railLine : railLines) {\n-\t\t\t\t\n-\t\t\t\tList> stripVectors =\n-\t\t\t\t\tWorldModuleGeometryUtil.createShapeExtrusionAlong(\n-\t\t\t\t\tRAIL_SHAPE, railLine,\n-\t\t\t\t\tCollections.nCopies(railLine.size(), VectorXYZ.Y_UNIT));\n-\t\t\t\t\t\n-\t\t\t\tfor (List stripVector : stripVectors) {\n-\t\t\t\t\ttarget.drawTriangleStrip(Materials.RAIL_DEFAULT, stripVector, null);\n-\t\t\t\t}\n-\t\t\t\n-\t\t\t}\n-\t\t\t\n-\t\t\t\n-\t\t\t/* draw railway ties/sleepers */\n-\t\t\t\n-\t\t\tList sleeperPositions = GeometryUtil.equallyDistributePointsAlong(3, false,\n-\t\t\t\t\tgetStartWithOffset(), getEndWithOffset());\n-\t\t\t\t\t\t\n-\t\t\tfor (VectorXZ sleeperPosition : sleeperPositions) {\n-\t\t\t\n-\t\t\t\t//TODO interpolate ele, also using additional points inbetween\n-\t\t\t\t\n-//\t\t\t\tVectorXYZ sleeperPositionXYZ =\n-//\t\t\t\t\t\tsegment.getElevationProfile().getWithEle(sleeperPosition);\n-//\n-//\t\t\t\ttarget.drawBox(Materials.RAIL_SLEEPER_DEFAULT,\n-//\t\t\t\t\t\tsleeperPositionXYZ, segment.getDirection(),\n-//\t\t\t\t\t\tSLEEPER_HEIGHT, SLEEPER_WIDTH, SLEEPER_LENGTH);\n-\t\t\t\t\n-\t\t\t}\n+//\t\t\tfor (List railLine : railLines) {\n+//\t\t\t\t\n+//\t\t\t\tList> stripVectors =\n+//\t\t\t\t\tWorldModuleGeometryUtil.createShapeExtrusionAlong(\n+//\t\t\t\t\tRAIL_SHAPE, railLine,\n+//\t\t\t\t\tCollections.nCopies(railLine.size(), VectorXYZ.Y_UNIT));\n+//\t\t\t\t\t\n+//\t\t\t\tfor (List stripVector : stripVectors) {\n+//\t\t\t\t\ttarget.drawTriangleStrip(Materials.RAIL_DEFAULT, stripVector, null);\n+//\t\t\t\t}\n+//\t\t\t\n+//\t\t\t}\n+//\t\t\t\n+//\t\t\t\n+//\t\t\t/* draw railway ties/sleepers */\n+//\t\t\t\n+//\t\t\tList sleeperPositions = GeometryUtil.equallyDistributePointsAlong(3, false,\n+//\t\t\t\t\tgetStartWithOffset(), getEndWithOffset());\n+//\t\t\t\t\t\t\n+//\t\t\tfor (VectorXZ sleeperPosition : sleeperPositions) {\n+//\t\t\t\n+//\t\t\t\t//TODO interpolate ele, also using additional points inbetween\n+//\t\t\t\t\n+////\t\t\t\tVectorXYZ sleeperPositionXYZ =\n+////\t\t\t\t\t\tsegment.getElevationProfile().getWithEle(sleeperPosition);\n+////\n+////\t\t\t\ttarget.drawBox(Materials.RAIL_SLEEPER_DEFAULT,\n+////\t\t\t\t\t\tsleeperPositionXYZ, segment.getDirection(),\n+////\t\t\t\t\t\tSLEEPER_HEIGHT, SLEEPER_WIDTH, SLEEPER_LENGTH);\n+//\t\t\t\t\n+//\t\t\t}\n \t\t\t\n \t\t}\n \ndiff --git a/OSM2World/src/org/osm2world/core/world/modules/RoadModule.java b/OSM2World/src/org/osm2world/core/world/modules/RoadModule.java\nindex 66bc74f..b9a11b5 100644\n--- a/OSM2World/src/org/osm2world/core/world/modules/RoadModule.java\n+++ b/OSM2World/src/org/osm2world/core/world/modules/RoadModule.java\n@@ -61,21 +61,24 @@ public class RoadModule extends ConfigurableWorldModule {\n \t\t\n \t\tfor (MapWaySegment line : grid.getMapWaySegments()) {\n \t\t\tif (isRoad(line.getTags())) {\n-\t\t\t\tline.addRepresentation(new Road(line, line.getTags()));\n+\t\t\t\tif (! isTunnelOrSimilar(line.getTags())) {\n+\t\t\t\t\tline.addRepresentation(new Road(line, line.getTags()));\n+\t\t\t\t}\n \t\t\t}\n \t\t}\n \n \t\tfor (MapArea area : grid.getMapAreas()) {\n \t\t\t\t\n \t\t\tif (isRoad(area.getTags())) {\n-\t\t\t\t\n-\t\t\t\tList coords = new ArrayList();\n-\t\t\t\tfor (MapNode node : area.getBoundaryNodes()) {\n-\t\t\t\t\tcoords.add(node.getPos());\n+\t\t\t\tif (! isTunnelOrSimilar(area.getTags())) {\n+\t\t\t\t\tList coords = new ArrayList();\n+\t\t\t\t\tfor (MapNode node : area.getBoundaryNodes()) {\n+\t\t\t\t\t\tcoords.add(node.getPos());\n+\t\t\t\t\t}\n+\t\t\t\t\tcoords.remove(coords.size()-1);\n+\t\t\t\t\t\n+\t\t\t\t\tarea.addRepresentation(new RoadArea(area));\n \t\t\t\t}\n-\t\t\t\tcoords.remove(coords.size()-1);\n-\t\t\t\t\n-\t\t\t\tarea.addRepresentation(new RoadArea(area));\n \t\t\t}\n \t\t\t\n \t\t}\n@@ -86,7 +89,7 @@ public class RoadModule extends ConfigurableWorldModule {\n \t\t\t\n \t\t\tList connectedRoads = getConnectedRoads(node, false);\n \t\t\t\n-\t\t\tif (connectedRoads.size() > 2) {\n+\t\t\tif (connectedRoads.size() == 3) {\n \t\t\t\t\n \t\t\t\tnode.addRepresentation(new RoadJunction(node));\n \t\t\t\t\n@@ -112,6 +115,18 @@ public class RoadModule extends ConfigurableWorldModule {\n \t\t\n \t}\n \n+\tpublic static final boolean isTunnelOrSimilar(TagGroup tags) {\n+\t\tif (tags.containsKey(\"tunnel\")\n+\t\t\t\t&& !\"no\".equals(tags.getValue(\"tunnel\"))) {\n+\t\t\treturn true;\n+\t\t};\n+\t\tif (tags.containsKey(\"indoor\")\n+\t\t\t\t&& !\"no\".equals(tags.getValue(\"indoor\"))) {\n+\t\t\treturn true;\n+\t\t};\n+\t\treturn false;\n+\t}\n+\n \tprivate static boolean isRoad(TagGroup tags) {\n \t\tif (tags.containsKey(\"highway\")\n \t\t\t\t&& !tags.contains(\"highway\", \"construction\")\n@@ -119,15 +134,24 @@ public class RoadModule extends ConfigurableWorldModule {\n \t\t\treturn true;\n \t\t} else {\n \t\t\treturn tags.contains(\"railway\", \"platform\")\n-\t\t\t\t|| tags.contains(\"leisure\", \"track\");\n+\t\t\t\t|| tags.contains(\"leisure\", \"track\")\n+\t\t\t\t|| tags.contains(\"tourism\", \"attraction\")\n+\t\t\t\t|| tags.contains(\"man_made\", \"pier\")\n+\t\t\t\t|| tags.contains(\"man_made\", \"breakwater\");\n \t\t}\n \t}\n \t\n \tprivate static boolean isSteps(TagGroup tags) {\n-\t\treturn tags.contains(new Tag(\"highway\",\"steps\"));\n+\t\treturn false;\n+//\t\treturn tags.contains(new Tag(\"highway\",\"steps\"));\n \t}\n \n+\t// See also ObjTarget.isPath()\n \tprivate static boolean isPath(TagGroup tags) {\n+\t\tif (tags.contains(\"man_made\", \"pier\")\n+\t\t\t\t|| tags.contains(\"man_made\", \"breakwater\")) {\n+\t\t\treturn true;\n+\t\t}\n \t\tString highwayValue = tags.getValue(\"highway\");\n \t\treturn \"path\".equals(highwayValue)\n \t\t\t|| \"footway\".equals(highwayValue)\n@@ -339,6 +363,9 @@ public class RoadModule extends ConfigurableWorldModule {\n \t */\n \tprivate static List buildLaneConnections(\n \t\t\tMapNode node, boolean isJunction, boolean isCrossing) {\n+\t\tif (true) {\n+\t\t\treturn new ArrayList();\n+\t\t}\n \t\t\n \t\tList roads = getConnectedRoads(node, true);\n \t\t\n@@ -434,6 +461,9 @@ public class RoadModule extends ConfigurableWorldModule {\n \tprivate static List buildLaneConnections_allOneway(\n \t\t\tMapNode node, List inboundOnewayRoadsLTR,\n \t\t\tList outboundOnewayRoadsLTR) {\n+\t\tif (true) {\n+\t\t\treturn new ArrayList();\n+\t\t}\n \n \t\tList inboundLanes = new ArrayList();\n \t\tList outboundLanes = new ArrayList();\n@@ -754,7 +784,16 @@ public class RoadModule extends ConfigurableWorldModule {\n \tpublic static class Road\n \t\textends AbstractNetworkWaySegmentWorldObject\n \t\timplements RenderableToAllTargets, TerrainBoundaryWorldObject {\n-\t\t\n+\n+\t\tprivate static float TM_SCALE = Float.parseFloat(System.getenv(\"TOUCH_MAPPER_SCALE\"));\n+\t\tprivate static float TM_EXTRUDER = Float.parseFloat(System.getenv(\"TOUCH_MAPPER_EXTRUDER_WIDTH\"));\n+\n+\t\t// Using exactly extruder width will leave many roads unprinted. The ideal road width may\n+\t\t// be much less than the goal because edges where roads connect are not perpendicular\n+\t\t// to road direction. Further unevenness in road width is caused by fattening in Blender.\n+\t\t// Further, Simplify3D often uses value eg. 1.2x extruder width, depending on printer-dependent configuration.\n+\t\tprivate static final float ROAD_WIDTH_MULTIPLIER = 1.6f;\n+\n \t\tprotected static final float DEFAULT_LANE_WIDTH = 3.5f;\n \t\t\n \t\tprotected static final float DEFAULT_ROAD_CLEARING = 5;\n@@ -799,11 +838,15 @@ public class RoadModule extends ConfigurableWorldModule {\n \t\t\tthis.steps = isSteps(tags);\n \t\t\t\t\t\t\n \t\t\tif (steps) {\n+\t\t\t\t// Never executed\n \t\t\t\tthis.laneLayout = null;\n \t\t\t\tthis.width = parseWidth(tags, 1.0f);\n \t\t\t} else {\n \t\t\t\tthis.laneLayout = buildBasicLaneLayout();\n-\t\t\t\tthis.width = calculateWidth();\n+\t\t\t\tfloat mmToUnits = TM_SCALE / 1000;\n+\t\t\t\tfloat minRoadWidth = TM_EXTRUDER * ROAD_WIDTH_MULTIPLIER * mmToUnits;\n+\t\t\t\tfloat sizesScaling = TM_SCALE / 3100; // historically things were tuned for scale 3100\n+\t\t\t\tthis.width = Math.max(minRoadWidth, calculateWidth() * 0.8f * sizesScaling);\n \t\t\t\tlaneLayout.setCalculatedValues(width);\n \t\t\t}\n \t\t\t\ndiff --git a/OSM2World/src/org/osm2world/core/world/modules/WaterModule.java b/OSM2World/src/org/osm2world/core/world/modules/WaterModule.java\nindex 40e66c8..2be92c1 100644\n--- a/OSM2World/src/org/osm2world/core/world/modules/WaterModule.java\n+++ b/OSM2World/src/org/osm2world/core/world/modules/WaterModule.java\n@@ -45,6 +45,7 @@ public class WaterModule extends ConfigurableWorldModule {\n \n \t//TODO: add canal, ditch, drain\n \n+\tprivate static final float MIN_WATER_WIDTH = 2.2f;\n \tprivate static final Tag WATER_TAG = new Tag(\"natural\", \"water\");\n \tprivate static final Tag RIVERBANK_TAG = new Tag(\"waterway\", \"riverbank\");\n \t\n@@ -52,11 +53,11 @@ public class WaterModule extends ConfigurableWorldModule {\n \t\n \tstatic {\n \t\tWATERWAY_WIDTHS = new HashMap();\n-\t\tWATERWAY_WIDTHS.put(\"river\", 3f);\n-\t\tWATERWAY_WIDTHS.put(\"stream\", 0.5f);\n-\t\tWATERWAY_WIDTHS.put(\"canal\", 2f);\n-\t\tWATERWAY_WIDTHS.put(\"ditch\", 1f);\n-\t\tWATERWAY_WIDTHS.put(\"drain\", 1f);\n+\t\tWATERWAY_WIDTHS.put(\"river\", MIN_WATER_WIDTH * 1.5f);\n+\t\tWATERWAY_WIDTHS.put(\"stream\", MIN_WATER_WIDTH);\n+\t\tWATERWAY_WIDTHS.put(\"canal\", MIN_WATER_WIDTH * 1.2f);\n+\t\tWATERWAY_WIDTHS.put(\"ditch\", MIN_WATER_WIDTH);\n+\t\tWATERWAY_WIDTHS.put(\"drain\", MIN_WATER_WIDTH);\n \t}\n \t\n \t//TODO: apply to is almost always the same! create a superclass handling this!\n@@ -121,8 +122,10 @@ public class WaterModule extends ConfigurableWorldModule {\n \t\t}\n \t\t\n \t\tpublic float getWidth() {\n-\t\t\treturn WorldModuleParseUtil.parseWidth(segment.getTags(),\n-\t\t\t\t\tWATERWAY_WIDTHS.get(segment.getTags().getValue(\"waterway\")));\n+\t\t\treturn 2 * Math.max(\n+\t\t\t\t\t1,\n+\t\t\t\t\tWorldModuleParseUtil.parseWidth(segment.getTags(),\n+\t\t\t\t\tWATERWAY_WIDTHS.get(segment.getTags().getValue(\"waterway\"))));\n \t\t}\n \t\t\n \t\t@Override\n@@ -164,37 +167,37 @@ public class WaterModule extends ConfigurableWorldModule {\n \t\t\t\tList rightWaterBorder = createLineBetween(\n \t\t\t\t\t\tleftOutline, rightOutline, 0.95f);\n \t\t\t\t\n-\t\t\t\tmodifyLineHeight(leftWaterBorder, -0.2f);\n-\t\t\t\tmodifyLineHeight(rightWaterBorder, -0.2f);\n-\t\n-\t\t\t\tList leftGround = createLineBetween(\n-\t\t\t\t\t\tleftOutline, rightOutline, 0.35f);\n-\t\t\t\tList rightGround = createLineBetween(\n-\t\t\t\t\t\tleftOutline, rightOutline, 0.65f);\n-\t\t\t\t\n-\t\t\t\tmodifyLineHeight(leftGround, -1);\n-\t\t\t\tmodifyLineHeight(rightGround, -1);\n-\t\t\t\t\n-\t\t\t\t/* render ground */\n-\t\t\t\t\n-\t\t\t\t@SuppressWarnings(\"unchecked\") // generic vararg is intentional\n-\t\t\t\tList> strips = asList(\n-\t\t\t\t\tcreateTriangleStripBetween(\n-\t\t\t\t\t\t\tleftOutline, leftWaterBorder),\n-\t\t\t\t\tcreateTriangleStripBetween(\n-\t\t\t\t\t\t\tleftWaterBorder, leftGround),\n-\t\t\t\t\tcreateTriangleStripBetween(\n-\t\t\t\t\t\t\tleftGround, rightGround),\n-\t\t\t\t\tcreateTriangleStripBetween(\n-\t\t\t\t\t\t\trightGround, rightWaterBorder),\n-\t\t\t\t\tcreateTriangleStripBetween(\n-\t\t\t\t\t\t\trightWaterBorder, rightOutline)\n-\t\t\t\t);\n-\t\t\t\t\n-\t\t\t\tfor (List strip : strips) {\n-\t\t\t\t\ttarget.drawTriangleStrip(TERRAIN_DEFAULT, strip,\n-\t\t\t\t\t\ttexCoordLists(strip, TERRAIN_DEFAULT, GLOBAL_X_Z));\n-\t\t\t\t}\n+//\t\t\t\tmodifyLineHeight(leftWaterBorder, -0.2f);\n+//\t\t\t\tmodifyLineHeight(rightWaterBorder, -0.2f);\n+//\t\n+//\t\t\t\tList leftGround = createLineBetween(\n+//\t\t\t\t\t\tleftOutline, rightOutline, 0.35f);\n+//\t\t\t\tList rightGround = createLineBetween(\n+//\t\t\t\t\t\tleftOutline, rightOutline, 0.65f);\n+//\t\t\t\t\n+//\t\t\t\tmodifyLineHeight(leftGround, -1);\n+//\t\t\t\tmodifyLineHeight(rightGround, -1);\n+//\t\t\t\t\n+//\t\t\t\t/* render ground */\n+//\t\t\t\t\n+//\t\t\t\t@SuppressWarnings(\"unchecked\") // generic vararg is intentional\n+//\t\t\t\tList> strips = asList(\n+//\t\t\t\t\tcreateTriangleStripBetween(\n+//\t\t\t\t\t\t\tleftOutline, leftWaterBorder),\n+//\t\t\t\t\tcreateTriangleStripBetween(\n+//\t\t\t\t\t\t\tleftWaterBorder, leftGround),\n+//\t\t\t\t\tcreateTriangleStripBetween(\n+//\t\t\t\t\t\t\tleftGround, rightGround),\n+//\t\t\t\t\tcreateTriangleStripBetween(\n+//\t\t\t\t\t\t\trightGround, rightWaterBorder),\n+//\t\t\t\t\tcreateTriangleStripBetween(\n+//\t\t\t\t\t\t\trightWaterBorder, rightOutline)\n+//\t\t\t\t);\n+//\t\t\t\t\n+//\t\t\t\tfor (List strip : strips) {\n+//\t\t\t\t\ttarget.drawTriangleStrip(TERRAIN_DEFAULT, strip,\n+//\t\t\t\t\t\ttexCoordLists(strip, TERRAIN_DEFAULT, GLOBAL_X_Z));\n+//\t\t\t\t}\n \t\t\t\t\n \t\t\t\t/* render water */\n \t\t\t\t\n"
},
{
"path": "OSM2World/resources/osm2world_definitions.inc",
"content": "/*\n * This is an example for a POVRay include file that can be used to configure the rendering\n * of .pov files generated with OSM2World (http://osm2world.org/).\n *\n * You can leave out any definition from this file, the rendering will then fall back\n * to (mostly very basic) default materials and shapes.\n * Please be aware that many possible definitions are not listed in this example file.\n * Examine the \"material and object definitions\" section of a .pov file generated\n * by OSM2World to see what definitions are used by that particular scene.\n */\n\n#include \"metals.inc\"\n#include \"woods.inc\"\n#include \"textures.inc\"\n#include \"colors.inc\"\n\n// chooses the season - possible values: spring, summer, autumn, winter\n// (has no effect on the generated scenes yet, could be used in custom model declarations)\n#declare season=\"summer\"\n\n// chooses the time of day - possible values: day, night\n// (has no effect on the generated scenes yet, could be used in custom model declarations)\n#declare time=\"day\"\n\n// activate this #include if you have downloaded the tree models\n// that are available from http://osm2world.org/download (optional)\n// #include \"osm2world_trees.inc\"\n\n// texture definitions\n\n#declare texture_ASPHALT=texture { pigment { color rgb <0.2, 0.2, 0.2> } }\n#declare texture_WATER=texture { T_Chrome_2D normal { waves 0.2 frequency 1000.0 scale 4.0 turbulence 0.1 rotate <0,-45,0> } }\n#declare texture_WOOD=texture { T_Wood5 }\n#declare texture_TERRAIN_DEFAULT=texture { pigment { color rgb <0.2, 0.73, 0.2> } finish { ambient 0.5 diffuse 0.5 } }\n\n// sky sphere definition\n\n// activating this creates a pure blue sky.\n// This is useful when generating tiles. With patterned skies,\n// there will often be visible tile borders in reflecting water.\n//#declare sky_sphere_def = sky_sphere { pigment { rgb <0.0, 0.0, 1.0> } }\n\n\n// activating this creates reflective windows\n// However, you need a material map which is a indexed png with 3 colors:\n// Color 1 is for the transparent part, color 2 is for the window glass, color 3 \n// is for the rest of the window, i.e. the window frame \n//#declare texture_BUILDING_WINDOWS = texture { \n// material_map {\n// png \"./textures/transparent.png\"\n// texture { pigment { color rgb<0,0,0> transmit 1 } }\n// texture {\n// pigment { image_map {\n// png \"./textures/MarekCompositeWall00001_transparent.png\"\n// } }\n// finish {\n// ambient 0.5\n// diffuse 0.5\n// phong 1.0\n// phong_size 150\n// reflection 0.5\n// }\n// }\n// texture {\n// pigment { image_map {\n// png \"./textures/MarekCompositeWall00001_transparent.png\"\n// } }\n// finish {\n// ambient 0.5\n// diffuse 0.5\n// }\n// }\n// } }\n"
},
{
"path": "OSM2World/resources/shaders/background.fragment",
"content": "/* Simple fragment shader for drawing a 2d geometry with texture to screen\n */ \n#version 130\n\t\nuniform mat4 ModelViewMatrix;\n \n// corresponds with output from vertex shader, gets interpolated\nin vec2 TexCoord;\n \n// output to buffer\nout vec4 FragColor;\n\nuniform sampler2D Tex;\n\n\nvoid main()\n{\n\tFragColor = texture2D(Tex, TexCoord); \n} \n"
},
{
"path": "OSM2World/resources/shaders/background.vertex",
"content": "/* Simple vertex shader for drawing a 2d geometry with texture to screen\n */\n#version 130\n \n// per vertex input\nin vec2 VertexPosition;\nin vec2 VertexTexCoord;\n\n// input for at least primitives\nuniform mat4 ModelViewProjectionMatrix;\n\n// output to fragment shader for interpolation\nout vec2 TexCoord;\n \nvoid main()\n{\n\tTexCoord = VertexTexCoord;\n\tgl_Position = ModelViewProjectionMatrix * vec4(VertexPosition.x, VertexPosition.y, 0.0, 1.0);\n} \n"
},
{
"path": "OSM2World/resources/shaders/default.fragment",
"content": "/* Fragment shader with a per fragment phong lighting model, bumpmaps/normalmaps, shadowmaps and SSAO.\n */ \n#version 130\n// TODO: set from java to match MAX_TEXTURE_LAYERS there\n#define MAX_TEXTURE_LAYERS 4\n#define SSAO_RANDOM_ROTATION\n\t\nuniform bool isShadowed;\nuniform bool useLighting;\nstruct LightInfo {\n\tvec4 Position; // Light position in world coords.\n\tvec3 La; // Ambient light intensity\n\tvec3 Ld; // Diffuse light intensity\n\tvec3 Ls; // Specular light intensity\n};\nuniform LightInfo Light;\n\t\nstruct MaterialInfo {\n\tvec3 Color; // Material color\n\tfloat Ka; // Ambient reflectivity\n\tfloat Kd; // Diffuse reflectivity\n\tfloat Ks; // Specular reflectivity\n\tint Shininess; // Specular shininess factor\n};\nuniform MaterialInfo Material;\n\nuniform mat4 ModelViewMatrix;\nuniform mat4 ProjectionMatrix;\n \n// corresponds with output from vertex shader, gets interpolated\nin vec3 VertexEye;\nin vec3 NormalEye;\nin vec4 TangentEye;\nin vec2 BumpMapCoord;\nin vec4 ShadowCoord;\nin vec2 TexCoord0;\nin vec2 TexCoord1;\nin vec2 TexCoord2;\nin vec2 TexCoord3;\n\nuniform bool useTexture[MAX_TEXTURE_LAYERS];\nuniform sampler2D Tex[MAX_TEXTURE_LAYERS];\nuniform sampler2D BumpMap;\nuniform bool useShadowMap;\nuniform sampler2DShadow ShadowMap;\n\nuniform bool useSSAO;\nuniform sampler2D DepthMap;\nuniform sampler2D NoiseTex;\nuniform vec2 uNoiseScale;\nconst int MAX_KERNEL_SIZE = 128;\nconst float SSAO_SAMPLE_THRESHOLD = 0.15;\nuniform int uKernelSize;\nuniform vec3 uKernelOffsets[MAX_KERNEL_SIZE];\nuniform float uRadius = 1;\n\nuniform bool useAlphaTreshold;\nuniform float alphaTreshold;\n\nuniform bool useBumpMaps;\n \n// output to buffer\nout vec4 FragColor;\n\n/*\n * shading with phong model (ambient, diffuse, specular)\n * lightDir, viewDir and norm have to be in the same coordinate system (e.g. eye or tangent space)\n */\nvec3 phongModel( vec3 lightDir, vec3 viewDir, vec3 norm, out vec3 ambient, out vec3 diffuse, out vec3 spec )\n{\t\n\tvec3 r = reflect( -lightDir, norm );\n\tambient = Light.La;\n\tfloat sDotN = max( dot(lightDir,norm), 0.0 );\n\tdiffuse = Light.Ld * sDotN;\n\tspec = vec3(0.0);\n\tif( sDotN > 0.0 )\n\t\tspec = Light.Ls *\n\t\t\t\tpow( max( dot(r,viewDir), 0.0 ), Material.Shininess );\n\treturn ambient + diffuse + spec;\n}\n\nconst int levels = 3;\nconst float scaleFactor = 1.0 / levels;\n// toon shading (only ambient and diffuse)\nvec3 toonShade( vec3 lightDir, vec3 norm, out vec3 ambient, out vec3 diffuse )\n{\n\tambient = Light.La;\n\tfloat cosine = max( dot(lightDir,norm) , 0.0 );\n\tdiffuse = Light.Ld * floor( cosine * levels ) * scaleFactor;\n\t\n\treturn ambient + diffuse;\n}\n\n//float linearizeDepthPerspective(in float depth, in mat4 projMatrix) {\n//\treturn -projMatrix[3][2] / ((depth*2-1.0) + projMatrix[2][2]);\n//}\n\nfloat linearizeDepth(in float depth, in mat4 projMatrix) {\n\tfloat zNDC = depth*2-1.0;\n\treturn -(zNDC * projMatrix[3][3] - projMatrix[3][2]) / (zNDC * projMatrix[2][3] - projMatrix[2][2]);\n}\n\nfloat ssao( vec3 origin, vec3 normal, out vec3 debug )\n{\n\t/*\n\tvec3 rvec = texture(uTexRandom, vTexcoord * uNoiseScale).xyz * 2.0 - 1.0;\n\tvec3 tangent = normalize(rvec - normal * dot(rvec, normal));\n\tvec3 bitangent = cross(normal, tangent);\n\tmat3 tbn = mat3(tangent, bitangent, normal);\n\t*/\n#ifdef SSAO_RANDOM_ROTATION\n\t//vec3 rvec = texture(NoiseTex, gl_FragCoord.xy * uNoiseScale).xyz; \n\tvec3 rvec = texture(NoiseTex, gl_FragCoord.xy/4.0).xyz; \n\t//vec3 rvec = vec3(gl_FragCoord.xy, 0.0);\n#else \n\tvec3 rvec = vec3(1.0, 0.0, 0.0);\n#endif\n\tvec3 tangent = normalize(rvec - normal * dot(rvec, normal));\n\t//vec3 c1 = cross(normal, vec3(0.0, 0.0, 1.0));\n\t//vec3 c2 = cross(normal, vec3(0.0, 1.0, 0.0)); \n\t//tangent = normalize(length(c1) > length(c2) ? c1 : c2);\n\tvec3 bitangent = cross(normal, tangent);\n\tmat3 tbn = mat3(tangent, bitangent, normal);\n\t\n\tfloat occlusion = 0.0;\n\tint skipped = 0;\n\t// performance improvement: loop could be unrolled with constant kernel size\n\tfor (int i = 0; i < uKernelSize; ++i)\n\t{\n\t\t// get sample position:\n\t\tvec3 sample = tbn * (uKernelOffsets[i]);\n\t\t//vec3 sample = uKernelOffsets[i];\n\t\t/*if ( dot(sample, normal) < SSAO_SAMPLE_THRESHOLD )\n\t\t{\n\t\t\tskipped += 1;\n\t\t\tcontinue;\n\t\t}*/\n\t\tsample = sample * uRadius + origin;\n\t\t\n\t\t// project sample position:\n\t\tvec4 offset = vec4(sample, 1.0);\n\t\toffset = ProjectionMatrix * offset;\n\t\toffset.xy /= offset.w;\n\t\toffset.xy = offset.xy * 0.5 + 0.5;\n\t\t\n\t\t// skip samples outside of depth map texture\n\t\tif ( offset.x < 0 || offset.y < 0 || offset.x > 1 || offset.y > 1 )\n\t\t{\n\t\t\tskipped += 1;\n\t\t\tcontinue;\n\t\t}\n\t\t\n\t\t// get sample depth:\n\t\tfloat sampleDepth = texture(DepthMap, offset.xy).r;\n\t\tsampleDepth = linearizeDepth(sampleDepth, ProjectionMatrix);\n\t\t \n\t\t// range check & accumulate:\n\t\t//float rangeCheck= abs(origin.z - sampleDepth) < uRadius ? 1.0 : 0.0;\n\t\t//occlusion += (sampleDepth <= sample.z ? 1.0 : 0.0) * rangeCheck;\n\t\tfloat rangeCheck = smoothstep(0.0, 1.0, uRadius / abs(origin.z - sampleDepth));\n\t\tocclusion += rangeCheck * step(sample.z, sampleDepth);\n\t}\n\t\n\t//debug = tbn * vec3(0.0, 0.0, 1.0);\n\t//debug = vec3(skipped/float(255));\n\tdebug = rvec;\n\t\n\t/*vec4 test = ProjectionMatrix * vec4(origin, 1.0);\n\ttest.xy /= test.w;\n\ttest.xy = test.xy * 0.5 + 0.5;\n\tfloat d = texture(DepthMap, test.xy).r;\n\td = linearizeDepth(d, ProjectionMatrix);\n\treturn abs(origin.z - d);\n\treturn origin.z - linearizeDepth(((test.z / test.w)*0.5 + 0.5), ProjectionMatrix);\n\t//return 1.0 - abs(((test.z / test.w)*0.5 + 0.5) - d);\n\t*/\n\t\n\t// normalize and invert\n\tif ( uKernelSize > skipped )\n\t\tocclusion = 1.0 - (occlusion / float(uKernelSize-skipped));\n\telse\n\t\tocclusion = 1.0;\n\t//occlusion = occlusion / float(uKernelSize);\n\treturn occlusion;\n}\n \nvoid main()\n{\n\tvec3 ambient, diff, spec=vec3(0.0);\n\tvec4 texColor = vec4(1.0);\n\n\t// apply textures\n\t// TODO: autogenerate based on MAX_TEXTURE_LAYERS\n\tif ( useTexture[0] ) {\n\t\ttexColor = texture( Tex[0], TexCoord0 );\n\t}\n\ttexColor = texColor * vec4(Material.Color, 1.0); // color first layer only\n\tif ( useTexture[1] ) {\n\t\tvec4 layerColor = texture( Tex[1], TexCoord1 );\n\t\ttexColor = mix(texColor, vec4(layerColor.rgb,1), layerColor.a);\n\t}\n\tif ( useTexture[2] ) {\n\t\tvec4 layerColor = texture( Tex[2], TexCoord2 );\n\t\ttexColor = mix(texColor, vec4(layerColor.rgb,1), layerColor.a);\n\t}\n\tif ( useTexture[3] ) {\n\t\tvec4 layerColor = texture( Tex[3], TexCoord3 );\n\t\ttexColor = mix(texColor, vec4(layerColor.rgb,1), layerColor.a);\n\t}\n\t\n\tif ( useLighting ) {\n\t\tvec3 normalEye = normalize(NormalEye);\n\t\t\n\t\tfloat occlusionFactor = 1.0;\n\t\tvec3 debug = vec3(0.0);\n\t\tif ( useSSAO )\n\t\t\tocclusionFactor = ssao( VertexEye, normalEye, debug );\n\t\t\n\t\tif ( isShadowed ) {\n\t\t\tambient = Light.La;\n\t\t\tdiff = vec3(0.0);\n\t\t} else {\n\t\t\tvec3 viewDirection, lightDirection;\n\t\t\tvec4 lightPositionEye = ModelViewMatrix * Light.Position;\n\t\t\t\n\t\t\t// transform light and view direction to eye space\n\t\t\t\n\t\t\tif( ProjectionMatrix[3][3] == 0.0 )\n\t\t\t\tviewDirection = normalize(-VertexEye); // perspective projection\n\t\t\telse\n\t\t\t\tviewDirection = vec3(0.0, 0.0, 1.0); // orthographic projection: camera is infinite far away, so vertex coordinates don't matter\n\t\t\t\n\t\t\t// directional light?\n\t\t\tif( Light.Position.w == 0.0 )\n\t\t\t\tlightDirection = normalize(vec3(lightPositionEye));\n\t\t\telse\n\t\t\t\tlightDirection = normalize(vec3(lightPositionEye) - VertexEye);\n\t\t\t\n\t\t\tvec3 normal = normalEye;\n\t\t\tif ( useBumpMaps ) {\n\t\t\t\tvec3 tangentEye = normalize(TangentEye.xyz);\n\t\t\t\t// compute bitangent\n\t\t\t\tvec3 bitangentEye = normalize( cross( normalEye, tangentEye ) ) * TangentEye.w;\n\t\t\n\t\t\t\t// transformation from eye to tangent space\n\t\t\t\tmat3 tangentMatrix = mat3(\n\t\t\t\t\ttangentEye.x, bitangentEye.x, normalEye.x,\n\t\t\t\t\ttangentEye.y, bitangentEye.y, normalEye.y,\n\t\t\t\t\ttangentEye.z, bitangentEye.z, normalEye.z );\n\t\t\t\n\t\t\t\t// transform light and view direction to tangent space\n\t\t\t\tviewDirection = tangentMatrix * viewDirection;\n\t\t\t\tlightDirection = tangentMatrix * lightDirection;\n\t\t\t\tnormal = normalize(texture( BumpMap, BumpMapCoord ).xyz * 2.0 - 1.0);\n\t\t\t}\n\t\t\t\n\t\t\tphongModel( lightDirection, viewDirection, normal, ambient, diff, spec );\n\t\t\t//toonShade( lightDirection, normal, ambient, diff );\n\t\t}\n\t\t\n\t\t// shadow map lookup\n\t\tfloat shadowFactor = 1.0;\n\t\tif ( useShadowMap ) {\n\t\t\t//vec3 shadowCoordCart = ShadowCoord.xyz / ShadowCoord.w; // from homogene coordiantes to carthesian\n\t\t\t//float shadowDepthValue = texture(ShadowMap, shadowCoordCart.xy).r; // lookup of depth value in shadow map\n\t\t\t//float fragmentDepthValue = shadowCoordCart.z; // fragment depth value to compare\n\t\t\t//if (shadowDepthValue < fragmentDepthValue)\n\t\t\t//\tshadowFactor = 0.0; // in shadow\n\t\t\t\n\t\t\t// PCF (percentage closer filtering): blur with adjacent shadow map comparison results\n\t\t\tfloat sum = 0 ;\n\t\t\t// Sum contributions from texels around ShadowCoord\n\t\t\tsum += textureProjOffset(ShadowMap, ShadowCoord, ivec2(-1,-1));\n\t\t\tsum += textureProjOffset(ShadowMap, ShadowCoord, ivec2(-1,1));\n\t\t\tsum += textureProjOffset(ShadowMap, ShadowCoord, ivec2(1,1));\n\t\t\tsum += textureProjOffset(ShadowMap, ShadowCoord, ivec2(1,-1));\n\t\t\tshadowFactor = sum * 0.25;\n\t\t}\n\t\tif ( isShadowed )\n\t\t\tshadowFactor = 0.0;\n\t\t\n\t\tdiff = diff * shadowFactor * occlusionFactor;\n\t\tspec = spec * shadowFactor * occlusionFactor;\n\t\tambient = ambient * occlusionFactor;\n\t\t\n\t\tFragColor = vec4(ambient*Material.Ka + diff*Material.Kd, 1.0) * texColor + vec4(spec*Material.Ks, 0.0);\n\t\t//FragColor = texColor;\n\t\t//FragColor = vec4(occlusionFactor, occlusionFactor, occlusionFactor, FragColor.a);\n\t\t//FragColor = vec4(normalEye, FragColor.a);\n\t\t//FragColor = vec4(debug, FragColor.a);\n\t} else {\n\t\tFragColor = texColor;\n\t}\n\t\n\tif ( useAlphaTreshold ) {\n\t\tif ( FragColor.a < alphaTreshold )\n\t\t\tFragColor.a = 0.0;\n\t\telse\n\t\t\tFragColor.a = 1.0;\n\t}\n\t\t\n\tif( FragColor.a < 0.01 )\n\t\tdiscard;\n} \n"
},
{
"path": "OSM2World/resources/shaders/default.vertex",
"content": "/* Vertex shader with support for bumpmaps/normalmaps, shadowmaps and phong lighting model\n */\n#version 130\n// TODO: set from java to match MAX_TEXTURE_LAYERS there\n#define MAX_TEXTURE_LAYERS 4\n \n// per vertex input\nin vec3 VertexPosition;\nin vec3 VertexNormal;\nin vec4 VertexTangent;\nin vec2 VertexBumpMapCoord;\nin vec2 VertexTexCoord0;\nin vec2 VertexTexCoord1;\nin vec2 VertexTexCoord2;\nin vec2 VertexTexCoord3;\n\n// input for at least primitives\nuniform mat4 ProjectionMatrix;\nuniform mat4 ModelViewMatrix;\nuniform mat4 ModelViewProjectionMatrix;\nuniform mat4 NormalMatrix;\nuniform mat4 ShadowMatrix;\n\n// output to fragment shader for interpolation\nout vec3 VertexEye; // in eye space\nout vec3 NormalEye;\nout vec4 TangentEye; // last coordinate is the handedness to reconstruct the bitangent\nout vec2 BumpMapCoord;\nout vec4 ShadowCoord;\nout vec2 TexCoord0;\nout vec2 TexCoord1;\nout vec2 TexCoord2;\nout vec2 TexCoord3;\n\nvoid main()\n{\n\tTexCoord0 = VertexTexCoord0;\n\tTexCoord1 = VertexTexCoord1;\n\tTexCoord2 = VertexTexCoord2;\n\tTexCoord3 = VertexTexCoord3;\n\tBumpMapCoord = VertexBumpMapCoord;\n\t\n\t// Transform to eye coordinates\n\tNormalEye = normalize(vec3(NormalMatrix * vec4(VertexNormal, 1.0)));\n\tTangentEye = vec4(normalize(vec3(NormalMatrix * vec4(VertexTangent.xyz, 1.0))), VertexTangent.w);\n\tvec4 veye = ModelViewMatrix * vec4(VertexPosition, 1.0);\n\tVertexEye = veye.xyz / veye.w;\n\t\n\t// Transform to shadow coordinates\n\tShadowCoord = ShadowMatrix * vec4(VertexPosition, 1.0);\n\t\n\tgl_Position = ModelViewProjectionMatrix * vec4(VertexPosition, 1.0);\n} \n"
},
{
"path": "OSM2World/resources/shaders/nonarea.fragment",
"content": "/* Simple fragment shader with static color, no lighting, no textures\n */ \n#version 130\n \n// corresponds with output from vertex shader, gets interpolated\nin vec4 Color;\n \n// output to buffer\nout vec4 FragColor;\n \nvoid main()\n{\n\tFragColor = Color;\n} \n"
},
{
"path": "OSM2World/resources/shaders/nonarea.vertex",
"content": "/* Simple vertex shader with static color, no lighting, no textures\n */\n#version 130\n \n// per vertex input\nin vec3 VertexPosition;\nin vec4 VertexColor;\n\n// input for at least primitives\nuniform mat4 ModelViewProjectionMatrix;\n\n// output to fragment shader for interpolation\nout vec4 Color;\n \nvoid main()\n{\n\tColor = VertexColor;\n\tgl_Position = ModelViewProjectionMatrix * vec4(VertexPosition, 1.0);\n} \n"
},
{
"path": "OSM2World/resources/shaders/shadowmap.fragment",
"content": "/* Simple fragment shader with texture layers for depth buffer calculation\n */ \n#version 130\n// TODO: set from java to match MAX_TEXTURE_LAYERS there\n#define MAX_TEXTURE_LAYERS 4\n\n// corresponds with output from vertex shader, gets interpolated\nin vec2 TexCoord0;\nin vec2 TexCoord1;\nin vec2 TexCoord2;\nin vec2 TexCoord3;\n\nuniform bool useTexture[MAX_TEXTURE_LAYERS];\nuniform sampler2D Tex[MAX_TEXTURE_LAYERS];\n\nuniform bool useAlphaTreshold;\nuniform float alphaTreshold;\n \nvoid main()\n{\n\tfloat alpha = 1.0;\n\t\n\t// apply textures\n\t// TODO: autogenerate based on MAX_TEXTURE_LAYERS\n\tif ( useTexture[0] ) {\n\t\talpha = texture( Tex[0], TexCoord0 ).a;\n\t}\n\tif ( useTexture[1] ) {\n\t\tfloat layerAlpha = texture( Tex[1], TexCoord1 ).a;\n\t\talpha = mix(alpha, 1, layerAlpha);\n\t}\n\tif ( useTexture[2] ) {\n\t\tfloat layerAlpha = texture( Tex[2], TexCoord2 ).a;\n\t\talpha = mix(alpha, 1, layerAlpha);\n\t}\n\tif ( useTexture[3] ) {\n\t\tfloat layerAlpha = texture( Tex[3], TexCoord3 ).a;\n\t\talpha = mix(alpha, 1, layerAlpha);\n\t}\n\t\n\tif ( useAlphaTreshold ) {\n\t\tif ( alpha < alphaTreshold )\n\t\t\talpha = 0.0;\n\t\telse\n\t\t\talpha = 1.0;\n\t}\n\t\t\n\tif( alpha < 0.01 )\n\t\tdiscard;\n\t\n\t// nothing to output, only depth buffer needed\n} \n"
},
{
"path": "OSM2World/resources/shaders/shadowmap.vertex",
"content": "/* Simple vertex shader with vertex position texture layers computation\n */\n#version 130\n\n// per vertex input\nin vec3 VertexPosition;\nin vec2 VertexTexCoord0;\nin vec2 VertexTexCoord1;\nin vec2 VertexTexCoord2;\nin vec2 VertexTexCoord3;\n\n// input for at least primitives\nuniform mat4 ModelViewProjectionMatrix;\n\n// output to fragment shader for interpolation\nout vec2 TexCoord0;\nout vec2 TexCoord1;\nout vec2 TexCoord2;\nout vec2 TexCoord3;\n\nvoid main()\n{\n\tTexCoord0 = VertexTexCoord0;\n\tTexCoord1 = VertexTexCoord1;\n\tTexCoord2 = VertexTexCoord2;\n\tTexCoord3 = VertexTexCoord3;\n\t\n\tgl_Position = ModelViewProjectionMatrix * vec4(VertexPosition, 1.0);\n} \n"
},
{
"path": "OSM2World/resources/shaders/shadowvolume.fragment",
"content": "/* Empty fragment shader. Only depth buffer will be calculated.\n */ \n#version 130\n \nvoid main()\n{\t\n\t// nothing to output, only depth buffer needed\n} \n"
},
{
"path": "OSM2World/resources/shaders/shadowvolume.vertex",
"content": "/* Simple vertex shader with vertex position\n */\n#version 130\n\n// per vertex input\nin vec4 VertexPosition;\n\n// input for at least primitives\nuniform mat4 ModelViewProjectionMatrix;\n\nvoid main()\n{\n\tgl_Position = ModelViewProjectionMatrix * VertexPosition;\n} \n"
},
{
"path": "OSM2World/src/org/openstreetmap/josm/plugins/graphview/core/data/DataSource.java",
"content": "package org.openstreetmap.josm.plugins.graphview.core.data;\n\n/**\n * source of OSM data that can be used to build graphs from\n *\n * @param node type\n * @param way type\n * @param relation type\n */\npublic interface DataSource {\n\t\n\t/** returns all nodes */\n\tpublic Iterable getNodes();\n\n\t/** returns all ways */\n\tpublic Iterable getWays();\n\n\t/** returns all relations */\n\tpublic Iterable getRelations();\n\n\t/** returns a node's latitude */\n\tpublic double getLat(N node);\n\n\t/** returns a node's longitude */\n\tpublic double getLon(N node);\n\n\t/** returns a way's nodes */\n\tpublic Iterable getNodes(W way);\n\n\t/** returns a relation's members */\n\tpublic Iterable getMembers(R relation);\n\n\t/** returns a node's tags */\n\tpublic TagGroup getTagsN(N node);\n\n\t/** returns a way's tags */\n\tpublic TagGroup getTagsW(W way);\n\n\t/** returns a relation's tags */\n\tpublic TagGroup getTagsR(R relation);\n\n\t/** returns a relation member's role */\n\tpublic String getRole(M member);\n\n\t/** returns a relation member's member object */\n\tpublic Object getMember(M member);\n\t\n\t/** returns whether a relation member is a node */\n\tpublic boolean isNMember(M member);\n\t\n\t/** returns whether a relation member is a way */\n\tpublic boolean isWMember(M member);\n\t\n\t/** returns whether a relation member is a relation */\n\tpublic boolean isRMember(M member);\n\t\n\t/**\n\t * adds an observer.\n\t * Does nothing if the parameter is already an observer of this DataSource.\n\t *\n\t * @param observer observer object, != null\n\t */\n\tpublic void addObserver(DataSourceObserver observer);\n\n\t/**\n\t * deletes an observer that has been added using {@link #addObserver(DataSourceObserver)}.\n\t * Does nothing if the parameter isn't currently an observer of this DataSource.\n\t *\n\t * @param observer observer object, != null\n\t */\n\tpublic void deleteObserver(DataSourceObserver observer);\n\t\n}"
},
{
"path": "OSM2World/src/org/openstreetmap/josm/plugins/graphview/core/data/DataSourceObserver.java",
"content": "package org.openstreetmap.josm.plugins.graphview.core.data;\n\n/**\n * observer that will be informed about changes in a DataSource\n * if it has been registered using {@link DataSource#addObserver(DataSourceObserver)}.\n * Not every DataSource will send updates, because some don't change.\n */\npublic interface DataSourceObserver {\n\n\t/**\n\t * informs this observer about changes in an observed data source\n\t * @param dataSource observed data source that has changed; != null\n\t */\n\tpublic void update(DataSource dataSource);\n\n}\n"
},
{
"path": "OSM2World/src/org/openstreetmap/josm/plugins/graphview/core/data/EmptyTagGroup.java",
"content": "package org.openstreetmap.josm.plugins.graphview.core.data;\n\nimport java.util.Collections;\nimport java.util.Iterator;\n\npublic final class EmptyTagGroup implements TagGroup {\n\t\n\tpublic static final EmptyTagGroup EMPTY_TAG_GROUP = new EmptyTagGroup();\n\t\n\tprivate EmptyTagGroup() { }\n\t\n\t@Override\n\tpublic boolean contains(Tag tag) {\n\t\treturn false;\n\t}\n\t\n\t@Override\n\tpublic boolean containsAny(Iterable tag) {\n\t\treturn false;\n\t}\n\t\n\t@Override\n\tpublic boolean contains(String key, String value) {\n\t\treturn false;\n\t}\n\t\n\t@Override\n\tpublic boolean containsAny(Iterable key, String value) {\n\t\treturn false;\n\t}\n\t\n\t@Override\n\tpublic boolean containsAny(String key, Iterable values) {\n\t\treturn false;\n\t}\n\t\n\t@Override\n\tpublic boolean containsAny(Iterable keys, Iterable values) {\n\t\treturn false;\n\t}\n\t\n\t@Override\n\tpublic boolean containsAnyKey(Iterable keys) {\n\t\treturn false;\n\t}\n\t\t\n\t@Override\n\tpublic boolean containsKey(String key) {\n\t\treturn false;\n\t}\n\t\n\t@Override\n\tpublic boolean containsValue(String value) {\n\t\treturn false;\n\t}\n\t\n\t@Override\n\tpublic boolean containsAnyValue(Iterable value) {\n\t\treturn false;\n\t}\n\t\n\t@Override\n\tpublic String getValue(String key) {\n\t\treturn null;\n\t}\n\t\n\t@Override\n\tpublic int size() {\n\t\treturn 0;\n\t}\n\t\n\t@Override\n\tpublic boolean isEmpty() {\n\t\treturn true;\n\t}\n\t\n\t@Override\n\tpublic Iterator iterator() {\n\t\treturn Collections.emptyList().iterator();\n\t}\n\t\n\t@Override\n\tpublic String toString() {\n\t\treturn \"{}\";\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/openstreetmap/josm/plugins/graphview/core/data/MapBasedTagGroup.java",
"content": "package org.openstreetmap.josm.plugins.graphview.core.data;\n\nimport java.util.Collection;\nimport java.util.Collections;\nimport java.util.HashMap;\nimport java.util.Iterator;\nimport java.util.LinkedList;\nimport java.util.Map;\n\n/**\n * TagGroup that uses a key-value-Map to store tags\n */\npublic class MapBasedTagGroup implements TagGroup {\n\t\n\tprivate final Map tagMap;\n\t\n\t/**\n\t * @param tagMap map from keys to values; != null;\n\t * must not be modified after being used as parameter\n\t */\n\tpublic MapBasedTagGroup(Map tagMap) {\n\t\tif (tagMap == null) {\n\t\t\tthrow new IllegalArgumentException();\n\t\t}\n\t\t\n\t\tthis.tagMap = tagMap;\n\t}\n\t\n\t/**\n\t * @param tags tags to add to the group; != null, each != null\n\t */\n\tpublic MapBasedTagGroup(Iterable tags) {\n\t\tif (tags == null) {\n\t\t\tthrow new IllegalArgumentException();\n\t\t}\n\t\tthis.tagMap = new HashMap();\n\t\tfor (Tag tag : tags) {\n\t\t\tif (tag == null) {\n\t\t\t\tthrow new IllegalArgumentException();\n\t\t\t} else {\n\t\t\t\tthis.tagMap.put(tag.key, tag.value);\n\t\t\t}\n\t\t}\n\t}\n\t\n\t/**\n\t * @param tags tags to add to the group; each != null\n\t */\n\tpublic MapBasedTagGroup(Tag... tags) {\n\t\tthis.tagMap = new HashMap(tags.length);\n\t\tfor (Tag tag : tags) {\n\t\t\tif (tag == null) {\n\t\t\t\tthrow new IllegalArgumentException();\n\t\t\t} else {\n\t\t\t\tthis.tagMap.put(tag.key, tag.value);\n\t\t\t}\n\t\t}\n\t}\n\n\t@Override\n\tpublic String getValue(String key) {\n\t\tassert key != null;\n\t\treturn tagMap.get(key);\n\t}\n\n\t@Override\n\tpublic boolean containsKey(String key) {\n\t\tassert key != null;\n\t\treturn tagMap.containsKey(key);\n\t}\n\n\t@Override\n\tpublic boolean containsAnyKey(Iterable keys) {\n\t\tfor (String key : keys) {\n\t\t\tif (this.containsKey(key)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\n\t@Override\n\tpublic boolean containsValue(String value) {\n\t\tassert value != null;\n\t\treturn tagMap.containsValue(value);\n\t}\n\n\t@Override\n\tpublic boolean containsAnyValue(Iterable values) {\n\t\tfor (String value : values) {\n\t\t\tif (this.containsValue(value)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn false;\n\t}\n\n\t@Override\n\tpublic boolean contains(Tag tag) {\n\t\tassert tag != null;\n\t\treturn tag.value.equals(tagMap.get(tag.key));\n\t}\n\n\t@Override\n\tpublic boolean containsAny(Iterable tags) {\n\t\tfor (Tag tag : tags) {\n\t\t\tif (this.contains(tag)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\t\n\t@Override\n\tpublic boolean contains(String key, String value) {\n\t\tassert key != null;\n\t\tassert value != null;\n\t\treturn value.equals(tagMap.get(key));\n\t}\n\t\n\t@Override\n\tpublic boolean containsAny( Iterable keys, String value) {\n\t\tfor (String key : keys) {\n\t\t\tif (this.contains(key, value)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\t\n\t@Override\n\tpublic boolean containsAny(Iterable keys, Iterable values) {\n\t\tfor (String key : keys) {\n\t\t\tif (this.containsAny(key, values)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\n\t@Override\n\tpublic boolean containsAny(String key, Iterable values) {\n\t\tfor (String value : values) {\n\t\t\tif (this.contains(key, value)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn false;\n\t}\n\n\t@Override\n\tpublic int size() {\n\t\treturn tagMap.size();\n\t}\n\t\n\t@Override\n\tpublic boolean isEmpty() {\n\t\treturn tagMap.isEmpty();\n\t}\n\t\n\t/**\n\t * returns an Iterator providing access to all Tags.\n\t * The Iterator does not support the {@link Iterator#remove()} method.\n\t */\n\t@Override\n\tpublic Iterator iterator() {\n\t\t\n\t\tCollection tagCollection = new LinkedList();\n\t\t\n\t\tfor (String key : tagMap.keySet()) {\n\t\t\ttagCollection.add(new Tag(key, tagMap.get(key)));\n\t\t}\n\t\t\n\t\treturn Collections.unmodifiableCollection(tagCollection).iterator();\n\t\t\n\t}\n\t\n\t@Override\n\tpublic String toString() {\n\t\treturn tagMap.toString();\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/openstreetmap/josm/plugins/graphview/core/data/Tag.java",
"content": "package org.openstreetmap.josm.plugins.graphview.core.data;\n\n/**\n * immutable representation of an OSM tag (key-value-pair)\n */\npublic class Tag {\n\n\t/** key of the tag; != null */\n\tpublic final String key;\n\n\t/** value of the tag; != null */\n\tpublic final String value;\n\n\tpublic Tag(String key, String value) {\n\t\tassert key != null && value != null;\n\t\tthis.key = key;\n\t\tthis.value = value;\n\t}\n\n\t@Override\n\tpublic boolean equals(Object obj) {\n\t\tif (!(obj instanceof Tag)) {\n\t\t\treturn false;\n\t\t} else {\n\t\t\tTag otherTag = (Tag)obj;\n\t\t\treturn key.equals(otherTag.key) && value.equals(otherTag.value);\n\t\t}\n\t}\n\n\t@Override\n\tpublic int hashCode() {\n\t\treturn key.hashCode() + value.hashCode(); //TODO: might be a less than optimal hash function\n\t}\n\n\t@Override\n\tpublic String toString() {\n\t\treturn key + \"=\" + value;\n\t}\n\n}\n"
},
{
"path": "OSM2World/src/org/openstreetmap/josm/plugins/graphview/core/data/TagGroup.java",
"content": "package org.openstreetmap.josm.plugins.graphview.core.data;\n\n/**\n * represents a group of OSM tags (e.g. all tags of a way).\n * TagGroups are expected to be immutable, so modifying the tags means creation of a new group.\n * This interface requires that keys are unique, which is guaranteed since OSM API 0.6.\n */\npublic interface TagGroup extends Iterable {\n\t\n\t/**\n\t * returns the value for the given key or null if no tag in this group uses that key\n\t * @param key key whose value will be returned; != null\n\t */\n\tpublic String getValue(String key);\n\t\n\t/**\n\t * returns true if this tag group contains a tag with the given key\n\t * @param key key to check for; != null\n\t */\n\tpublic boolean containsKey(String key);\n\t\n\t/**\n\t * returns true if this tag group contains a tag with one of the given keys\n\t * @param keys keys to check for; != null\n\t */\n\tpublic boolean containsAnyKey(Iterable keys);\n\t\n\t/**\n\t * returns true if this tag group contains at least one tag with the given value\n\t * @param value value to check for; != null\n\t */\n\tpublic boolean containsValue(String value);\n\t\n\t/**\n\t * returns true if this tag group contains at least one tag with one of the given values\n\t * @param values values to check for; != null\n\t */\n\tpublic boolean containsAnyValue(Iterable values);\n\t\n\t/**\n\t * returns true if this tag group contains the given tag\n\t * @param tag tag to check for; != null\n\t */\n\tpublic boolean contains(Tag tag);\n\t\n\t/**\n\t * returns true if this tag group contains one of the given tags\n\t * @param tags tags to check for; != null\n\t */\n\tpublic boolean containsAny(Iterable tags);\n\t\n\t/**\n\t * returns true if this tag group contains the tag\n\t * @param key key of the tag to check for; != null\n\t * @param value value of the tag to check for; != null\n\t */\n\tpublic boolean contains(String key, String value);\n\t\n\t/**\n\t * returns true if this tag group contains one of the keys\n\t * with value\n\t * @param keys keys of the tag to check for; != null\n\t * @param value value of the tag to check for; != null\n\t */\n\tpublic boolean containsAny(Iterable keys, String value);\n\n\t/**\n\t * returns true if this tag group contains one of the keys\n\t * with one of the values\n\t * @param keys \t keys of the tag to check for; != null\n\t * @param values values of the tag to check for; != null\n\t */\n\tpublic boolean containsAny(Iterable keys, Iterable values);\n\t\n\t/**\n\t * returns true if this tag group contains the key with\n\t * one of the values\n\t * @param key key of the tag to check for; != null\n\t * @param values values of the tag to check for; != null\n\t */\n\tpublic boolean containsAny(String key, Iterable values);\n\t\n\t/**\n\t * returns the number of tags in this group\n\t */\n\tpublic int size();\n\t\n\t/**\n\t * returns true if this group contains any tags\n\t */\n\tpublic boolean isEmpty();\n\t\n}"
},
{
"path": "OSM2World/src/org/openstreetmap/josm/plugins/graphview/core/data/osmosis/OSMFileDataSource.java",
"content": "package org.openstreetmap.josm.plugins.graphview.core.data.osmosis;\n\nimport java.io.File;\nimport java.io.IOException;\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.HashMap;\nimport java.util.List;\nimport java.util.Map;\n\nimport org.openstreetmap.josm.plugins.graphview.core.data.DataSource;\nimport org.openstreetmap.josm.plugins.graphview.core.data.DataSourceObserver;\nimport org.openstreetmap.josm.plugins.graphview.core.data.MapBasedTagGroup;\nimport org.openstreetmap.josm.plugins.graphview.core.data.TagGroup;\nimport org.openstreetmap.osmosis.core.container.v0_6.EntityContainer;\nimport org.openstreetmap.osmosis.core.domain.v0_6.Entity;\nimport org.openstreetmap.osmosis.core.domain.v0_6.EntityType;\nimport org.openstreetmap.osmosis.core.domain.v0_6.Node;\nimport org.openstreetmap.osmosis.core.domain.v0_6.Relation;\nimport org.openstreetmap.osmosis.core.domain.v0_6.Tag;\nimport org.openstreetmap.osmosis.core.domain.v0_6.Way;\nimport org.openstreetmap.osmosis.core.domain.v0_6.WayNode;\nimport org.openstreetmap.osmosis.core.task.v0_6.Sink;\nimport org.openstreetmap.osmosis.xml.common.CompressionMethod;\nimport org.openstreetmap.osmosis.xml.v0_6.XmlReader;\n\n/**\n * DataSource providing information from a single .osm file. The file is read\n * during the constructor call, there will be no updates when the file is\n * changed later. This class uses osmosis to read the file.\n */\npublic class OSMFileDataSource implements\n\t\tDataSource {\n\t\n\tprivate static final boolean useDebugLabels = true;\n\t\n\tprivate boolean complete = false;\n\t\n\tprivate synchronized boolean isComplete() {\n\t\treturn complete;\n\t}\n\t\n\tprivate synchronized void setCompleteTrue() {\n\t\tthis.complete = true;\n\t}\n\t\n\tprivate Map nodesById = new HashMap();\n\tprivate Map waysById = new HashMap();\n\tprivate Map relationsById = new HashMap();\n\t\n\tprivate Collection ownNodes;\n\tprivate Collection ownWays;\n\tprivate Collection ownRelations;\n\t\n\tprivate final Sink sinkImplementation = new Sink() {\n\t\tpublic void initialize(Map arg0) {\n\t\t\t/* do nothing */\n\t\t}\n\t\tpublic void release() {\n\t\t\t/* do nothing */\n\t\t}\n\t\tpublic void complete() {\n\t\t\tsetCompleteTrue();\n\t\t}\n\t\tpublic void process(EntityContainer entityContainer) {\n\t\t\tEntity entity = entityContainer.getEntity();\n\t\t\tif (entity instanceof Node) {\n\t\t\t\tnodesById.put(entity.getId(), ((Node) entity));\n\t\t\t} else if (entity instanceof Way) {\n\t\t\t\twaysById.put(entity.getId(), ((Way) entity));\n\t\t\t} else if (entity instanceof Relation) {\n\t\t\t\trelationsById.put(entity.getId(), ((Relation) entity));\n\t\t\t}\n\t\t}\n\t};\n\t\n\tpublic OSMFileDataSource(File file) throws IOException {\n\t\t\n\t\tXmlReader reader = new XmlReader(file, false, CompressionMethod.None);\n\t\treader.setSink(sinkImplementation);\n\t\t\n\t\tThread readerThread = new Thread(reader);\n\t\treaderThread.start();\n\t\t\n\t\twhile (readerThread.isAlive()) {\n\t\t\ttry {\n\t\t\t\treaderThread.join();\n\t\t\t} catch (InterruptedException e) { /* do nothing */\n\t\t\t}\n\t\t}\n\t\t\n\t\tif (!isComplete()) {\n\t\t\tthrow new IOException(\"couldn't read from file\");\n\t\t}\n\t\t\n\t\tconvertToOwnRepresentation();\n\t\t\n\t}\n\t\n\tprivate void convertToOwnRepresentation() {\n\t\t\n\t\townNodes = new ArrayList(nodesById.size());\n\t\townWays = new ArrayList(waysById.size());\n\t\townRelations = new ArrayList(relationsById.size());\n\t\t\n\t\tMap nodeMap = new HashMap();\n\t\tMap wayMap = new HashMap();\n\t\tMap relationMap = new HashMap();\n\t\t\n\t\tfor (Node node : nodesById.values()) {\n\t\t\t\n\t\t\tOwnNode ownNode = new OwnNode(node.getLatitude(), node\n\t\t\t\t\t.getLongitude(), tagGroupForEntity(node));\n\t\t\t\n\t\t\townNodes.add(ownNode);\n\t\t\tnodeMap.put(node, ownNode);\n\t\t\t\n\t\t}\n\t\t\n\t\tfor (Way way : waysById.values()) {\n\t\t\t\n\t\t\tList origWayNodes = way.getWayNodes();\n\t\t\tList wayNodes = new ArrayList(origWayNodes.size());\n\t\t\tfor (WayNode origWayNode : origWayNodes) {\n\t\t\t\tNode origNode = nodesById.get(origWayNode.getNodeId());\n\t\t\t\twayNodes.add(nodeMap.get(origNode));\n\t\t\t}\n\t\t\t\n\t\t\tOwnWay ownWay = new OwnWay(tagGroupForEntity(way), wayNodes);\n\t\t\t\n\t\t\townWays.add(ownWay);\n\t\t\twayMap.put(way, ownWay);\n\t\t\t\n\t\t}\n\t\t\n\t\tfor (Relation relation : relationsById.values()) {\n\t\t\t\n\t\t\tOwnRelation ownRelation = new OwnRelation(\n\t\t\t\t\ttagGroupForEntity(relation), relation.getMembers().size());\n\t\t\t\n\t\t\townRelations.add(ownRelation);\n\t\t\trelationMap.put(relation, ownRelation);\n\t\t\t\n\t\t}\n\t\t\n\t\t// add relation members\n\t\t// (needs to be done *after* creation because relations can be members\n\t\t// of other relations)\n\t\t\n\t\tfor (Relation relation : relationMap.keySet()) {\n\t\t\t\n\t\t\tOwnRelation ownRelation = relationMap.get(relation);\n\t\t\t\n\t\t\tfor (org.openstreetmap.osmosis.core.domain.v0_6.RelationMember member : relation\n\t\t\t\t\t.getMembers()) {\n\t\t\t\t\n\t\t\t\tObject memberObject = null;\n\t\t\t\tif (member.getMemberType() == EntityType.Node) {\n\t\t\t\t\tmemberObject = nodeMap.get(nodesById.get(member\n\t\t\t\t\t\t\t.getMemberId()));\n\t\t\t\t} else if (member.getMemberType() == EntityType.Way) {\n\t\t\t\t\tmemberObject = wayMap.get(waysById\n\t\t\t\t\t\t\t.get(member.getMemberId()));\n\t\t\t\t} else if (member.getMemberType() == EntityType.Relation) {\n\t\t\t\t\tmemberObject = relationMap.get(relationsById.get(member\n\t\t\t\t\t\t\t.getMemberId()));\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tOwnMember ownMember = new OwnMember(member\n\t\t\t\t\t\t.getMemberRole(), memberObject);\n\t\t\t\t\n\t\t\t\townRelation.relationMembers.add(ownMember);\n\t\t\t}\n\t\t\t\n\t\t}\n\t\t\n\t\t// give up references to original collections\n\t\t\n\t\tnodesById = null;\n\t\twaysById = null;\n\t\trelationsById = null;\n\t\t\n\t}\n\t\n\tprivate TagGroup tagGroupForEntity(Entity entity) {\n\t\tMap tagMap = new HashMap(entity.getTags().size());\n\t\tfor (Tag tag : entity.getTags()) {\n\t\t\ttagMap.put(tag.getKey(), tag.getValue());\n\t\t}\n\t\treturn new MapBasedTagGroup(tagMap);\n\t}\n\t\n\tpublic void addObserver(DataSourceObserver observer) {\n\t\t// OSMFileDataSource doesn't check for updates\n\t}\n\t\n\tpublic void deleteObserver(DataSourceObserver observer) {\n\t\t// OSMFileDataSource doesn't check for updates\n\t}\n\t\n\tpublic double getLat(OwnNode node) {\n\t\treturn node.lat;\n\t}\n\t\n\tpublic double getLon(OwnNode node) {\n\t\treturn node.lon;\n\t}\n\t\n\tpublic List getMembers(OwnRelation relation) {\n\t\treturn relation.relationMembers;\n\t}\n\t\n\tpublic Collection getNodes() {\n\t\treturn ownNodes;\n\t}\n\t\n\tpublic Collection getWays() {\n\t\treturn ownWays;\n\t}\n\t\n\tpublic Collection getRelations() {\n\t\treturn ownRelations;\n\t}\n\t\n\tpublic List getNodes(OwnWay way) {\n\t\treturn way.nodes;\n\t}\n\t\n\tpublic TagGroup getTagsN(OwnNode node) {\n\t\treturn node.tags;\n\t}\n\t\n\tpublic TagGroup getTagsR(OwnRelation relation) {\n\t\treturn relation.tags;\n\t}\n\t\n\tpublic TagGroup getTagsW(OwnWay way) {\n\t\treturn way.tags;\n\t}\n\t\n\tpublic Object getMember(OwnMember member) {\n\t\treturn member.member;\n\t}\n\t\n\tpublic String getRole(OwnMember member) {\n\t\treturn member.role;\n\t}\n\t\n\tpublic boolean isNMember(OwnMember member) {\n\t\treturn member.member instanceof OwnNode;\n\t};\n\t\n\tpublic boolean isWMember(OwnMember member) {\n\t\treturn member.member instanceof OwnWay;\n\t};\n\t\n\tpublic boolean isRMember(OwnMember member) {\n\t\treturn member.member instanceof OwnRelation;\n\t};\n\t\n\tpublic class OwnNode {\n\t\tprivate final double lat;\n\t\tprivate final double lon;\n\t\tprivate final TagGroup tags;\n\t\t\n\t\tpublic OwnNode(double lat, double lon, TagGroup tags) {\n\t\t\tthis.lat = lat;\n\t\t\tthis.lon = lon;\n\t\t\tthis.tags = tags;\n\t\t}\n\t\t\n\t\t@Override\n\t\tpublic String toString() {\n\t\t\tif (useDebugLabels && tags.containsKey(\"debug:label\")) {\n\t\t\t\treturn tags.getValue(\"debug:label\");\n\t\t\t}\n\t\t\treturn \"(\" + lat + \", \" + lon + \", \" + tags + \")\";\n\t\t}\n\t\t\n\t}\n\t\n\tpublic class OwnWay {\n\t\tprivate final TagGroup tags;\n\t\tprivate final List nodes;\n\t\t\n\t\tpublic OwnWay(TagGroup tags, List nodes) {\n\t\t\tthis.tags = tags;\n\t\t\tthis.nodes = nodes;\n\t\t}\n\t\t\n\t\t@Override\n\t\tpublic String toString() {\n\t\t\t\n\t\t\tif (useDebugLabels && tags.containsKey(\"debug:label\")) {\n\t\t\t\treturn tags.getValue(\"debug:label\");\n\t\t\t}\n\t\t\t\n\t\t\treturn nodes.get(0)\n\t\t\t\t+ \"->[\" + (nodes.size() - 2) + \"]->\"\n\t\t\t\t+ nodes.get(nodes.size()-1);\n\t\t\t\n\t\t}\n\t\t\n\t}\n\t\n\tpublic class OwnRelation {\n\t\t\n\t\tprivate final TagGroup tags;\n\t\t\n\t\tprivate final List relationMembers;\n\t\t\t// content added after constructor call\n\t\t\n\t\tpublic OwnRelation(TagGroup tags, int initialMemberSize) {\n\t\t\tthis.tags = tags;\n\t\t\tthis.relationMembers =\n\t\t\t\tnew ArrayList(initialMemberSize);\n\t\t}\n\t}\n\t\n\tpublic static class OwnMember {\n\t\tprivate final String role;\n\t\tprivate final Object member;\n\t\t\n\t\tpublic OwnMember(String role, Object member) {\n\t\t\tthis.role = role;\n\t\t\tthis.member = member;\n\t\t}\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/openstreetmap/josm/plugins/graphview/core/util/ValueStringParser.java",
"content": "package org.openstreetmap.josm.plugins.graphview.core.util;\n\nimport java.awt.Color;\nimport java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\npublic final class ValueStringParser {\n\n\t/** prevents instantiation */\n\tprivate ValueStringParser() { }\n\n\t/** pattern that splits into a part before and after a decimal point */\n\tprivate static final Pattern DEC_POINT_PATTERN = Pattern.compile(\"^(\\\\-?\\\\d+)\\\\.(\\\\d+)$\");\n\n\tpublic static final Float parseOsmDecimal(String value, boolean allowNegative) {\n\n\t\t/* positive integer */\n\n\t\ttry {\n\n\t\t\tint weight = Integer.parseInt(value);\n\t\t\tif (weight >= 0 || allowNegative) {\n\t\t\t\treturn (float)weight;\n\t\t\t}\n\n\t\t} catch (NumberFormatException nfe) {}\n\n\t\t/* positive number with decimal point */\n\n\t\tMatcher matcher = DEC_POINT_PATTERN.matcher(value);\n\n\t\tif (matcher.matches()) {\n\n\t\t\tString stringBeforePoint = matcher.group(1);\n\t\t\tString stringAfterPoint = matcher.group(2);\n\n\t\t\tif (stringBeforePoint.length() > 0 || stringAfterPoint.length() > 0) {\n\n\t\t\t\ttry {\n\n\t\t\t\t\tboolean negative = stringBeforePoint.startsWith(\"-\");\n\t\t\t\t\t\n\t\t\t\t\tfloat beforePoint = Integer.parseInt(stringBeforePoint);\n\t\t\t\t\tfloat afterPoint = Integer.parseInt(stringAfterPoint);\n\n\t\t\t\t\tdouble result = Math.abs(beforePoint)\n\t\t\t\t\t\t\t+ Math.pow(10, -stringAfterPoint.length()) * afterPoint;\n\t\t\t\t\tif (negative) { result = - result; }\n\t\t\t\t\t\n\t\t\t\t\tif (result >= 0 || allowNegative) {\n\t\t\t\t\t\treturn (float)result;\n\t\t\t\t\t}\n\n\t\t\t\t} catch (NumberFormatException nfe) {}\n\n\t\t\t}\n\t\t}\n\n\t\treturn null;\n\t}\n\n\tprivate static final Pattern KMH_PATTERN = Pattern.compile(\"^(\\\\d+)\\\\s*km/h$\");\n\tprivate static final Pattern MPH_PATTERN = Pattern.compile(\"^(\\\\d+)\\\\s*mph$\");\n\n\tprivate static final float KM_PER_MILE = 1.609344f;\n\n\t/**\n\t * parses a speed value given e.g. for the \"maxspeed\" key.\n\t *\n\t * @return speed in km/h; null if value had syntax errors\n\t */\n\tpublic static final Float parseSpeed(String value) {\n\n\t\t/* try numeric speed (implied km/h) */\n\n\t\tFloat speed = parseOsmDecimal(value, false);\n\t\tif (speed != null) {\n\t\t\treturn speed;\n\t\t}\n\n\t\t/* try km/h speed */\n\n\t\tMatcher kmhMatcher = KMH_PATTERN.matcher(value);\n\t\tif (kmhMatcher.matches()) {\n\t\t\tString kmhString = kmhMatcher.group(1);\n\t\t\ttry {\n\t\t\t\treturn (float)Integer.parseInt(kmhString);\n\t\t\t} catch (NumberFormatException nfe) {}\n\t\t}\n\n\t\t/* try mph speed */\n\n\t\tMatcher mphMatcher = MPH_PATTERN.matcher(value);\n\t\tif (mphMatcher.matches()) {\n\t\t\tString mphString = mphMatcher.group(1);\n\t\t\ttry {\n\t\t\t\tint mph = Integer.parseInt(mphString);\n\t\t\t\treturn KM_PER_MILE * mph;\n\t\t\t} catch (NumberFormatException nfe) {}\n\t\t}\n\n\t\t/* all possibilities failed */\n\n\t\treturn null;\n\t}\n\n\tprivate static final Pattern M_PATTERN = Pattern.compile(\"^([\\\\d\\\\.]+)\\\\s*m$\");\n\tprivate static final Pattern KM_PATTERN = Pattern.compile(\"^([\\\\d\\\\.]+)\\\\s*km$\");\n\tprivate static final Pattern MI_PATTERN = Pattern.compile(\"^([\\\\d\\\\.]+)\\\\s*mi$\");\n\tprivate static final Pattern FEET_INCHES_PATTERN = Pattern.compile(\"^([\\\\d]+)'\\\\s*([\\\\d]+)\\\"\");\n\n\tprivate static final double M_PER_MI = 1609.344;\n\tprivate static final double M_PER_INCH = 0.0254f;\n\n\t/**\n\t * parses a measure value given e.g. for the \"width\" or \"length\" key.\n\t *\n\t * @return measure in m; null if value had syntax errors\n\t */\n\tpublic static final Float parseMeasure(String value) {\n\n\t\t/* try numeric measure (implied m) */\n\n\t\tFloat measure = parseOsmDecimal(value, false);\n\t\tif (measure != null) {\n\t\t\treturn measure;\n\t\t}\n\n\t\t/* try m measure */\n\n\t\tMatcher mMatcher = M_PATTERN.matcher(value);\n\t\tif (mMatcher.matches()) {\n\t\t\tString mString = mMatcher.group(1);\n\t\t\treturn parseOsmDecimal(mString, false);\n\t\t}\n\n\t\t/* try km measure */\n\n\t\tMatcher kmMatcher = KM_PATTERN.matcher(value);\n\t\tif (kmMatcher.matches()) {\n\t\t\tString kmString = kmMatcher.group(1);\n\t\t\tfloat km = parseOsmDecimal(kmString, false);\n\t\t\treturn 1000 * km;\n\t\t}\n\n\t\t/* try mi measure */\n\n\t\tMatcher miMatcher = MI_PATTERN.matcher(value);\n\t\tif (miMatcher.matches()) {\n\t\t\tString miString = miMatcher.group(1);\n\t\t\tfloat mi = parseOsmDecimal(miString, false);\n\t\t\treturn (float)(M_PER_MI * mi);\n\t\t}\n\n\t\t/* try feet/inches measure */\n\n\t\tMatcher feetInchesMatcher = FEET_INCHES_PATTERN.matcher(value);\n\t\tif (feetInchesMatcher.matches()) {\n\t\t\tString feetString = feetInchesMatcher.group(1);\n\t\t\tString inchesString = feetInchesMatcher.group(2);\n\t\t\ttry {\n\t\t\t\tint feet = Integer.parseInt(feetString);\n\t\t\t\tint inches = Integer.parseInt(inchesString);\n\t\t\t\tif (feet >= 0 && inches >= 0 && inches < 12) {\n\t\t\t\t\treturn (float)(M_PER_INCH * (12 * feet + inches));\n\t\t\t\t}\n\t\t\t} catch (NumberFormatException nfe) {}\n\t\t}\n\n\t\t/* all possibilities failed */\n\n\t\treturn null;\n\t}\n\n\tprivate static final Pattern T_PATTERN = Pattern.compile(\"^([\\\\d\\\\.]+)\\\\s*t$\");\n\n\t/**\n\t * parses a weight value given e.g. for the \"maxweight\" or \"maxaxleload\" key.\n\t *\n\t * @return weight in t; null if value had syntax errors\n\t */\n\tpublic static Float parseWeight(String value) {\n\n\t\t/* try numeric weight (implied t) */\n\n\t\tFloat weight = parseOsmDecimal(value, false);\n\t\tif (weight != null) {\n\t\t\treturn weight;\n\t\t}\n\n\t\t/* try t weight */\n\n\t\tMatcher tMatcher = T_PATTERN.matcher(value);\n\t\tif (tMatcher.matches()) {\n\t\t\tString tString = tMatcher.group(1);\n\t\t\treturn parseOsmDecimal(tString, false);\n\t\t}\n\n\t\t/* all possibilities failed */\n\n\t\treturn null;\n\n\t}\n\n\tprivate static final Pattern INCLINE_PATTERN = Pattern.compile(\"^(\\\\-?\\\\d+(?:\\\\.\\\\d+)?)\\\\s*%$\");\n\n\t/**\n\t * parses an incline value as given for the \"incline\" key.\n\t *\n\t * @return incline in percents; null if value had syntax errors\n\t */\n\tpublic static final Float parseIncline(String value) {\n\n\t\tMatcher inclineMatcher = INCLINE_PATTERN.matcher(value);\n\t\tif (inclineMatcher.matches()) {\n\t\t\tString inclineString = inclineMatcher.group(1);\n\t\t\treturn parseOsmDecimal(inclineString, true);\n\t\t}\n\n\t\treturn null;\n\t}\n\n\t/**\n\t * parses an angular value as given for the \"direction\" key.\n\t *\n\t * @return angle in degrees measured from north, range [0, 360[;\n\t * null if value had syntax errors\n\t */\n\tpublic static final Float parseAngle(String value) {\n\n\t\t/* try numeric angle */\n\t\t\n\t\tFloat measure = parseOsmDecimal(value, false);\n\t\tif (measure != null) {\n\t\t\treturn measure % 360;\n\t\t}\n\t\t\n\t\t/* try cardinal directions (represented by letters) */\n\n\t\tif (\"N\" .equals(value)) { return 0.0f; }\n\t\tif (\"NNE\".equals(value)) { return 22.5f; }\n\t\tif (\"NE\" .equals(value)) { return 45.0f; }\n\t\tif (\"ENE\".equals(value)) { return 67.5f; }\n\t\tif (\"E\" .equals(value)) { return 90.0f; }\n\t\tif (\"ESE\".equals(value)) { return 112.5f; }\n\t\tif (\"SE\" .equals(value)) { return 135.0f; }\n\t\tif (\"SSE\".equals(value)) { return 157.5f; }\n\t\tif (\"S\" .equals(value)) { return 180.0f; }\n\t\tif (\"SSW\".equals(value)) { return 202.5f; }\n\t\tif (\"SW\" .equals(value)) { return 225.0f; }\n\t\tif (\"WSW\".equals(value)) { return 247.5f; }\n\t\tif (\"W\" .equals(value)) { return 270.0f; }\n\t\tif (\"WNW\".equals(value)) { return 292.5f; }\n\t\tif (\"NW\" .equals(value)) { return 315.0f; }\n\t\tif (\"NNW\".equals(value)) { return 337.5f; }\n\t\t\n\t\treturn null;\n\t}\n\n\t/**\n\t * parses an hexadecimal color value\n\t *\n\t * @return color; null if value had syntax errors\n\t */\n\tpublic static final Color parseColor(String value) {\n\t\t\n\t\ttry {\n\t\t\treturn Color.decode(value);\n\t\t} catch (NumberFormatException e) {\n\t\t\treturn null;\n\t\t}\n\t\t\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/console/CLIArguments.java",
"content": "package org.osm2world.console;\n\nimport java.io.File;\nimport java.util.List;\n\nimport org.osm2world.core.target.common.rendering.OrthoTilesUtil.CardinalDirection;\nimport org.osm2world.core.target.common.rendering.TileNumber;\n\nimport uk.co.flamingpenguin.jewel.cli.Option;\n\npublic interface CLIArguments {\n\t\n\tpublic static final String OUTPUT_PATTERN = \"(.*)\\\\.(?:obj|pov|png|ppm|gd)\";\n\t\n\t/* input and output */\n\t\n\t@Option(description=\"the .osm input file\", shortName=\"i\")\n\tFile getInput();\n\tboolean isInput();\n\t\n\t@Option(description=\"output files\", shortName=\"o\", pattern=OUTPUT_PATTERN)\n\tList getOutput();\n\tboolean isOutput();\n\t\n\t@Option(description=\"properties file with configuration parameters\")\n\tFile getConfig();\n\tboolean isConfig();\n\t\n\t@Option(description=\"output size in pixels\", pattern=Resolution.PATTERN,\n\t\t\tdefaultValue=\"800,600\")\n\tResolution getResolution();\n\tboolean isResolution();\n\t\n\t/* camera */\n\t\n\t@Option(description=\"downwards angle of orthographic view in degrees\",\n\t\t\tlongName=\"oview.angle\", defaultValue=\"30\")\n\tdouble getOviewAngle();\n\tboolean isOviewAngle();\n\t\n\t@Option(description=\"direction from which the orthographic view is rendered\",\n\t\t\tpattern=\"[NESW]\", longName=\"oview.from\", defaultValue=\"S\")\n\tCardinalDirection getOviewFrom();\n\tboolean isOviewFrom();\n\t\n\t@Option(description=\"lat,lon pairs defining a bounding box for orthographic view\",\n\t\t\tpattern=LatLonEle.PATTERN, longName=\"oview.bbox\")\n\tList getOviewBoundingBox();\n\tboolean isOviewBoundingBox();\n\t\n\t@Option(description=\"zoom,x,y triples of tiles defining a bounding box for orthographic view\",\n\t\t\tpattern=TileNumber.PATTERN, longName=\"oview.tiles\")\n\tList getOviewTiles();\n\tboolean isOviewTiles();\n\t\n\t@Option(description=\"lat,lon,ele of camera position for perspective view\",\n\t\t\tpattern=LatLonEle.PATTERN_WITH_ELE, longName=\"pview.pos\")\n\tLatLonEle getPviewPos();\n\tboolean isPviewPos();\n\t\n\t@Option(description=\"lat,lon,ele of camera look-at for perspective view\",\n\t\t\tpattern=LatLonEle.PATTERN_WITH_ELE, longName=\"pview.lookAt\")\n\tLatLonEle getPviewLookat();\n\tboolean isPviewLookat();\n\t\n\t@Option(description=\"vertical field of view angle for perspective view, in degrees\",\n\t\t\tlongName=\"pview.fovy\", defaultValue=\"45\")\n\tdouble getPviewFovy();\n\tboolean isPviewFovy();\n\t\n\t@Option(description=\"aspect ratio (width / height) for perspective view\",\n\t\t\tlongName=\"pview.aspect\")\n\tdouble getPviewAspect();\n\tboolean isPviewAspect();\n\t\n\t/* logging */\n\t\n\t@Option(description=\"writes execution times to the command line\")\n\tboolean getPerformancePrint();\n\t\n\t@Option(description=\"appends a line with execution times to a file\")\n\tFile getPerformanceTable();\n\tboolean isPerformanceTable();\n\t\t\n\t/* other parameters */\n\t\n\t@Option(description=\"start the graphical user interface\")\n\tboolean getGui();\n\t\n\t@Option(helpRequest=true, description=\"show this help\", shortName=\"?\")\n\tboolean getHelp();\n\t\n\t@Option(description=\"print software version and exit\")\n\tboolean getVersion();\n\t\n\t/* parameter files */\n\t\n\t@Option(description=\"a file containing one set of parameters per line\")\n\tFile getParameterFile();\n\tboolean isParameterFile();\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/console/CLIArgumentsGroup.java",
"content": "package org.osm2world.console;\n\nimport static com.google.common.base.Preconditions.*;\nimport static org.osm2world.console.CLIArgumentsUtil.ProgramMode.CONVERT;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\n/**\n * a group of {@link CLIArguments} that represent conversions\n * which can be performed at the same time\n * and are only distinguished by output format/parameters\n */\npublic class CLIArgumentsGroup {\n\t\n\tprivate final CLIArguments representative;\n\tprivate final List cliArgumentsList;\n\t\n\t/**\n\t * @param representative the first member of the group.\n\t */\n\tpublic CLIArgumentsGroup(CLIArguments representative) {\n\t\t\n\t\tcheckNotNull(representative);\n\t\t\n\t\tthis.representative = representative;\n\t\t\n\t\tcliArgumentsList = new ArrayList();\n\t\tcliArgumentsList.add(representative);\n\t\t\n\t}\n\t\n\tpublic void addCLIArguments(CLIArguments cliArguments) {\n\t\t\n\t\tcheckNotNull(cliArguments);\n\t\tcheckArgument(isCompatible(cliArguments), \"argument incompatible with group\");\n\t\t\n\t\tcliArgumentsList.add(cliArguments);\n\t\t\n\t}\n\n\tpublic CLIArguments getRepresentative() {\n\t\treturn representative;\n\t}\n\t\n\tpublic List getCLIArgumentsList() {\n\t\treturn cliArgumentsList;\n\t}\n\t\n\t/**\n\t * checks whether a CLIArguments instance is compatible with this group\n\t */\n\tpublic boolean isCompatible(CLIArguments cliArguments) {\n\t\treturn isCompatible(representative, cliArguments);\n\t}\n\n\t/**\n\t * checks whether two CLIArguments instances can be put into the same group\n\t */\n\tprivate static final boolean isCompatible(\n\t\t\tCLIArguments args1, CLIArguments args2) {\n\t\t\n\t\treturn CLIArgumentsUtil.getProgramMode(args1) == CONVERT\n\t\t\t&& CLIArgumentsUtil.getProgramMode(args2) == CONVERT\n\t\t\t&& args1.getInput().equals(args2.getInput())\n\t\t\t&& ((args1.isConfig() && args1.getConfig().equals(args2.getConfig()))\n\t\t\t\t\t|| (!args1.isConfig() && !args2.isConfig()));\n\t\t\t\t\n\t}\n\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/console/CLIArgumentsUtil.java",
"content": "package org.osm2world.console;\n\nimport static org.osm2world.console.CLIArgumentsUtil.ProgramMode.*;\n\nimport java.io.BufferedReader;\nimport java.io.File;\nimport java.io.FileReader;\nimport java.io.IOException;\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\npublic final class CLIArgumentsUtil {\n\t\n\tpublic static enum ProgramMode {GUI, CONVERT, HELP, VERSION, PARAMFILE};\n\tpublic static enum OutputMode {OBJ, POV, PNG, PPM, GD};\n\t\n\tprivate CLIArgumentsUtil() { }\n\t\n\tpublic static final boolean isValid(CLIArguments args) {\n\t\treturn getErrorString(args) == null;\n\t}\n\t\n\tpublic static final String getErrorString(CLIArguments args) {\n\t\t\n\t\tif (getProgramMode(args) == CONVERT) {\n\t\t\t\n\t\t\tif (!args.isInput() || !args.isOutput()) {\n\t\t\t\treturn \"input and output are required arguments\" +\n\t\t\t\t\t\t\" for a conversion\";\n\t\t\t}\n\t\t\t\n\t\t\tif (args.isOviewTiles() && args.getOviewTiles().isEmpty()) {\n\t\t\t\treturn \"at least one tile required\";\n\t\t\t}\n\t\t\t\n\t\t\tif (args.isOviewBoundingBox()\n\t\t\t\t\t&& args.getOviewBoundingBox().size() < 2) {\n\t\t\t\treturn \"bounding box requires at least two lat,lon pairs\";\n\t\t\t}\n\t\t\t\n\t\t\tif (args.isOviewTiles() && args.isOviewBoundingBox()) {\n\t\t\t\treturn \"define *either* tiles or bounding box for\" +\n\t\t\t\t\t\t\" orthographic view\";\n\t\t\t}\n\t\t\t\n\t\t\tfor (File outputFile : args.getOutput()) {\n\t\t\t\tif (getOutputMode(outputFile) == null) {\n\t\t\t\t\treturn \"cannot identify file type from name \" + outputFile\n\t\t\t\t\t\t+ \"\\navailable output types: \" + OutputMode.values();\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tif ((args.isPviewPos() && !args.isPviewLookat())\n\t\t\t\t\t|| (args.isPviewLookat() && !args.isPviewPos())) {\n\t\t\t\treturn \"camera position and look-at for perspective view \"\n\t\t\t\t\t+ \"cannot be used separately, both must be defined\";\n\t\t\t}\n\t\t\t\n\t\t\tif (hasOrthographicArg(args) && hasPerspectiveArg(args)) {\n\t\t\t\treturn \"you cannot combine arguments for perspective view \"\n\t\t\t\t\t+ \"and orthographic view\";\n\t\t\t}\n\t\t\t\n\t\t}\n\t\t\n\t\treturn null;\n\t\t\t\t\n\t}\n\t\n\tprivate static final boolean hasOrthographicArg(CLIArguments args) {\n\t\treturn args.isOviewBoundingBox()\n\t\t\t|| args.isOviewTiles();\n\t}\n\t\n\tprivate static final boolean hasPerspectiveArg(CLIArguments args) {\n\t\treturn args.isPviewLookat()\n\t\t\t|| args.isPviewPos();\n\t}\n\n\tpublic static final ProgramMode getProgramMode(CLIArguments args) {\n\t\treturn args.isParameterFile() ? PARAMFILE\n\t\t\t\t: args.getHelp() ? HELP\n\t\t\t\t\t: args.getVersion() ? VERSION\n\t\t\t\t\t\t: args.getGui() ? GUI\n\t\t\t\t\t\t\t: CONVERT;\n\t}\n\t\n\tpublic static final OutputMode getOutputMode(File outputFile) {\n\t\tif (outputFile.getName().toLowerCase().endsWith(\".obj\")) {\n\t\t\treturn OutputMode.OBJ;\n\t\t} else if (outputFile.getName().toLowerCase().endsWith(\".pov\")) {\n\t\t\treturn OutputMode.POV;\n\t\t} else if (outputFile.getName().toLowerCase().endsWith(\".png\")) {\n\t\t\treturn OutputMode.PNG;\n\t\t} else if (outputFile.getName().toLowerCase().endsWith(\".ppm\")) {\n\t\t\treturn OutputMode.PPM;\n\t\t} else if (outputFile.getName().toLowerCase().endsWith(\".gd\")) {\n\t\t\treturn OutputMode.GD;\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t}\n\t\n\tpublic static final List getUnparsedParameterGroups(\n\t\t\tFile parameterFile) throws IOException {\n\t\t\n\t\tList result = new ArrayList();\n\t\t\n\t\tBufferedReader in = new BufferedReader(new FileReader(parameterFile));\n\t\t\t\n\t\tString line;\n\t\t\n\t\twhile ((line = in.readLine()) != null) {\n\t\t\t\n\t\t\tif (line.startsWith(\"#\")) continue;\n\t\t\tif (line.trim().isEmpty()) continue;\n\t\t\t\n\t\t\tList argList = new ArrayList();\n\t\t\t\n\t\t\tPattern regex = Pattern.compile(\"[^\\\\s\\\"']+|\\\"([^\\\"]*)\\\"|'([^']*)'\");\n\t\t\tMatcher matcher = regex.matcher(line);\n\t\t\t\n\t\t\twhile (matcher.find()) {\n\t\t\t if (matcher.group(1) != null) {\n\t\t\t // Add double-quoted string without the quotes\n\t\t\t \targList.add(matcher.group(1));\n\t\t\t } else if (matcher.group(2) != null) {\n\t\t\t // Add single-quoted string without the quotes\n\t\t\t \targList.add(matcher.group(2));\n\t\t\t } else {\n\t\t\t // Add unquoted word\n\t\t\t \targList.add(matcher.group());\n\t\t\t }\n\t\t\t}\n\t\t\t\n\t\t\tresult.add(argList.toArray(new String[argList.size()]));\n\t\t\t\n\t\t}\n\t\tin.close();\n\t\t\n\t\treturn result;\n\t\t\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/console/ImageExporter.java",
"content": "package org.osm2world.console;\n\nimport static java.lang.Math.*;\nimport static org.osm2world.core.target.jogl.JOGLRenderingParameters.Winding.CCW;\nimport static org.osm2world.core.util.ConfigUtil.*;\n\nimport java.awt.AlphaComposite;\nimport java.awt.Color;\nimport java.awt.Graphics2D;\nimport java.awt.image.BufferedImage;\nimport java.awt.image.DataBuffer;\nimport java.awt.image.DataBufferInt;\nimport java.io.DataOutputStream;\nimport java.io.File;\nimport java.io.FileOutputStream;\nimport java.io.IOException;\nimport java.nio.ByteBuffer;\nimport java.nio.channels.FileChannel;\nimport java.nio.charset.Charset;\n\nimport javax.media.opengl.GL;\nimport javax.media.opengl.GLAutoDrawable;\nimport javax.media.opengl.GLCapabilities;\nimport javax.media.opengl.GLDrawableFactory;\nimport javax.media.opengl.GLEventListener;\nimport javax.media.opengl.GLOffscreenAutoDrawable;\nimport javax.media.opengl.GLProfile;\n\nimport org.apache.commons.configuration.Configuration;\nimport org.osm2world.console.CLIArgumentsUtil.OutputMode;\nimport org.osm2world.core.ConversionFacade.Results;\nimport org.osm2world.core.target.TargetUtil;\nimport org.osm2world.core.target.common.lighting.GlobalLightingParameters;\nimport org.osm2world.core.target.common.rendering.Camera;\nimport org.osm2world.core.target.common.rendering.Projection;\nimport org.osm2world.core.target.jogl.AbstractJOGLTarget;\nimport org.osm2world.core.target.jogl.JOGLRenderingParameters;\nimport org.osm2world.core.target.jogl.JOGLTarget;\nimport org.osm2world.core.target.jogl.JOGLTargetFixedFunction;\nimport org.osm2world.core.target.jogl.JOGLTargetShader;\nimport org.osm2world.core.target.jogl.JOGLTextureManager;\n\nimport ar.com.hjg.pngj.ImageInfo;\nimport ar.com.hjg.pngj.ImageLineByte;\nimport ar.com.hjg.pngj.PngWriter;\nimport ar.com.hjg.pngj.chunks.PngChunkTextVar;\nimport ar.com.hjg.pngj.chunks.PngMetadata;\n\nimport com.jogamp.opengl.util.awt.AWTGLReadBufferUtil;\n\npublic class ImageExporter {\n\n\t/**\n\t * the width and height of the canvas used for rendering the exported image\n\t * each must not exceed the canvas limit. If the requested image is larger,\n\t * it will be rendered in multiple passes and combined afterwards.\n\t * This is intended to avoid overwhelmingly large canvases\n\t * (which would lead to crashes)\n\t */\n\tprivate static final int DEFAULT_CANVAS_LIMIT = 1024;\n\t\n\tprivate final Results results;\n\tprivate final Configuration config;\n\t\n\tprivate File backgroundImage;\n\tprivate JOGLTextureManager backgroundTextureManager;\n\tprivate Color clearColor;\n\t\n\tprivate boolean exportAlpha = false;\n\t\n\tprivate GLOffscreenAutoDrawable drawable;\n\tprivate ImageExporterGLEventListener listener;\n\tprivate final int pBufferSizeX;\n\tprivate final int pBufferSizeY;\n\t\n\t/** target prepared in init; null for unbuffered rendering */\n\tprivate JOGLTarget bufferTarget = null;\n\t\n\tprivate boolean unbufferedRendering;\n\t\n\t\n\t/**\n\t * Creates an {@link ImageExporter} for later use.\n\t * Also performs calculations that only need to be done once for a group\n\t * of files, based on a {@link CLIArgumentsGroup}.\n\t * \n\t * @param expectedGroup group that should contain at least the arguments\n\t * for the files that will later be requested.\n\t * Basis for optimization preparations.\n\t */\n\tpublic ImageExporter(Configuration config, Results results,\n\t\t\tCLIArgumentsGroup expectedGroup) {\n\t\t\n\t\tthis.results = results;\n\t\tthis.config = config;\n\n\t\t/* parse background color/image and other configuration options */\n\t\t\n\t\tclearColor = new Color(0, 0, 0, 0);\n\t\t\n\t\tif (config.containsKey(BG_COLOR_KEY)) {\n\t\t\tColor confClearColor = parseColor(config.getString(BG_COLOR_KEY));\n\t\t\tif (confClearColor != null) {\n\t\t\t\tclearColor = confClearColor;\n\t\t\t} else {\n\t\t\t\tSystem.err.println(\"incorrect color value: \"\n\t\t\t\t\t\t+ config.getString(BG_COLOR_KEY));\n\t\t\t}\n\t\t}\n\t\t\n\t\tif (config.containsKey(BG_IMAGE_KEY)) {\n\t\t\tString fileString = config.getString(BG_IMAGE_KEY);\n\t\t\tif (fileString != null) {\n\t\t\t\tbackgroundImage = new File(fileString);\n\t\t\t\tif (!backgroundImage.exists()) {\n\t\t\t\t\tSystem.err.println(\"background image file doesn't exist: \"\n\t\t\t\t\t\t\t+ backgroundImage);\n\t\t\t\t\tbackgroundImage = null;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t\n\t\texportAlpha = config.getBoolean(\"exportAlpha\", false);\n\t\t\n\t\tint canvasLimit = config.getInt(CANVAS_LIMIT_KEY, DEFAULT_CANVAS_LIMIT);\n\t\t\n\t\t/* find out what number and size of image file requests to expect */\n\t\t\n\t\tint expectedFileCalls = 0;\n\t\tint expectedMaxSizeX = 1;\n\t\tint expectedMaxSizeY = 1;\n\t\t\n\t\tfor (CLIArguments args : expectedGroup.getCLIArgumentsList()) {\n\t\t\t\n\t\t\tfor (File outputFile : args.getOutput()) {\n\t\t\t\tOutputMode outputMode = CLIArgumentsUtil.getOutputMode(outputFile);\n\t\t\t\tif (outputMode == OutputMode.PNG || outputMode == OutputMode.PPM || outputMode == OutputMode.GD) {\n\t\t\t\t\texpectedFileCalls += 1;\n\t\t\t\t\texpectedMaxSizeX = max(expectedMaxSizeX, args.getResolution().x);\n\t\t\t\t\texpectedMaxSizeY = max(expectedMaxSizeY, args.getResolution().y);\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t}\n\t\tboolean onlyOneRenderPass = (expectedFileCalls <= 1\n\t\t\t\t&& expectedMaxSizeX <= canvasLimit\n\t\t\t\t&& expectedMaxSizeY <= canvasLimit);\n\n\t\tunbufferedRendering = onlyOneRenderPass\n\t\t\t\t|| config.getBoolean(\"forceUnbufferedPNGRendering\", false);\n\t\t\n\t\t/* create GL canvas and set rendering parameters */\n\n\t\tGLProfile profile;\n\t\tif (\"shader\".equals(config.getString(\"joglImplementation\"))) {\n\t\t\tprofile = GLProfile.get(GLProfile.GL3);\n\t\t} else {\n\t\t\tprofile = GLProfile.get(GLProfile.GL2);\n\t\t}\n\t\t\n\t\tGLDrawableFactory factory = GLDrawableFactory.getFactory(profile);\n\t\t\n\t\tif (! factory.canCreateGLPbuffer(null, profile) && ! factory.canCreateFBO(null, profile)) {\n\t\t\tthrow new Error(\"Cannot create GLPbuffer or FBO for OpenGL output!\");\n\t\t}\n\t\t\n\t\tGLCapabilities cap = new GLCapabilities(profile);\n\t\tcap.setDoubleBuffered(false);\n\t\tif (exportAlpha)\n\t\t\tcap.setAlphaBits(8);\n\t\t\n\t\t// set MSAA (Multi Sample Anti-Aliasing)\n\t\tint msaa = config.getInt(\"msaa\", 0);\n\t\tif (msaa > 0) {\n\t\t\tcap.setSampleBuffers(true);\n\t\t\tcap.setNumSamples(msaa);\n\t\t}\n\t\t\n\t\tif (\"shader\".equals(config.getString(\"joglImplementation\"))) {\n\t\t\t\n\t\t\tif (\"shadowVolumes\".equals(config.getString(\"shadowImplementation\"))\n\t\t\t\t\t|| \"both\".equals(config.getString(\"shadowImplementation\"))) {\n\t\t\t\tcap.setStencilBits(8);\n\t\t\t}\n\t\t}\n\t\t\t\t\n\t\tpBufferSizeX = min(canvasLimit, expectedMaxSizeX);\n\t\tpBufferSizeY = min(canvasLimit, expectedMaxSizeY);\n\t\t\t\t\n\t\tdrawable = factory.createOffscreenAutoDrawable(null,\n\t\t\t\tcap, null, pBufferSizeX, pBufferSizeY, null);\n\t\tlistener = new ImageExporterGLEventListener();\n\t\tdrawable.addGLEventListener(listener);\n\n\t\tbackgroundTextureManager = new JOGLTextureManager(drawable.getGL());\n\n\t}\n\t\n\tprotected void finalize() throws Throwable {\n\t\tfreeResources();\n\t}\n\n\t/**\n\t * manually frees resources that would otherwise remain used\n\t * until the finalize call. It is no longer possible to use\n\t * {@link #writeImageFile(File, CLIArgumentsUtil.OutputMode, int, int, Camera, Projection)}\n\t * afterwards.\n\t */\n\tpublic void freeResources() {\n\n\t\tif (backgroundTextureManager != null) {\n\t\t\tbackgroundTextureManager.releaseAll();\n\t\t\tbackgroundTextureManager = null;\n\t\t}\n\t\t\n\t\tif (bufferTarget != null) {\n\t\t\tbufferTarget.freeResources();\n\t\t\tbufferTarget = null;\n\t\t}\n\t\t\n\t\tif (drawable != null) {\n\t\t\tdrawable.destroy();\n\t\t\tdrawable = null;\n\t\t}\n\t\t\n\t}\n\t\n\t/**\n\t * renders this ImageExporter's content to a file\n\t * \n\t * @param outputMode one of the image output modes\n\t * @param x horizontal resolution\n\t * @param y vertical resolution\n\t */\n\tpublic void writeImageFile(\n\t\t\tFile outputFile, OutputMode outputMode,\n\t\t\tint x, int y,\n\t\t\tfinal Camera camera,\n\t\t\tfinal Projection projection) throws IOException {\n\t\t\n\t\t/* FIXME: this would be needed for cases where BufferSizes are so unbeliveable large that the temp images go beyond the memory limit\n\t\twhile (((1<<31)/x) <= pBufferSizeY) {\n\t\t\tpBufferSizeY /= 2;\n\t\t}\n\t\t*/\n\t\t\n\t\tlistener.prepareRendering(camera, projection, x, y);\n\t\t\n\t\t/* determine the number of \"parts\" to split the rendering in */\n\t\t\n\t\tint xParts = 1 + ((x-1) / pBufferSizeX);\n\t\tint yParts = 1 + ((y-1) / pBufferSizeY);\n\n\t\t/* generate ImageWriter */\n\t\tImageWriter imageWriter;\n\t\t\n\t\tswitch (outputMode) {\n\t\tcase PNG: imageWriter = new PNGWriter(outputFile, x, y, exportAlpha); break;\n\t\tcase PPM: imageWriter = new PPMWriter(outputFile, x, y); break;\n\t\tcase GD: imageWriter = new GDWriter(outputFile, x, y); break;\n\t\t\n\t\tdefault: throw new IllegalArgumentException(\n\t\t\t\t\"output mode not supported \" + outputMode);\n\t\t}\n\n\t\t/* create image (maybe in multiple parts) */\n\t\t\t\t\n BufferedImage image = new BufferedImage(x, pBufferSizeY, exportAlpha ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB);\n\n\t\tGraphics2D graphics = image.createGraphics();\n\t\tgraphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC));\n \n for (int yPart = yParts-1; yPart >=0 ; --yPart) {\n \t\n \tint yStart = yPart * pBufferSizeY;\n\t\t\tint yEnd = (yPart+1 < yParts) ? (yStart + (pBufferSizeY-1)) : (y-1);\n\t\t\tint ySize = (yEnd - yStart) + 1;\n\n \tfor (int xPart = 0; xPart < xParts; ++xPart) {\n \t\t\t\n\t\t\t\t/* calculate start, end and size (in pixels)\n\t\t\t\t * of the image part that will be rendered in this pass */\n\t\t\t\n\t\t\t\tint xStart = xPart * pBufferSizeX;\n\t\t\t\tint xEnd = (xPart+1 < xParts) ? (xStart + (pBufferSizeX-1)) : (x-1);\n\t\t\t\tint xSize = (xEnd - xStart) + 1;\n\n\t\t\t\tlistener.setPart(xStart, yStart, xEnd, yEnd, xSize, ySize);\n\t\t\t\t\n\t\t\t\t// render everything\n \t\tdrawable.display();\n\t \n\t\t\t\t/* make screenshot and paste into the buffer that will contain\n\t\t\t\t * pBufferSizeY entire image lines */\n\n \t\tdrawable.getContext().makeCurrent();\n\t\t\t\tAWTGLReadBufferUtil reader = new AWTGLReadBufferUtil(drawable.getGLProfile(), exportAlpha);\n\t\t\t\tBufferedImage imagePart = reader.readPixelsToBufferedImage(drawable.getGL(), 0, 0, xSize, ySize, true);\n \t\tdrawable.getContext().release();\n\t \n \t\tgraphics.drawImage(imagePart, xStart, 0, xSize, ySize, null);\n\t\t\t}\n \t\n \timageWriter.append(image, ySize);\n\t\t}\n\n imageWriter.close();\n\t}\n\n\tprivate static JOGLTarget createJOGLTarget(GL gl, Results results,\n\t\t\tConfiguration config) {\n\t\t\n\t\tJOGLTarget target;\n\t\tif (\"shader\".equals(config.getString(\"joglImplementation\"))) {\n\t\t\tboolean drawBoundingBox = config.getBoolean(\"drawBoundingBox\", false);\n\t\t\tboolean shadowVolumes = \"shadowVolumes\".equals(config.getString(\"shadowImplementation\"))\n\t\t\t\t\t|| \"both\".equals(config.getString(\"shadowImplementation\"));\n\t\t\tboolean shadowMaps = \"shadowMap\".equals(config.getString(\"shadowImplementation\"))\n\t\t\t\t\t|| \"both\".equals(config.getString(\"shadowImplementation\"));\n\t\t\tint shadowMapWidth = config.getInt(\"shadowMapWidth\", 4096);\n\t\t\tint shadowMapHeight = config.getInt(\"shadowMapHeight\", 4096);\n\t\t\tint shadowMapCameraFrustumPadding = config.getInt(\"shadowMapCameraFrustumPadding\", 8);\n\t\t\tboolean useSSAO = \"true\".equals(config.getString(\"useSSAO\"));\n\t\t\tint SSAOkernelSize = config.getInt(\"SSAOkernelSize\", 16);\n\t\t\tfloat SSAOradius = config.getFloat(\"SSAOradius\", 1);\n\t\t\tboolean overwriteProjectionClippingPlanes = \"true\".equals(config.getString(\"overwriteProjectionClippingPlanes\"));\n\t\t\ttarget = new JOGLTargetShader(gl.getGL3(),\n\t\t\t\t\tnew JOGLRenderingParameters(CCW, false, true, drawBoundingBox, shadowVolumes, shadowMaps, shadowMapWidth, shadowMapHeight,\n\t\t\t \t\t\tshadowMapCameraFrustumPadding, useSSAO, SSAOkernelSize, SSAOradius, overwriteProjectionClippingPlanes),\n\t\t\t\t\tGlobalLightingParameters.DEFAULT);\n\t\t} else {\n\t\t\ttarget = new JOGLTargetFixedFunction(gl.getGL2(),\n\t\t\t\t\tnew JOGLRenderingParameters(CCW, false, true),\n\t\t\t\t\tGlobalLightingParameters.DEFAULT);\n\t\t}\n\t\t\n\t\t\n\t\ttarget.setConfiguration(config);\n\t\t\n\t\tboolean underground = config.getBoolean(\"renderUnderground\", true);\n\n\t\ttarget.setXZBoundary(results.getMapData().getBoundary());\n\t\tTargetUtil.renderWorldObjects(target, results.getMapData(), underground);\n\t\t\n\t\ttarget.finish();\n\t\t\n\t\treturn target;\n\t\t\n\t}\n\t\n\t\n\t/**\n\t * interface ImageWriter is used to abstract the underlaying image\n\t * format. It can be used for incremental image writes of huge images\n\t */\n\tpublic static interface ImageWriter {\n\t\tvoid append(BufferedImage img) throws IOException;\n\t\tvoid append(BufferedImage img, int lines) throws IOException;\n\t\tvoid close() throws IOException;\n\t}\n\n\t/**\n\t * Implementation of an ImageWriter to write png files\n\t */\n\tpublic static class PNGWriter implements ImageWriter {\n\n\t\tprivate ImageInfo imgInfo;\n\t\tprivate PngWriter writer;\n\t\t\n\t\tpublic PNGWriter(File outputFile, int cols, int rows, boolean alpha) {\n\t\t\timgInfo = new ImageInfo(cols, rows, 8, alpha);\n\t\t\twriter = new PngWriter(outputFile, imgInfo, true);\n\t\t\t\n\t\t\tPngMetadata metaData = writer.getMetadata();\n\t\t\tmetaData.setTimeNow();\n\t\t\tmetaData.setText(PngChunkTextVar.KEY_Software, \"OSM2World\");\n\t\t}\n\t\t\n\t\t@Override\n\t\tpublic void append(BufferedImage img) throws IOException {\n\t\t\tappend(img, img.getHeight());\n\t\t}\n\n\t\t@Override\n\t\tpublic void append(BufferedImage img, int lines) throws IOException {\n\n\t\t\t/* get raw data of image */\n\t\t\tDataBuffer imageDataBuffer = img.getRaster().getDataBuffer();\n\t\t\tint[] data = (((DataBufferInt)imageDataBuffer).getData());\n\t\t\t\n\t\t\t/* create one ImageLine that will be refilled and written to png */\n\t\t\tImageLineByte bline = new ImageLineByte(imgInfo);\n\t\t\tbyte[] line = bline.getScanline();\n\t\t\tint channels = imgInfo.channels;\n\t\t\t\n\t\t\tfor (int i = 0; i < lines; i++) {\n\t\t\t\tfor (int d = 0; d < img.getWidth(); d++) {\n\t\t\t\t\tint val = data[i*img.getWidth()+d];\n\t\t\t\t\tline[channels*d+0] = (byte) (val >> 16);\n\t\t\t\t\tline[channels*d+1] = (byte) (val >> 8);\n\t\t\t\t\tline[channels*d+2] = (byte) val;\n\t\t\t\t\tif (channels > 3)\n\t\t\t\t\t\tline[channels*d+3] = (byte) (val >> 24);\n\t\t\t\t}\n\t\t\t\twriter.writeRow(bline);\n\t\t\t}\n\t\t}\n\n\t\t@Override\n\t\tpublic void close() throws IOException {\n\t\t\twriter.end();\n\t\t\twriter.close();\n\t\t}\n\t}\n\t\n\t/**\n\t * Implementation of an ImageWriter to write raw ppm files\n\t */\n\tpublic static class PPMWriter implements ImageWriter {\n\n\t\tprivate FileOutputStream out;\n\t\tprivate FileChannel fc;\n\t\tprivate File outputFile;\n\t\tprivate int cols;\n\t\tprivate int rows;\n\t\t\n\t\tpublic PPMWriter(File outputFile, int cols, int rows) {\n\t\t\tthis.cols = cols;\n\t\t\tthis.rows = rows;\n\t\t\tthis.outputFile = outputFile;\n\t\t}\n\t\t\n\t\tprivate void writeHeader() throws IOException {\n\t\t\t\n\t\t\tout = new FileOutputStream(outputFile);\n\t\t\t\t\t\n\t\t\t// write header\n\t\t\tCharset charSet = Charset.forName(\"US-ASCII\");\n\t\t\tout.write(\"P6\\n\".getBytes(charSet));\n\t\t\tout.write(String.format(\"%d %d\\n\", cols, rows).getBytes(charSet));\n\t\t\tout.write(\"255\\n\".getBytes(charSet));\n\n\t\t\tfc = out.getChannel();\n\t\t}\n\t\t\n\t\t\n\t\t@Override\n\t\tpublic void append(BufferedImage img) throws IOException {\n\t\t\tappend(img, img.getHeight());\n\t\t}\n\n\t\t@Override\n\t\tpublic void append(BufferedImage img, int lines) throws IOException {\n\n\t\t\tif (fc == null) {\n\t\t\t\twriteHeader();\n\t\t\t}\n\t\t\t\n\t\t\t// collect and write content\n\n\t\t\tByteBuffer writeBuffer = ByteBuffer.allocate(\n\t\t\t\t\t3 * img.getWidth() * lines);\n\t\t\t\n\t\t\tDataBuffer imageDataBuffer = img.getRaster().getDataBuffer();\n\t\t\tint[] data = (((DataBufferInt)imageDataBuffer).getData());\n\t\t\t\n\t\t\tfor (int i = 0; i < img.getWidth() * lines; i++) {\n\t\t\t\tint value = data[i];\n\t\t\t\twriteBuffer.put((byte)(value >>> 16));\n\t\t\t\twriteBuffer.put((byte)(value >>> 8));\n\t\t\t\twriteBuffer.put((byte)(value));\n\t\t\t}\n\t\t\t\n\t\t\twriteBuffer.position(0);\n\t\t\tfc.write(writeBuffer);\n\t\t\t\n\t\t}\n\n\t\t@Override\n\t\tpublic void close() throws IOException {\n\n\t\t\tif (fc != null) {\n\t\t\t\tfc.close();\n\t\t\t}\n\n\t\t\tif (out != null) {\n\t\t\t\tout.close();\n\t\t\t}\n\t\t}\n\t}\n\t\n\t/**\n\t * Implementation of an ImageWriter to write the (rare) gd file format\n\t */\n\tpublic static class GDWriter implements ImageWriter {\n\n\t\t//TODO: dimensions are limited to short!\n\t\t\n\t\tprivate FileOutputStream out;\n\t\tprivate FileChannel fc;\n\t\tprivate File outputFile;\n\t\tprivate int cols;\n\t\tprivate int rows;\n\t\t\n\t\tpublic GDWriter(File outputFile, int cols, int rows) {\n\t\t\tthis.cols = cols;\n\t\t\tthis.rows = rows;\n\t\t\tthis.outputFile = outputFile;\n\t\t}\n\t\t\n\t\tprivate void writeHeader() throws IOException {\n\t\t\t\n\t\t\tout = new FileOutputStream(outputFile);\n\t\t\t\t\t\t\n\t\t\tout.write(0xff);\n\t\t\tout.write(0xfe);\n\t\t\t\n\t\t\t//write dimensions\n\t\t\tDataOutputStream dOut = new DataOutputStream(out);\n\t\t\tdOut.writeShort(cols);\n\t\t\tdOut.writeShort(rows);\n\n\t\t\tout.write(0x01);\n\t\t\tout.write(0xff);\n\t\t\tout.write(0xff);\n\t\t\tout.write(0xff);\n\t\t\tout.write(0xff);\n\t\t\tout.write(0x00);\n\t\t\t\t\t\t\n\t\t\tfc = out.getChannel();\n\t\t}\n\t\t\n\t\t\n\t\t@Override\n\t\tpublic void append(BufferedImage img) throws IOException {\n\t\t\tappend(img, img.getHeight());\n\t\t}\n\n\t\t@Override\n\t\tpublic void append(BufferedImage img, int lines) throws IOException {\n\n\t\t\tif (fc == null) {\n\t\t\t\twriteHeader();\n\t\t\t}\n\t\t\t\n\t\t\t// collect and write content\n\n\t\t\tByteBuffer writeBuffer = ByteBuffer.allocate(\n\t\t\t\t\t4 * img.getWidth() * lines);\n\t\t\t\n\t\t\tDataBuffer imageDataBuffer = img.getRaster().getDataBuffer();\n\t\t\tint[] data = (((DataBufferInt)imageDataBuffer).getData());\n\t\t\t\n\t\t\tfor (int i = 0; i < img.getWidth() * lines; i++) {\n\t\t\t\tint value = data[i];\n\t\t\t\twriteBuffer.put((byte)(value >>> 16));\n\t\t\t\twriteBuffer.put((byte)(value >>> 8));\n\t\t\t\twriteBuffer.put((byte)(value));\n\t\t\t\twriteBuffer.put((byte) 0);\n\t\t\t}\n\t\t\t\n\t\t\twriteBuffer.position(0);\n\t\t\tfc.write(writeBuffer);\n\t\t\t\n\t\t}\n\n\t\t@Override\n\t\tpublic void close() throws IOException {\n\n\t\t\tif (fc != null) {\n\t\t\t\tfc.close();\n\t\t\t}\n\n\t\t\tif (out != null) {\n\t\t\t\tout.close();\n\t\t\t}\n\t\t}\n\t}\n\t\n\tpublic class ImageExporterGLEventListener implements GLEventListener {\n\t\tprivate int xStart;\n\t\tprivate int yStart;\n\t\tprivate int xEnd;\n\t\tprivate int yEnd;\n\t\tprivate int xSize;\n\t\tprivate int ySize;\n\t\tprivate int x;\n\t\tprivate int y;\n\t\tprivate Camera camera;\n\t\tprivate Projection projection;\n\t\tprivate boolean nodisplay = false;\n\n\t\t@Override\n\t\tpublic void init(GLAutoDrawable drawable) {\n\n\t\t\t/* render map data into buffer if it needs to be rendered multiple times */\n\t\t\tif (!unbufferedRendering ) {\n\t\t\t\tbufferTarget = createJOGLTarget(drawable.getGL(), results, config);\n\t\t\t}\n\t\t}\n\n\t\tpublic void setPart(int xStart, int yStart, int xEnd, int yEnd,\n\t\t\t\tint xSize, int ySize) {\n\t\t\t\n\t\t\tif (this.xSize != xSize || this.ySize != ySize) {\n\t\t\t\t// disable display while resizing. all display calls need to be from @writeImageFile\n\t\t\t\tnodisplay = true;\n\t\t\t\tdrawable.setSize(xSize, ySize);\n\t\t\t\tnodisplay = false;\n\t\t\t}\n\t\t\t\n\t\t\tthis.xStart = xStart;\n\t\t\tthis.yStart = yStart;\n\t\t\tthis.xEnd = xEnd;\n\t\t\tthis.yEnd = yEnd;\n\t\t\tthis.xSize = xSize;\n\t\t\tthis.ySize = ySize;\n\t\t}\n\n\t\tpublic void prepareRendering(Camera camera, Projection projection,\n\t\t\t\tint x, int y) {\n\t\t\tthis.camera = camera;\n\t\t\tthis.projection = projection;\n\t\t\tthis.x = x;\n\t\t\tthis.y = y;\n\t\t}\n\n\t\t@Override\n\t\tpublic void dispose(GLAutoDrawable drawable) {\n\t\t}\n\n\t\t@Override\n\t\tpublic void display(GLAutoDrawable drawable) {\n\t\t\t\n\t\t\tif (nodisplay)\n\t\t\t\treturn;\n\t\t\t\n\t\t\t/* configure rendering */\n\n\t\t\tAbstractJOGLTarget.clearGL(drawable.getGL(), clearColor);\n\n\t\t\t/* render to pBuffer */\n\n\t\t\tJOGLTarget target = (bufferTarget == null)?\n\t\t\t\t\tcreateJOGLTarget(drawable.getGL(), results, config) : bufferTarget;\n\n\t\t\t\t\tif (backgroundImage != null) {\n\t\t\t\t\t\ttarget.drawBackgoundImage(backgroundImage,\n\t\t\t\t\t\t\t\txStart, yStart, xSize, ySize,\n\t\t\t\t\t\t\t\tbackgroundTextureManager);\n\t\t\t\t\t}\n\n\t\t\t\t\ttarget.renderPart(camera, projection,\n\t\t\t\t\t\t\txStart / (double)(x-1), xEnd / (double)(x-1),\n\t\t\t\t\t\t\tyStart / (double)(y-1), yEnd / (double)(y-1));\n\n\t\t\t\t\tif (target != bufferTarget) {\n\t\t\t\t\t\ttarget.freeResources();\n\t\t\t\t\t}\n\t\t}\n\n\t\t@Override\n\t\tpublic void reshape(GLAutoDrawable drawable, int x, int y, int width,\n\t\t\t\tint height) {\n\t\t}\n\t}\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/console/LatLonEle.java",
"content": "package org.osm2world.console;\n\nimport java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\n/**\n * immutable latitude/longitude/elevation coordinate triple\n */\npublic class LatLonEle {\n\n\tpublic final double lat;\n\tpublic final double lon;\n\tpublic final double ele;\n\n\tprivate static final String DOUBLE_P = \"[+-]?\\\\d+(?:\\\\.\\\\d+)?\";\n\t\n\t/**\n\t * pattern for parseable arguments\n\t */\n\tpublic static final String PATTERN = \"(\"+DOUBLE_P+\"),(\"+DOUBLE_P+\")\";\n\tpublic static final String PATTERN_WITH_ELE = PATTERN + \",(\" + DOUBLE_P + \")\";\n\n\t/**\n\t * regular constructor\n\t */\n\tpublic LatLonEle(double lat, double lon, double ele) {\n\t\tthis.lat = lat;\n\t\tthis.lon = lon;\n\t\tthis.ele = ele;\n\t\tvalidateValues();\n\t}\n\t\n\t/**\n\t * regular constructor (with default elevation of 0)\n\t */\n\tpublic LatLonEle(double lat, double lon) {\n\t\tthis(lat, lon, 0);\n\t}\n\t\n\t/**\n\t * parsing constructor\n\t * @param arg command line argument to be parsed;\n\t * formats see {@link #PATTERN} and {@link #PATTERN_WITH_ELE}\n\t */\n\tpublic LatLonEle(String arg) {\n\t\tMatcher mEle = Pattern.compile(PATTERN_WITH_ELE).matcher(arg);\n\t\tMatcher m = Pattern.compile(PATTERN).matcher(arg);\n\t\tif (mEle.matches()) {\n\t\t\tlat = Double.parseDouble(mEle.group(1));\n\t\t\tlon = Double.parseDouble(mEle.group(2));\n\t\t\tele = Double.parseDouble(mEle.group(3));\n\t\t\tvalidateValues();\n\t\t} else if (m.matches()) {\n\t\t\tlat = Double.parseDouble(m.group(1));\n\t\t\tlon = Double.parseDouble(m.group(2));\n\t\t\tele = 0;\n\t\t\tvalidateValues();\n\t\t} else {\n\t\t\tthrow new IllegalArgumentException(\"argument doesn't match: \" + arg);\n\t\t}\n\t}\n\n\t/**\n\t * @throws IllegalArgumentException for incorrect field values\n\t */\n\tprivate void validateValues() {\n\t\tif (lat > 90 || lat < -90 || lon > 180 || lon < -180) {\n\t\t\tthrow new IllegalArgumentException(\"not valid: \" + lat + \", \" + lon);\n\t\t}\n\t}\n\t\n\t@Override\n\tpublic String toString() {\n\t\treturn lat + \",\" + lon;\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/console/OSM2World.java",
"content": "package org.osm2world.console;\n\nimport static org.osm2world.console.CLIArgumentsUtil.getProgramMode;\nimport static org.osm2world.core.GlobalValues.VERSION_STRING;\n\nimport java.io.File;\nimport java.io.IOException;\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collections;\nimport java.util.List;\n\nimport javax.swing.UIManager;\n\nimport org.apache.commons.configuration.BaseConfiguration;\nimport org.apache.commons.configuration.Configuration;\nimport org.apache.commons.configuration.ConfigurationException;\nimport org.apache.commons.configuration.PropertiesConfiguration;\nimport org.osm2world.console.CLIArgumentsUtil.ProgramMode;\nimport org.osm2world.core.GlobalValues;\nimport org.osm2world.viewer.view.ViewerFrame;\n\nimport uk.co.flamingpenguin.jewel.cli.ArgumentValidationException;\nimport uk.co.flamingpenguin.jewel.cli.CliFactory;\n\n/**\n * main class of the OSM2World console application\n */\npublic class OSM2World {\n\n\tpublic static void main(String[] unparsedArgs) {\n\t\t\n\t\t/* assume --gui if no parameters are given */\n\t\t\n\t\tif (unparsedArgs.length == 0) {\n\t\t \n\t\t\tSystem.out.println(\"No parameters, running graphical interface.\\n\"\n\t\t\t\t\t+ \"If you want to use the command line, use the --help\"\n\t\t\t\t\t+ \" parameter for a list of available parameters.\");\n\t\t\t\n\t\t\tunparsedArgs = new String[]{\"--gui\"};\n\t\t\t\n\t\t}\n\t\t\n\t\t/* parse command line arguments */\n\t\t\n\t\tCLIArguments args = null;\n\t\t\n\t\ttry {\n\t\t\targs = parseArguments(unparsedArgs);\n\t\t} catch (Exception e) {\n\t\t\tSystem.err.println(e.getMessage());\n\t\t\tSystem.exit(1);\n\t\t}\n\t\t\n\t\t/* parse lines from parameter file (if one exists) */\n\t\t\n\t\tList argumentsList = Collections.singletonList(args);\n\t\t\n\t\tif (args.isParameterFile()) {\n\t\t\t\n\t\t\targumentsList = new ArrayList();\n\t\t\t\n\t\t\ttry {\n\t\t\t\t\n\t\t\t\tList unparsedArgsLines = CLIArgumentsUtil\n\t\t\t\t\t.getUnparsedParameterGroups(args.getParameterFile());\n\t\t\t\t\n\t\t\t\tfor (String[] unparsedArgsLine : unparsedArgsLines) {\n\t\t\t\t\t\n\t\t\t\t\ttry {\n\t\t\t\t\t\targumentsList.add(parseArguments(unparsedArgsLine));\n\t\t\t\t\t} catch (Exception e) {\n\t\t\t\t\t\tSystem.err.println(\"Could not parse parameters from file:\");\n\t\t\t\t\t\tSystem.err.println(Arrays.toString(unparsedArgsLine));\n\t\t\t\t\t\tSystem.err.println(\"Ignoring it. Reason:\");\n\t\t\t\t\t\tSystem.err.println(e.getMessage());\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t}\n\t\t\t\t\n\t\t\t} catch (IOException e) {\n\t\t\t\tSystem.err.println(e.getMessage());\n\t\t\t\tSystem.exit(1);\n\t\t\t}\n\t\t\t\n\t\t}\n\t\t\n\t\t/* collect parameter groups into compatible groups\n\t\t * (groups of parameter groups that use the same input and config files) */\n\t\t\n\t\tList argumentsGroups = new ArrayList();\n\t\t\n\t\tfor (CLIArguments arguments : argumentsList) {\n\t\t\t\n\t\t\tboolean added = false;\n\t\t\t\n\t\t\tfor (CLIArgumentsGroup compatibleGroup : argumentsGroups) {\n\t\t\t\tif (compatibleGroup.isCompatible(arguments)) {\n\t\t\t\t\t// add to existing compatible group\n\t\t\t\t\tcompatibleGroup.addCLIArguments(arguments);\n\t\t\t\t\tadded = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tif (!added) {\n\t\t\t\t// start a new compatible group\n\t\t\t\targumentsGroups.add(new CLIArgumentsGroup(arguments));\n\t\t\t}\n\t\t\t\n\t\t}\n\t\t\n\t\t/* execute conversions */\n\t\t\n\t\tif (argumentsGroups.isEmpty()) {\n\t\t\tSystem.err.println(\"warning: empty parameter file, doing nothing\");\n\t\t}\n\t\t\n\t\tfor (CLIArgumentsGroup argumentsGroup : argumentsGroups) {\n\t\t\t\t\t\t\n\t\t\tif (argumentsList.size() > 1) {\n\t\t\t\tSystem.out.print(\"executing conversion for these parameter lines: \");\n\t\t\t\tfor (CLIArguments p : argumentsGroup.getCLIArgumentsList()) {\n\t\t\t\t\tSystem.out.print(argumentsList.indexOf(p) + \" \");\n\t\t\t\t}\n\t\t\t\tSystem.out.print(\"\\n\");\n\t\t\t}\n\t\t\t\n\t\t\texecuteArgumentsGroup(argumentsGroup);\n\t\t\t\n\t\t}\n\t\t\n\t}\n\n\tprivate static CLIArguments parseArguments(String[] unparsedArgs)\n\t\tthrows ArgumentValidationException, Exception {\n\t\t\n\t\tCLIArguments args = CliFactory.parseArguments(CLIArguments.class, unparsedArgs);\n\t\t\n\t\tif (!CLIArgumentsUtil.isValid(args)) {\n\t\t\tthrow new Exception(CLIArgumentsUtil.getErrorString(args));\n\t\t}\n\t\treturn args;\n\t\t\n\t}\n\n\tprivate static void executeArgumentsGroup(CLIArgumentsGroup argumentsGroup) {\n\t\t\n\t\t/* load configuration file */\n\t\t\n\t\tConfiguration config = new BaseConfiguration();\n\t\tFile configFile = null;\n\t\t\n\t\tCLIArguments representativeArgs = argumentsGroup.getRepresentative();\n\t\t\n\t\tif (representativeArgs.isConfig()) {\n\t\t\ttry {\n\t\t\t\tconfigFile = representativeArgs.getConfig();\n\t\t\t\tPropertiesConfiguration fileConfig = new PropertiesConfiguration();\n\t\t\t\tfileConfig.setListDelimiter(';');\n\t\t\t\tfileConfig.load(configFile);\n\t\t\t\tconfig = fileConfig;\n\t\t\t} catch (ConfigurationException e) {\n\t\t\t\tSystem.err.println(\"could not read config, ignoring it: \");\n\t\t\t\tSystem.err.println(e);\n\t\t\t}\n\t\t}\n\t\t\n\t\t/* run selected mode */\n\t\t\n\t\tProgramMode programMode = getProgramMode(representativeArgs);\n\t\t\n\t\tswitch (programMode) {\n\t\t\n\t\tcase HELP:\n\t\t\tSystem.out.println(\n\t\t\t\t\tCliFactory.createCli(CLIArguments.class).getHelpMessage()\n\t\t\t\t\t+ \"\\n\\nFor more information, see \" + GlobalValues.WIKI_URI);\n\t\t\tbreak;\n\t\t\t\n\t\tcase VERSION:\n\t\t\tSystem.out.println(\"OSM2World \" + VERSION_STRING);\n\t\t\tbreak;\n\t\t\n\t\tcase GUI:\n\t\t\ttry {\n\t\t\t\tUIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());\n\t\t\t} catch(Exception e) {\n\t\t\t\tSystem.out.println(\"Error setting native look and feel: \" + e);\n\t\t\t}\n\t\t\tFile input = representativeArgs.isInput() ?\n\t\t\t\t\trepresentativeArgs.getInput() : null;\n\t\t\tnew ViewerFrame(config, configFile, input).setVisible(true);\n\t\t\tbreak;\n\t\t\t\n\t\tcase CONVERT:\n\t\t\ttry {\n\t\t\t\tOutput.output(config, argumentsGroup);\n\t\t\t} catch (IOException e) {\n\t\t\t\te.printStackTrace();\n\t\t\t}\n\t\t\tbreak;\n\t\t\t\n\t\t}\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/console/Output.java",
"content": "package org.osm2world.console;\n\nimport java.io.File;\nimport java.io.FileWriter;\nimport java.io.IOException;\nimport java.io.PrintWriter;\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.HashMap;\nimport java.util.Map;\n\nimport org.apache.commons.configuration.Configuration;\nimport org.osm2world.console.CLIArgumentsUtil.OutputMode;\nimport org.osm2world.core.ConversionFacade;\nimport org.osm2world.core.ConversionFacade.Phase;\nimport org.osm2world.core.ConversionFacade.ProgressListener;\nimport org.osm2world.core.ConversionFacade.Results;\nimport org.osm2world.core.map_data.creation.MapProjection;\nimport org.osm2world.core.map_elevation.creation.EleConstraintEnforcer;\nimport org.osm2world.core.map_elevation.creation.LPEleConstraintEnforcer;\nimport org.osm2world.core.map_elevation.creation.LeastSquaresInterpolator;\nimport org.osm2world.core.map_elevation.creation.NaturalNeighborInterpolator;\nimport org.osm2world.core.map_elevation.creation.NoneEleConstraintEnforcer;\nimport org.osm2world.core.map_elevation.creation.SimpleEleConstraintEnforcer;\nimport org.osm2world.core.map_elevation.creation.TerrainInterpolator;\nimport org.osm2world.core.map_elevation.creation.ZeroInterpolator;\nimport org.osm2world.core.math.AxisAlignedBoundingBoxXZ;\nimport org.osm2world.core.math.VectorXYZ;\nimport org.osm2world.core.math.VectorXZ;\nimport org.osm2world.core.target.common.rendering.Camera;\nimport org.osm2world.core.target.common.rendering.OrthoTilesUtil;\nimport org.osm2world.core.target.common.rendering.OrthoTilesUtil.CardinalDirection;\nimport org.osm2world.core.target.common.rendering.Projection;\nimport org.osm2world.core.target.obj.ObjWriter;\nimport org.osm2world.core.target.povray.POVRayWriter;\nimport org.osm2world.core.util.functions.DefaultFactory;\n\npublic final class Output {\n\n\tprivate Output() {}\n\n\tpublic static void output(Configuration config,\n\t\t\tCLIArgumentsGroup argumentsGroup)\n\t\tthrows IOException {\n\t\t\n\t\tlong start = System.currentTimeMillis();\n\t\t\n\t\tConversionFacade cf = new ConversionFacade();\n\t\tPerformanceListener perfListener =\n\t\t\tnew PerformanceListener(argumentsGroup.getRepresentative());\n\t\tcf.addProgressListener(perfListener);\n\t\t\t\t\n\t\tString interpolatorType = config.getString(\"terrainInterpolator\");\n\t\tif (\"ZeroInterpolator\".equals(interpolatorType)) {\n\t\t\tcf.setTerrainEleInterpolatorFactory(\n\t\t\t\t\tnew DefaultFactory(ZeroInterpolator.class));\n\t\t} else if (\"LeastSquaresInterpolator\".equals(interpolatorType)) {\n\t\t\tcf.setTerrainEleInterpolatorFactory(\n\t\t\t\t\tnew DefaultFactory(LeastSquaresInterpolator.class));\n\t\t} else if (\"NaturalNeighborInterpolator\".equals(interpolatorType)) {\n\t\t\tcf.setTerrainEleInterpolatorFactory(\n\t\t\t\t\tnew DefaultFactory(NaturalNeighborInterpolator.class));\n\t\t}\n\t\t\n\t\tString enforcerType = config.getString(\"eleConstraintEnforcer\");\n\t\tif (\"NoneEleConstraintEnforcer\".equals(enforcerType)) {\n\t\t\tcf.setEleConstraintEnforcerFactory(\n\t\t\t\t\tnew DefaultFactory(NoneEleConstraintEnforcer.class));\n\t\t} else if (\"SimpleEleConstraintEnforcer\".equals(enforcerType)) {\n\t\t\tcf.setEleConstraintEnforcerFactory(\n\t\t\t\t\tnew DefaultFactory(SimpleEleConstraintEnforcer.class));\n\t\t} else if (\"LPEleConstraintEnforcer\".equals(enforcerType)) {\n\t\t\tcf.setEleConstraintEnforcerFactory(\n\t\t\t\t\tnew DefaultFactory(LPEleConstraintEnforcer.class));\n\t\t}\n\t\t\n\t\tResults results = cf.createRepresentations(\n\t\t\t\targumentsGroup.getRepresentative().getInput(), null, config, null);\n\t\t\n\t\tImageExporter exporter = null;\n\t\t\n\t\tfor (CLIArguments args : argumentsGroup.getCLIArgumentsList()) {\n\t\t\t\n\t\t\tCamera camera = null;\n\t\t\tProjection projection = null;\n\t\t\t\n\t\t\tif (args.isOviewTiles()) {\n\t\t\t\t\n\t\t\t\tcamera = OrthoTilesUtil.cameraForTiles(\n\t\t\t\t\t\tresults.getMapProjection(),\n\t\t\t\t\t\targs.getOviewTiles(),\n\t\t\t\t\t\targs.getOviewAngle(),\n\t\t\t\t\t\targs.getOviewFrom());\n\t\t\t\tprojection = OrthoTilesUtil.projectionForTiles(\n\t\t\t\t\t\tresults.getMapProjection(),\n\t\t\t\t\t\targs.getOviewTiles(),\n\t\t\t\t\t\targs.getOviewAngle(),\n\t\t\t\t\t\targs.getOviewFrom());\n\t\t\t\t\n\t\t\t} else if (args.isOviewBoundingBox()) {\n\t\t\t\t\n\t\t\t\tdouble angle = args.getOviewAngle();\n\t\t\t\tCardinalDirection from = args.getOviewFrom();\n\t\t\t\t\n\t\t\t\tCollection pointsXZ = new ArrayList();\n\t\t\t\tfor (LatLonEle l : args.getOviewBoundingBox()) {\n\t\t\t\t\tpointsXZ.add(results.getMapProjection().calcPos(l.lat, l.lon));\n\t\t\t\t}\n\t\t\t\tAxisAlignedBoundingBoxXZ bounds =\n\t\t\t\t\tnew AxisAlignedBoundingBoxXZ(pointsXZ);\n\t\t\t\t\t\t\t\n\t\t\t\tcamera = OrthoTilesUtil.cameraForBounds(bounds, angle, from);\n\t\t\t\tprojection = OrthoTilesUtil.projectionForBounds(bounds, angle, from);\n\t\t\t\t\n\t\t\t} else if (args.isPviewPos()) {\n\t\t\t\t\n\t\t\t\tMapProjection proj = results.getMapProjection();\n\t\t\t\t\n\t\t\t\tLatLonEle pos = args.getPviewPos();\n\t\t\t\tLatLonEle lookAt = args.getPviewLookat();\n\t\t\t\t\n\t\t\t\tcamera = new Camera();\n\t\t\t\tVectorXYZ posV = proj.calcPos(pos.lat, pos.lon).xyz(pos.ele);\n\t\t\t\tVectorXYZ laV =\tproj.calcPos(lookAt.lat, lookAt.lon).xyz(lookAt.ele);\n\t\t\t\tcamera.setCamera(posV.x, posV.y, posV.z, laV.x, laV.y, laV.z);\n\t\t\t\t\n\t\t\t\tprojection = new Projection(false,\n\t\t\t\t\t\targs.isPviewAspect() ? args.getPviewAspect() :\n\t\t\t\t\t\t\t(double)args.getResolution().x / args.getResolution().y,\n\t\t\t\t\t\t\targs.getPviewFovy(),\n\t\t\t\t\t\t0,\n\t\t\t\t\t\t1, 50000);\n\t\t\t\t\t\t\t\n\t\t\t}\n\t\t\t\n\t\t\tfor (File outputFile : args.getOutput()) {\n\t\t\t\t\n\t\t\t\tOutputMode outputMode =\n\t\t\t\t\tCLIArgumentsUtil.getOutputMode(outputFile);\n\t\t\t\t\n\t\t\t\tswitch (outputMode) {\n\t\n\t\t\t\tcase OBJ:\n\t\t\t\t\tInteger primitiveThresholdOBJ =\n\t\t\t\t\t\tconfig.getInteger(\"primitiveThresholdOBJ\", null);\n\t\t\t\t\tif (primitiveThresholdOBJ == null) {\n\t\t\t\t\t\tObjWriter.writeObjFile(outputFile,\n\t\t\t\t\t\t\t\tresults.getMapData(), results.getMapProjection(),\n\t\t\t\t\t\t\t\tcamera, projection);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tObjWriter.writeObjFiles(outputFile,\n\t\t\t\t\t\t\t\tresults.getMapData(), results.getMapProjection(),\n\t\t\t\t\t\t\t\tcamera, projection, primitiveThresholdOBJ);\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t\t\n\t\t\t\tcase POV:\n\t\t\t\t\tPOVRayWriter.writePOVInstructionFile(outputFile,\n\t\t\t\t\t\t\tresults.getMapData(), camera, projection);\n\t\t\t\t\tbreak;\n\t\t\t\t\t\n\t\t\t\tcase PNG:\n\t\t\t\tcase PPM:\n\t\t\t\tcase GD:\n\t\t\t\t\tif (camera == null || projection == null) {\n\t\t\t\t\t\tSystem.err.println(\"camera or projection missing\");\n\t\t\t\t\t}\n\t\t\t\t\tif (exporter == null) {\n\t\t\t\t\t\texporter = new ImageExporter(\n\t\t\t\t\t\t\t\tconfig, results, argumentsGroup);\n\t\t\t\t\t}\n\t\t\t\t\texporter.writeImageFile(outputFile, outputMode,\n\t\t\t\t\t\t\targs.getResolution().x, args.getResolution().y,\n\t\t\t\t\t\t\tcamera, projection);\n\t\t\t\t\tbreak;\n\t\t\t\t\t\n\t\t\t\t}\n\t\t\t\t\n\t\t\t}\n\t\t\t\n\t\t}\n\t\t\n\t\tif (exporter != null) {\n\t\t\texporter.freeResources();\n\t\t\texporter = null;\n\t\t}\n\t\t\n\t\tif (argumentsGroup.getRepresentative().getPerformancePrint()) {\n\t\t\tlong timeSec = (System.currentTimeMillis() - start) / 1000;\n\t\t\tSystem.out.println(\"finished after \" + timeSec + \" s\");\n\t\t}\n\t\t\n\t\tif (argumentsGroup.getRepresentative().isPerformanceTable()) {\n\t\t\tPrintWriter w = new PrintWriter(new FileWriter(\n\t\t\t\t\targumentsGroup.getRepresentative().getPerformanceTable(), true), true);\n\t\t\tw.printf(\"|%6d |%6d |%6d |%6d |%6d |%6d |\\n\",\n\t\t\t\t(perfListener.getPhaseDuration(Phase.MAP_DATA) + 500) / 1000,\n\t\t\t\t(perfListener.getPhaseDuration(Phase.REPRESENTATION) + 500) / 1000,\n\t\t\t\t(perfListener.getPhaseDuration(Phase.ELEVATION) + 500) / 1000,\n\t\t\t\t(perfListener.getPhaseDuration(Phase.TERRAIN) + 500) / 1000,\n\t\t\t\t(System.currentTimeMillis() - perfListener.getPhaseEnd(Phase.TERRAIN) + 500) / 1000,\n\t\t\t\t(System.currentTimeMillis() - start + 500) / 1000);\n\t\t\tw.close();\n\t\t}\n\n\t}\n\t\n\tprivate static class PerformanceListener implements ProgressListener {\n\t\t\n\t\tprivate final CLIArguments args;\n\t\tpublic PerformanceListener(CLIArguments args) {\n\t\t\tthis.args = args;\n\t\t}\n\n\t\tprivate Phase currentPhase = null;\n\t\tprivate long currentPhaseStart;\n\t\t\n\t\tprivate Map phaseStarts = new HashMap();\n\t\tprivate Map phaseEnds = new HashMap();\n\t\t\n\t\tpublic Long getPhaseStart(Phase phase) {\n\t\t\treturn phaseStarts.get(phase);\n\t\t}\n\t\t\n\t\tpublic Long getPhaseEnd(Phase phase) {\n\t\t\treturn phaseEnds.get(phase);\n\t\t}\n\t\t\n\t\tpublic Long getPhaseDuration(Phase phase) {\n\t\t\treturn getPhaseEnd(phase) - getPhaseStart(phase);\n\t\t}\n\t\t\n\t\t@Override\n\t\tpublic void updatePhase(Phase newPhase) {\n\t\t\t\n\t\t\tphaseStarts.put(newPhase, System.currentTimeMillis());\n\t\t\t\n\t\t\tif (currentPhase != null) {\n\t\t\t\t\n\t\t\t\tphaseEnds.put(currentPhase, System.currentTimeMillis());\n\t\t\t\t\n\t\t\t\tif (args.getPerformancePrint()) {\n\t\t\t\t\tlong ms = System.currentTimeMillis() - currentPhaseStart;\n\t\t\t\t\tSystem.out.println(\"phase \" + currentPhase\n\t\t\t\t\t\t+ \" finished after \" + ms + \" ms\");\n\t\t\t\t}\n\t\t\t\t\n\t\t\t}\n\t\t\t\n\t\t\tcurrentPhase = newPhase;\n\t\t\tcurrentPhaseStart = System.currentTimeMillis();\n\t\t\t\n\t\t}\n\t\t\n\t}\n\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/console/Resolution.java",
"content": "package org.osm2world.console;\n\nimport java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\n/**\n * immutable representation of an image resolution\n * (two positive integers)\n */\npublic class Resolution {\n\n\tpublic final int x;\n\tpublic final int y;\n\n\t/**\n\t * pattern for parseable arguments\n\t */\n\tpublic static final String PATTERN = \"([0-9]{1,9}),([0-9]{1,9})\";\n\t\n\t/**\n\t * regular constructor\n\t */\n\tpublic Resolution(int x, int y) {\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t\tvalidateValues();\n\t}\n\n\t/**\n\t * parsing constructor\n\t * @param arg command line argument to be parsed;\n\t * format see {@link #PATTERN}\n\t */\n\tpublic Resolution(String arg) {\n\t\tMatcher m = Pattern.compile(PATTERN).matcher(arg);\n\t\tif (m.matches()) {\n\t\t\tx = Integer.parseInt(m.group(1));\n\t\t\ty = Integer.parseInt(m.group(2));\n\t\t\tvalidateValues();\n\t\t} else {\n\t\t\tthrow new IllegalArgumentException(\"argument doesn't match: \" + arg);\n\t\t}\n\t}\n\n\t/**\n\t * @throws IllegalArgumentException for incorrect field values\n\t */\n\tprivate void validateValues() {\n\t\tif (x <= 0 || y <= 0) {\n\t\t\tthrow new IllegalArgumentException(\"not positive: \" + x + \", \" + y);\n\t\t}\n\t}\n\t\n\t@Override\n\tpublic String toString() {\n\t\treturn x + \",\" + y;\n\t}\n\t\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/console/package-info.java",
"content": "@ParametersAreNonnullByDefault\npackage org.osm2world.console;\n\nimport javax.annotation.ParametersAreNonnullByDefault;\n"
},
{
"path": "OSM2World/src/org/osm2world/console/package.html",
"content": "\n\n\n\n\n\ncommand line interface for OSM2World.\n\n"
},
{
"path": "OSM2World/src/org/osm2world/core/ConversionFacade.java",
"content": "package org.osm2world.core;\n\nimport static java.util.Collections.emptyList;\n\nimport java.io.File;\nimport java.io.IOException;\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.Collection;\nimport java.util.List;\n\nimport org.apache.commons.configuration.BaseConfiguration;\nimport org.apache.commons.configuration.Configuration;\nimport org.apache.commons.lang.time.StopWatch;\nimport org.openstreetmap.osmosis.core.domain.v0_6.Bound;\nimport org.osm2world.core.map_data.creation.MapProjection;\nimport org.osm2world.core.map_data.creation.MetricMapProjection;\nimport org.osm2world.core.map_data.creation.OSMToMapDataConverter;\nimport org.osm2world.core.map_data.creation.OriginMapProjection;\nimport org.osm2world.core.map_data.data.MapData;\nimport org.osm2world.core.map_data.object_info.AddressGatherer;\nimport org.osm2world.core.map_data.object_info.ObjectInfoManager;\nimport org.osm2world.core.map_elevation.creation.EleConstraintEnforcer;\nimport org.osm2world.core.map_elevation.creation.EleConstraintValidator;\nimport org.osm2world.core.map_elevation.creation.LeastSquaresInterpolator;\nimport org.osm2world.core.map_elevation.creation.NoneEleConstraintEnforcer;\nimport org.osm2world.core.map_elevation.creation.SRTMData;\nimport org.osm2world.core.map_elevation.creation.TerrainElevationData;\nimport org.osm2world.core.map_elevation.creation.TerrainInterpolator;\nimport org.osm2world.core.map_elevation.creation.ZeroInterpolator;\nimport org.osm2world.core.map_elevation.data.EleConnector;\nimport org.osm2world.core.math.VectorXYZ;\nimport org.osm2world.core.math.AxisAlignedBoundingBoxXZ;\nimport org.osm2world.core.osm.creation.JOSMFileHack;\nimport org.osm2world.core.osm.creation.OsmosisReader;\nimport org.osm2world.core.osm.data.OSMData;\nimport org.osm2world.core.target.Renderable;\nimport org.osm2world.core.target.Target;\nimport org.osm2world.core.target.TargetUtil;\nimport org.osm2world.core.target.common.material.Materials;\nimport org.osm2world.core.util.FaultTolerantIterationUtil;\nimport org.osm2world.core.util.TouchMapperProfile;\nimport org.osm2world.core.util.FaultTolerantIterationUtil.Operation;\nimport org.osm2world.core.util.functions.DefaultFactory;\nimport org.osm2world.core.util.functions.Factory;\nimport org.osm2world.core.world.creation.WorldCreator;\nimport org.osm2world.core.world.creation.WorldModule;\nimport org.osm2world.core.world.data.WorldObject;\nimport org.osm2world.core.world.modules.BarrierModule;\nimport org.osm2world.core.world.modules.BridgeModule;\nimport org.osm2world.core.world.modules.BuildingModule;\nimport org.osm2world.core.world.modules.CliffModule;\nimport org.osm2world.core.world.modules.GolfModule;\nimport org.osm2world.core.world.modules.InvisibleModule;\nimport org.osm2world.core.world.modules.ParkingModule;\nimport org.osm2world.core.world.modules.PoolModule;\nimport org.osm2world.core.world.modules.PowerModule;\nimport org.osm2world.core.world.modules.RailwayModule;\nimport org.osm2world.core.world.modules.RoadModule;\nimport org.osm2world.core.world.modules.StreetFurnitureModule;\nimport org.osm2world.core.world.modules.SurfaceAreaModule;\nimport org.osm2world.core.world.modules.TrafficSignModule;\nimport org.osm2world.core.world.modules.TreeModule;\nimport org.osm2world.core.world.modules.TunnelModule;\nimport org.osm2world.core.world.modules.WaterModule;\n\n/**\n * provides an easy way to call all steps of the conversion process\n * in the correct order\n */\npublic class ConversionFacade {\n\t\n\t/**\n\t * all results of a conversion run\n\t */\n\tpublic static final class Results {\n\t\t\n\t\tprivate final MapProjection mapProjection;\n\t\tprivate final MapData mapData;\n\t\tprivate final TerrainElevationData eleData;\n\t\t\n\t\tprivate Results(MapProjection mapProjection, MapData mapData, TerrainElevationData eleData) {\n\t\t\tthis.mapProjection = mapProjection;\n\t\t\tthis.mapData = mapData;\n\t\t\tthis.eleData = eleData;\n\t\t}\n\n\t\tpublic MapProjection getMapProjection() {\n\t\t\treturn mapProjection;\n\t\t}\n\t\t\n\t\tpublic MapData getMapData() {\n\t\t\treturn mapData;\n\t\t}\n\t\t\n\t\tpublic TerrainElevationData getEleData() {\n\t\t\treturn eleData;\n\t\t}\n\t\t\n\t\t/**\n\t\t * collects and returns all representations that implement a\n\t\t * renderableType, including terrain.\n\t\t * Convenience method.\n\t\t */\n\t\tpublic Collection getRenderables(Class renderableType) {\n\t\t\treturn getRenderables(renderableType, true, true);\n\t\t}\n\t\t\n\t\t/**\n\t\t * @see #getRenderables(Class)\n\t\t */\n\t\tpublic Collection getRenderables(\n\t\t\t\tClass renderableType, boolean includeGrid, boolean includeTerrain) {\n\t\t\t\n\t\t\t//TODO make use of or drop includeTerrain\n\t\t\t\n\t\t\tCollection representations = new ArrayList();\n\t\t\t\n\t\t\tif (includeGrid) {\n\t\t\t\tfor (R r : mapData.getWorldObjects(renderableType)) {\n\t\t\t\t\trepresentations.add(r);\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn representations;\n\t\t\t\n\t\t}\n\t\t\n\t}\n\t\n\t/**\n\t * generates a default list of modules for the conversion\n\t */\n\tprivate static final List createDefaultModuleList() {\n\t\t\n\t\treturn Arrays.asList((WorldModule)\n\t\t\t\tnew RoadModule(),\n\t\t\t\tnew RailwayModule(),\n\t\t\t\tnew BuildingModule(),\n\t\t\t\t//new ParkingModule(),\n\t\t\t\t//new TreeModule(),\n\t\t\t\t//new StreetFurnitureModule(),\n\t\t\t\t//new TrafficSignModule(),\n\t\t\t\tnew WaterModule()\n\t\t\t\t//new PoolModule(),\n\t\t\t\t//new GolfModule(),\n\t\t\t\t//new CliffModule(),\n\t\t\t\t//new BarrierModule(),\n\t\t\t\t//new PowerModule(),\n\t\t\t\t//new BridgeModule(),\n\t\t\t\t//new TunnelModule(),\n\t\t\t\t//new SurfaceAreaModule(),\n\t\t\t\t//new InvisibleModule()\n\t\t);\n\t\t\n\t}\n\n\tprivate Factory mapProjectionFactory =\n\t\tnew DefaultFactory(MetricMapProjection.class);\n\t\n\tprivate Factory terrainEleInterpolatorFactory =\n\t\tnew DefaultFactory(LeastSquaresInterpolator.class);\n\n\tprivate Factory eleConstraintEnforcerFactory =\n\t\tnew DefaultFactory(NoneEleConstraintEnforcer.class);\n\t\n\t/**\n\t * sets the factory that will make {@link MapProjection}\n\t * instances during subsequent calls to\n\t * {@link #createRepresentations(OSMData, List, Configuration, List)}.\n\t * \n\t * @see DefaultFactory\n\t */\n\tpublic void setMapProjectionFactory(\n\t\t\tFactory mapProjectionFactory) {\n\t\tthis.mapProjectionFactory = mapProjectionFactory;\n\t}\n\t\n\t/**\n\t * sets the factory that will make {@link EleConstraintEnforcer}\n\t * instances during subsequent calls to\n\t * {@link #createRepresentations(OSMData, List, Configuration, List)}.\n\t * \n\t * @see DefaultFactory\n\t */\n\tpublic void setEleConstraintEnforcerFactory(\n\t\t\tFactory interpolatorFactory) {\n\t\tthis.eleConstraintEnforcerFactory = interpolatorFactory;\n\t}\n\t\n\t/**\n\t * sets the factory that will make {@link TerrainInterpolator}\n\t * instances during subsequent calls to\n\t * {@link #createRepresentations(OSMData, List, Configuration, List)}.\n\t * \n\t * @see DefaultFactory\n\t */\n\tpublic void setTerrainEleInterpolatorFactory(\n\t\t\tFactory enforcerFactory) {\n\t\tthis.terrainEleInterpolatorFactory = enforcerFactory;\n\t}\n\t\n\t\n\t/**\n\t * performs all necessary steps to go from\n\t * an OSM file to the renderable {@link WorldObject}s.\n\t * Sends updates to {@link ProgressListener}s.\n\t * \n\t * @param osmFile file to read OSM data from; != null\n\t * @param worldModules modules that will create the {@link WorldObject}s\n\t * in the result; null to use a default module list\n\t * @param config set of parameters that controls various aspects\n\t * of the modules' behavior; null to use defaults\n\t * @param targets receivers of the conversion results; can be null if\n\t * you want to handle the returned results yourself\n\t */\n\tpublic Results createRepresentations(File osmFile,\n\t\t\tList worldModules, Configuration config,\n\t\t\tList> targets)\n\t\t\tthrows IOException {\n\n\t\tlong totalStart = TouchMapperProfile.start();\n\t\t\n\t\tif (osmFile == null) {\n\t\t\tthrow new IllegalArgumentException(\"osmFile must not be null\");\n\t\t}\n\t\t\n\t\tOSMData osmData = null;\n\t\tboolean useJOSMHack = false;\n\t\t\n\t\tif (JOSMFileHack.isJOSMGenerated(osmFile)) {\n\t\t\tuseJOSMHack = true;\n\t\t} else {\n\t\t\t\n\t\t\t/* try to read file using Osmosis */\n\t\t\t\n\t\t\ttry {\n\t\t\t\tlong readOsmStart = TouchMapperProfile.start();\n\t\t\t\tosmData = new OsmosisReader(osmFile).getData();\n\t\t\t\tTouchMapperProfile.logMillis(\"input.read_osmosis_ms\", readOsmStart);\n\t\t\t} catch (IOException e) {\n\t\t\t\t\n\t\t\t\tSystem.out.println(\"could not read file,\" +\n\t\t\t\t\t\t\" trying workaround for files created by JOSM\");\n\t\t\t\t\n\t\t\t\tuseJOSMHack = true;\n\t\t\t\t\t\t\t\n\t\t\t}\n\t\t\t\n\t\t}\n\t\t\n\t\t/* create a temporary \"cleaned up\" file as workaround for JOSM files */\n\t\t\n\t\tif (useJOSMHack) {\n\t\t\t\n\t\t\tFile tempFile;\n\t\t\ttry {\n\t\t\t\tlong josmCleanupStart = TouchMapperProfile.start();\n\t\t\t\ttempFile = JOSMFileHack.createTempOSMFile(osmFile);\n\t\t\t\tTouchMapperProfile.logMillis(\"input.josm_cleanup_ms\", josmCleanupStart);\n\t\t\t} catch (Exception e2) {\n\t\t\t\tthrow new IOException(\"could not read OSM file\" +\n\t\t\t\t\t\t\" (not even with workaround for JOSM files)\", e2);\n\t\t\t}\n\t\t\t\n\t\t\tlong readCleanedStart = TouchMapperProfile.start();\n\t\t\tosmData = new OsmosisReader(tempFile).getData();\n\t\t\tTouchMapperProfile.logMillis(\"input.read_cleaned_osmosis_ms\", readCleanedStart);\n\t\t\t\n\t\t}\n\t\t\n\t\tResults results = createRepresentations(osmData, worldModules, config, targets);\n\t\tTouchMapperProfile.logMillis(\"conversion.from_file_total_ms\", totalStart);\n\t\treturn results;\n\t\t\n\t}\n\t\n\t\n\t/**\n\t * variant of\n\t * {@link #createRepresentations(File, List, Configuration, List)}\n\t * that accepts {@link OSMData} instead of a file.\n\t * Use this when all data is already\n\t * in memory, for example with editor applications.\n\t * \n\t * @param osmData input data; != null\n\t * @param worldModules modules that will create the {@link WorldObject}s\n\t * in the result; null to use a default module list\n\t * @param config set of parameters that controls various aspects\n\t * of the modules' behavior; null to use defaults\n\t * @param targets receivers of the conversion results; can be null if\n\t * you want to handle the returned results yourself\n\t * \n\t * @throws BoundingBoxSizeException for oversized bounding boxes\n\t */\n\tpublic Results createRepresentations(OSMData osmData,\n\t\t\tList worldModules, Configuration config,\n\t\t\tList> targets)\n\t\t\tthrows IOException, BoundingBoxSizeException {\n\n\t\tlong totalStart = TouchMapperProfile.start();\n\t\t\n\t\t/* check the inputs */\n\t\t\n\t\tif (osmData == null) {\n\t\t\tthrow new IllegalArgumentException(\"osmData must not be null\");\n\t\t}\n\t\t\n\t\tif (config == null) {\n\t\t\tconfig = new BaseConfiguration();\n\t\t}\n\t\t\n\t\tDouble maxBoundingBoxDegrees = config.getDouble(\"maxBoundingBoxDegrees\", null);\n\t\tif (maxBoundingBoxDegrees != null) {\n\t\t\tfor (Bound bound : osmData.getBounds()) {\n\t\t\t\tif (bound.getTop() - bound.getBottom() > maxBoundingBoxDegrees\n\t\t\t\t\t\t|| bound.getRight() - bound.getLeft() > maxBoundingBoxDegrees) {\n\t\t\t\t\tthrow new BoundingBoxSizeException(bound);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t/* create map data from OSM data */\n\t\tupdatePhase(Phase.MAP_DATA);\n\t\t\n\t\tOriginMapProjection mapProjection = mapProjectionFactory.make();\n\t\tlong mapProjectionStart = TouchMapperProfile.start();\n\t\tmapProjection.setOrigin(osmData);\n\t\tTouchMapperProfile.logMillis(\"map_data.map_projection_origin_ms\",\n\t\t\t\tmapProjectionStart);\n\t\t\n\t\tOSMToMapDataConverter converter = new OSMToMapDataConverter(mapProjection, config);\n\t\tlong mapDataCreationStart = TouchMapperProfile.start();\n\t\tMapData mapData = converter.createMapData(osmData);\n\t\tTouchMapperProfile.logMillis(\"map_data.converter_total_ms\",\n\t\t\t\tmapDataCreationStart);\n\t\t\n\t\tAxisAlignedBoundingBoxXZ boundary = mapData.getBoundary();\n\t\t\n\t\t/* apply world modules */\n\t\tupdatePhase(Phase.REPRESENTATION);\n\t\t\n\t\tif (worldModules == null) {\n\t\t\tworldModules = createDefaultModuleList();\n\t\t}\n\t\t\n\t\tMaterials.configureMaterials(config);\n\t\t\t//this will cause problems if multiple conversions are run\n\t\t\t//at the same time, because global variables are being modified\n\t\t\n\t\tWorldCreator moduleManager =\n\t\t\tnew WorldCreator(config, worldModules);\n\t\tlong worldModulesStart = TouchMapperProfile.start();\n\t\tmoduleManager.addRepresentationsTo(mapData);\n\t\tTouchMapperProfile.logMillis(\"representation.world_creator_total_ms\",\n\t\t\t\tworldModulesStart);\n\t\t\n\t\t/* determine elevations */\n\t\tupdatePhase(Phase.ELEVATION);\n\t\t\n\t\tString srtmDir = config.getString(\"srtmDir\", null);\n\t\tTerrainElevationData eleData = null;\n\t\t\t\t\n\t\tif (srtmDir != null) {\n\t\t\teleData = new SRTMData(new File(srtmDir), mapProjection);\n\t\t}\n\t\t\n\t\tlong elevationsStart = TouchMapperProfile.start();\n\t\tcalculateElevations(mapData, eleData, config);\n\t\tTouchMapperProfile.logMillis(\"elevation.total_ms\", elevationsStart);\n\t\t\n\t\t/* create terrain */\n\t\tupdatePhase(Phase.TERRAIN); //TODO this phase may be obsolete\n\t\t\t\t\n\t\t/* supply results to targets and caller */\n\t\tupdatePhase(Phase.FINISHED);\n\t\t\n\t\tboolean underground = config.getBoolean(\"renderUnderground\", true);\n\t\t\n\t\tif (targets != null) {\n\t\t\tlong targetsStart = TouchMapperProfile.start();\n\t\t\tfor (Target target : targets) {\n\t\t\t\tTargetUtil.renderWorldObjects(target, mapData, underground);\n\t\t\t\ttarget.finish();\n\t\t\t}\n\t\t\tTouchMapperProfile.logMillis(\"output.targets_render_and_finish_ms\",\n\t\t\t\t\ttargetsStart);\n\t\t}\n\n\t\tlong addressesStart = TouchMapperProfile.start();\n\t\tAddressGatherer.gather(osmData, mapData);\n\t\tTouchMapperProfile.logMillis(\"output.address_gather_ms\", addressesStart);\n\t\tTouchMapperProfile.logMillis(\"conversion.from_osm_data_total_ms\", totalStart);\n\t\t\n\t\treturn new Results(mapProjection, mapData, eleData);\n\t\t\n\t}\n\t\n\t/**\n\t * uses OSM data and an terrain elevation data (usually from an external\n\t * source) to calculate elevations for all {@link EleConnector}s of the\n\t * {@link WorldObject}s\n\t */\n\tprivate void calculateElevations(MapData mapData,\n\t\t\tTerrainElevationData eleData, Configuration config) {\n\t\t\t\t\n\t\tfinal TerrainInterpolator interpolator =\n\t\t\t\t(eleData != null)\n\t\t\t\t? terrainEleInterpolatorFactory.make()\n\t\t\t\t: new ZeroInterpolator();\n\t\t\n\t\t/* provide known elevations from eleData to the interpolator */\n\t\t\n\t\tStopWatch stopWatch = new StopWatch();\n\t\tstopWatch.start();\n\t\t\t\t\n\t\tif (!(interpolator instanceof ZeroInterpolator)) {\n\t\t\n\t\t\tCollection sites = emptyList();\n\t\t\t\n\t\t\ttry {\n\t\t\t\t\t\t\t\n\t\t\t\tsites = eleData.getSites(mapData);\n\t\t\t\t\n\t\t\t\tSystem.out.println(\"time getSites: \" + stopWatch);\n\t\t\t\tstopWatch.reset();\n\t\t\t\tstopWatch.start();\n\t\t\t\t\n\t\t\t} catch (IOException e) {\n\t\t\t\te.printStackTrace();\n\t\t\t}\n\t\t\t\n\t\t\tinterpolator.setKnownSites(sites);\n\t\t\t\n\t\t\tSystem.out.println(\"time setKnownSites: \" + stopWatch);\n\t\t\tstopWatch.reset();\n\t\t\tstopWatch.start();\n\t\t\t\n\t\t}\n\t\t\n\t\t/* interpolate connectors' elevations */\n\t\t\n\t\tfinal List connectors = new ArrayList();\n\t\t\n\t\tFaultTolerantIterationUtil.iterate(mapData.getWorldObjects(),\n\t\t\t\tnew Operation() {\n\t\t\t@Override public void perform(WorldObject worldObject) {\n\t\t\t\t\n\t\t\t\tfor (EleConnector conn : worldObject.getEleConnectors()) {\n\t\t\t\t\tconn.setPosXYZ(interpolator.interpolateEle(conn.pos));\n\t\t\t\t\tconnectors.add(conn);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t}\n\t\t});\n\t\t\n\t\tSystem.out.println(\"time terrain interpolation: \" + stopWatch);\n\t\tstopWatch.reset();\n\t\tstopWatch.start();\n\t\t\n\t\t/* enforce constraints defined by WorldObjects */\n\t\t\n\t\tboolean debugConstraints = config.getBoolean(\"debugConstraints\", false);\n\t\t\n\t\tfinal EleConstraintEnforcer enforcer = debugConstraints\n\t\t\t\t? new EleConstraintValidator(mapData,\n\t\t\t\t\t\teleConstraintEnforcerFactory.make())\n\t\t\t\t: eleConstraintEnforcerFactory.make();\n\t\t\n\t\tenforcer.addConnectors(connectors);\n\t\t\n\t\tif (!(enforcer instanceof NoneEleConstraintEnforcer)) {\n\t\t\t\n\t\t\tFaultTolerantIterationUtil.iterate(mapData.getWorldObjects(),\n\t\t\t\t\tnew Operation() {\n\t\t\t\t@Override public void perform(WorldObject worldObject) {\n\t\t\t\t\t\n\t\t\t\t\tworldObject.defineEleConstraints(enforcer);\n\t\t\t\t\t\n\t\t\t\t}\n\t\t\t});\n\t\t\t\n\t\t}\n\t\t\n\t\tSystem.out.println(\"time add constraints: \" + stopWatch);\n\t\tstopWatch.reset();\n\t\tstopWatch.start();\n\t\t\n\t\tenforcer.enforceConstraints();\n\t\t\n\t\tSystem.out.println(\"time enforce constraints: \" + stopWatch);\n\t\tstopWatch.reset();\n\t\tstopWatch.start();\n\t\t\n\t}\n\t\n\tpublic static enum Phase {\n\t\tMAP_DATA,\n\t\tREPRESENTATION,\n\t\tELEVATION,\n\t\tTERRAIN,\n\t\tFINISHED\n\t}\n\t\n\t/**\n\t * implemented by classes that want to be informed about\n\t * a conversion run's progress\n\t */\n\tpublic static interface ProgressListener {\n\t\t\t\t\n\t\t/** announces the start of a new phase */\n\t\tpublic void updatePhase(Phase newPhase);\n\t\t\n//\t\t/** announces the fraction of the current phase that is completed */\n//\t\tpublic void updatePhaseProgress(float phaseProgress);\n\n\t}\n\t\n\tprivate List listeners = new ArrayList();\n\t\n\tpublic void addProgressListener(ProgressListener listener) {\n\t\tlisteners.add(listener);\n\t}\n\t\n\tprivate void updatePhase(Phase newPhase) {\n\t\tfor (ProgressListener listener : listeners) {\n\t\t\tlistener.updatePhase(newPhase);\n\t\t}\n\t}\n\t\n//\tprivate void updatePhaseProgress(float phaseProgress) {\n//\t\tfor (ProgressListener listener : listeners) {\n//\t\t\tlistener.updatePhaseProgress(phaseProgress);\n//\t\t}\n//\t}\n\t\n\t/**\n\t * exception to be thrown if the OSM input data covers an area\n\t * larger than the maxBoundingBoxDegrees config property\n\t */\n\tpublic static class BoundingBoxSizeException extends RuntimeException {\n\t\t\n\t\tprivate static final long serialVersionUID = 2841146365929523046L; //generated VersionID\n\t\tpublic final Bound bound;\n\n\t\tprivate BoundingBoxSizeException(Bound bound) {\n\t\t\tthis.bound = bound;\n\t\t}\n\t\t\n\t\t@Override\n\t\tpublic String toString() {\n\t\t\treturn \"oversized bounding box: \" + bound;\n\t\t}\n\t\t\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/GlobalValues.java",
"content": "package org.osm2world.core;\n\n/**\n * globally accessible constants\n */\npublic final class GlobalValues {\n\n\tprivate GlobalValues() {};\n\t\n\t/** version string */\n\tpublic static final String VERSION_STRING = \"0.2.0\";\n\t\n\t/** link to the OSM wiki documentation */\n\tpublic static final String WIKI_URI = \"http://wiki.osm.org/OSM2World\";\n\n\t/** link to OSM2World home page */\n\tpublic static final String OSM2WORLD_URI = \"http://osm2world.org\";\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/heightmap/creation/EmptyTerrainElevationGrid.java",
"content": "package org.osm2world.core.heightmap.creation;\n\nimport org.osm2world.core.heightmap.data.AbstractCellularTerrainElevation;\nimport org.osm2world.core.math.AxisAlignedBoundingBoxXZ;\nimport org.osm2world.core.math.VectorXZ;\n\npublic class EmptyTerrainElevationGrid extends\n\t\tAbstractCellularTerrainElevation {\n\t\n\tpublic EmptyTerrainElevationGrid(AxisAlignedBoundingBoxXZ bounds,\n\t\t\tint numPointsX, int numPointsZ) {\n\t\tsuper(bounds, numPointsX, numPointsZ);\n\t}\n\t\n\t@Override\n\tprotected Float getElevation(VectorXZ pos) {\n\t\treturn null;\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/heightmap/creation/FlatTerrainElevation.java",
"content": "package org.osm2world.core.heightmap.creation;\n\nimport org.osm2world.core.heightmap.data.AbstractCellularTerrainElevation;\nimport org.osm2world.core.math.AxisAlignedBoundingBoxXZ;\nimport org.osm2world.core.math.VectorXZ;\n\npublic class FlatTerrainElevation extends AbstractCellularTerrainElevation {\n\t\n\tpublic FlatTerrainElevation(AxisAlignedBoundingBoxXZ boundary,\n\t\t\tint numPointsX, int numPointsZ) {\n\t\tsuper(boundary, numPointsX, numPointsZ);\n\t}\n\t\n\t@Override\n\tprotected Float getElevation(VectorXZ pos) {\n\t\treturn 0f;\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/heightmap/creation/WaveTerrainElevation.java",
"content": "package org.osm2world.core.heightmap.creation;\n\nimport org.osm2world.core.heightmap.data.AbstractCellularTerrainElevation;\nimport org.osm2world.core.math.AxisAlignedBoundingBoxXZ;\nimport org.osm2world.core.math.VectorXZ;\n\npublic class WaveTerrainElevation extends AbstractCellularTerrainElevation {\n\t\n\tpublic WaveTerrainElevation(AxisAlignedBoundingBoxXZ boundary,\n\t\t\tint numPointsX, int numPointsZ) {\n\t\tsuper(boundary, numPointsX, numPointsZ);\n\t}\n\t\n\t@Override\n\tprotected Float getElevation(VectorXZ pos) {\n\t\treturn (float) Math.sin(pos.x) * 10;\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/heightmap/data/AbstractCellularTerrainElevation.java",
"content": "package org.osm2world.core.heightmap.data;\n\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.Iterator;\nimport java.util.List;\nimport java.util.NoSuchElementException;\n\nimport org.osm2world.core.math.AxisAlignedBoundingBoxXZ;\nimport org.osm2world.core.math.PolygonXYZ;\nimport org.osm2world.core.math.PolygonXZ;\nimport org.osm2world.core.math.SimplePolygonXZ;\nimport org.osm2world.core.math.VectorXYZ;\nimport org.osm2world.core.math.VectorXZ;\n\npublic abstract class AbstractCellularTerrainElevation implements\n\t\tCellularTerrainElevation {\n\t\n\tfinal int numPointsX;\n\tfinal int numPointsZ;\n\t\n\tfinal Collection terrainPoints;\n\tfinal TerrainPoint[][] terrainPointGrid;\n\t\n\t@Override\n\tpublic Collection getTerrainPoints() {\n\t\treturn terrainPoints;\n\t}\n\n\t@Override\n\tpublic TerrainPoint[][] getTerrainPointGrid() {\n\t\treturn terrainPointGrid;\n\t}\n\n\t@Override\n\tpublic PolygonXYZ getBoundaryPolygon() {\n\t\t\n\t\tList vertices = new ArrayList();\n\t\t\n\t\t// first row\n\t\tfor (int x = 0; x < numPointsX; x++) {\n\t\t\tvertices.add(vectorXYZForPointAt(x, 0));\n\t\t}\n\n\t\t// last column\n\t\tfor (int z = 1; z < numPointsZ - 1; z++) {\n\t\t\tvertices.add(vectorXYZForPointAt(numPointsX - 1, z));\n\t\t}\n\n\t\t// last row\n\t\tfor (int x = numPointsX - 1; x >= 0; x--) {\n\t\t\tvertices.add(vectorXYZForPointAt(x, numPointsZ - 1));\n\t\t}\n\n\t\t// first column\n\t\tfor (int z = numPointsZ - 2; z >= 0 /* [0][0] will be added again*/; z--) {\n\t\t\tvertices.add(vectorXYZForPointAt(0, z));\n\t\t}\n\t\t\n\t\treturn new PolygonXYZ(vertices);\n\t\t\n\t}\n\n\t@Override\n\tpublic PolygonXZ getBoundaryPolygonXZ() {\n\t\t\n\t\tList vertices = new ArrayList();\n\t\t\n\t\t// first row\n\t\tfor (int x = 0; x < numPointsX; x++) {\n\t\t\tvertices.add(vectorXZForPointAt(x, 0));\n\t\t}\n\n\t\t// last column\n\t\tfor (int z = 1; z < numPointsZ - 1; z++) {\n\t\t\tvertices.add(vectorXZForPointAt(numPointsX - 1, z));\n\t\t}\n\n\t\t// last row\n\t\tfor (int x = numPointsX - 1; x >= 0; x--) {\n\t\t\tvertices.add(vectorXZForPointAt(x, numPointsZ - 1));\n\t\t}\n\n\t\t// first column\n\t\tfor (int z = numPointsZ - 2; z >= 0 /* [0][0] will be added again*/; z--) {\n\t\t\tvertices.add(vectorXZForPointAt(0, z));\n\t\t}\n\t\t\n\t\treturn new PolygonXZ(vertices);\n\t\t\n\t}\n\n\tprivate VectorXYZ vectorXYZForPointAt(int x, int z) {\n\t\tTerrainPoint point = terrainPointGrid[x][z];\n\t\treturn point.getPos().xyz(point.getEle());\n\t}\n\n\tprivate VectorXZ vectorXZForPointAt(int x, int z) {\n\t\tTerrainPoint point = terrainPointGrid[x][z];\n\t\treturn point.getPos();\n\t}\n\t\n\t@Override\n\tpublic Iterable getCells() {\n\t\t\n\t\treturn new Iterable() {\n\t\t\t@Override public Iterator iterator() {\n\t\t\t\treturn new CellIterator();\n\t\t\t}\n\t\t};\n\t\t\n\t}\n\t\n\t//TODO (duplicated code): merge with independently written version from IntersectionGrid\n\tprivate final class CellIterator implements Iterator {\n\n\t\tint currX = -1, currZ = 0;\n\t\t\n\t\t@Override\n\t\tpublic boolean hasNext() {\n\t\t\treturn currX + 1 < numPointsX-1 || currZ + 2 < numPointsZ-1;\n\t\t}\n\n\t\t@Override\n\t\tpublic CellImpl next() {\n\t\t\t\n\t\t\tcurrX += 1;\n\t\t\tif (currX == numPointsX-1) {\n\t\t\t\tcurrZ += 1;\n\t\t\t\tcurrX = 0;\n\t\t\t\tif (currZ == numPointsZ-1) {\n\t\t\t\t\tthrow new NoSuchElementException();\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn new CellImpl(currX, currZ);\n\t\t\t\n\t\t}\n\n\t\t@Override\n\t\tpublic void remove() {\n\t\t\tthrow new UnsupportedOperationException();\n\t\t}\n\t\t\n\t}\n\t\n\tprivate final class CellImpl implements TerrainElevationCell {\n\t\t\n\t\tprivate int leftXIndex;\n\t\tprivate int bottomZIndex;\n\t\t\n\t\tpublic CellImpl(int leftXIndex, int bottomZIndex) {\n\t\t\t\n\t\t\tassert leftXIndex + 1 < numPointsX\n\t\t\t\t&& bottomZIndex + 1 < numPointsZ;\n\t\t\t\n\t\t\tthis.leftXIndex = leftXIndex;\n\t\t\tthis.bottomZIndex = bottomZIndex;\n\t\t\t\n\t\t}\n\t\t\n\t\t@Override public final TerrainPoint getBottomLeft() {\n\t\t\treturn terrainPointGrid[leftXIndex][bottomZIndex];\n\t\t}\n\t\t@Override public final TerrainPoint getTopLeft() {\n\t\t\treturn terrainPointGrid[leftXIndex][bottomZIndex+1];\n\t\t}\n\t\t@Override public final TerrainPoint getBottomRight() {\n\t\t\treturn terrainPointGrid[leftXIndex+1][bottomZIndex];\n\t\t}\n\t\t@Override public final TerrainPoint getTopRight() {\n\t\t\treturn terrainPointGrid[leftXIndex+1][bottomZIndex+1];\n\t\t}\n\t\t\n\t\t@Override\n\t\tpublic Collection getTerrainPoints() {\n\t\t\tList terrainPoints = new ArrayList(4);\n\t\t\tterrainPoints.add(terrainPointGrid[leftXIndex][bottomZIndex]);\n\t\t\tterrainPoints.add(terrainPointGrid[leftXIndex+1][bottomZIndex]);\n\t\t\tterrainPoints.add(terrainPointGrid[leftXIndex+1][bottomZIndex+1]);\n\t\t\tterrainPoints.add(terrainPointGrid[leftXIndex][bottomZIndex+1]);\n\t\t\treturn terrainPoints;\n\t\t}\n\t\t\n\t\t@Override\n\t\tpublic final PolygonXYZ getPolygonXYZ() {\n\t\t\tList vertices = new ArrayList(5);\n\t\t\tvertices.add(vectorXYZForPointAt(leftXIndex, bottomZIndex));\n\t\t\tvertices.add(vectorXYZForPointAt(leftXIndex+1, bottomZIndex));\n\t\t\tvertices.add(vectorXYZForPointAt(leftXIndex+1, bottomZIndex+1));\n\t\t\tvertices.add(vectorXYZForPointAt(leftXIndex, bottomZIndex+1));\n\t\t\tvertices.add(vertices.get(0));\n\t\t\treturn new PolygonXYZ(vertices);\n\t\t}\n\t\t\n\t\t@Override\n\t\tpublic final SimplePolygonXZ getPolygonXZ() {\n\t\t\tList vertices = new ArrayList(5);\n\t\t\tvertices.add(vectorXZForPointAt(leftXIndex, bottomZIndex));\n\t\t\tvertices.add(vectorXZForPointAt(leftXIndex+1, bottomZIndex));\n\t\t\tvertices.add(vectorXZForPointAt(leftXIndex+1, bottomZIndex+1));\n\t\t\tvertices.add(vectorXZForPointAt(leftXIndex, bottomZIndex+1));\n\t\t\tvertices.add(vertices.get(0));\n\t\t\treturn new SimplePolygonXZ(vertices);\n\t\t}\n\t\t\n\t\t@Override\n\t\tpublic AxisAlignedBoundingBoxXZ getAxisAlignedBoundingBoxXZ() {\n\t\t\treturn new AxisAlignedBoundingBoxXZ(\n\t\t\t\tMath.min(getTopLeft().getPos().x, getBottomLeft().getPos().x),\n\t\t\t\tMath.min(getBottomLeft().getPos().z, getBottomRight().getPos().z),\n\t\t\t\tMath.max(getTopRight().getPos().x, getBottomRight().getPos().x),\n\t\t\t\tMath.max(getTopLeft().getPos().z, getTopRight().getPos().z));\n\t\t}\n\t\t\n\t\t@Override\n\t\tpublic String toString() {\n\t\t\treturn \"cell at x: \" + leftXIndex + \", z: \" + bottomZIndex;\n\t\t}\n\n\t\t/* auto-generated hashCode and equals follow */\n\t\t\n\t\t@Override\n\t\tpublic int hashCode() {\n\t\t\tfinal int prime = 31;\n\t\t\tint result = 1;\n\t\t\tresult = prime * result + getOuterType().hashCode();\n\t\t\tresult = prime * result + bottomZIndex;\n\t\t\tresult = prime * result + leftXIndex;\n\t\t\treturn result;\n\t\t}\n\n\t\t@Override\n\t\tpublic boolean equals(Object obj) {\n\t\t\tif (this == obj)\n\t\t\t\treturn true;\n\t\t\tif (obj == null)\n\t\t\t\treturn false;\n\t\t\tif (getClass() != obj.getClass())\n\t\t\t\treturn false;\n\t\t\tCellImpl other = (CellImpl) obj;\n\t\t\tif (!getOuterType().equals(other.getOuterType()))\n\t\t\t\treturn false;\n\t\t\tif (bottomZIndex != other.bottomZIndex)\n\t\t\t\treturn false;\n\t\t\tif (leftXIndex != other.leftXIndex)\n\t\t\t\treturn false;\n\t\t\treturn true;\n\t\t}\n\n\t\tprivate AbstractCellularTerrainElevation getOuterType() {\n\t\t\treturn AbstractCellularTerrainElevation.this;\n\t\t}\n\t\t\n\t}\n\t\n\tpublic AbstractCellularTerrainElevation(AxisAlignedBoundingBoxXZ boundary,\n\t\t\tint numPointsX, int numPointsZ) {\n\n\t\tif (numPointsX < 2 || numPointsZ < 2) {\n\t\t\tthrow new IllegalArgumentException(\"need at least 2x2 points for cell grid\");\n\t\t}\n\t\t\n\t\tthis.numPointsX = numPointsX;\n\t\tthis.numPointsZ = numPointsZ;\n\t\t\n\t\tterrainPoints = new ArrayList(numPointsX * numPointsZ);\n\t\tterrainPointGrid = new TerrainPoint[numPointsX][numPointsZ];\n\n\t\tfor (int x = 0; x < numPointsX; x++) {\n\t\t\tfor (int z = 0; z < numPointsZ; z++) {\n\n\t\t\t\tVectorXZ pos = new VectorXZ(boundary.minX + x * boundary.sizeX()\n\t\t\t\t\t\t/ (numPointsX - 1), boundary.minZ + z * boundary.sizeZ()\n\t\t\t\t\t\t/ (numPointsZ - 1));\n\n\t\t\t\tTerrainPoint terrainPoint = new TerrainPoint(pos,\n\t\t\t\t\t\tgetElevation(pos));\n\n\t\t\t\tterrainPointGrid[x][z] = terrainPoint;\n\t\t\t\tterrainPoints.add(terrainPoint);\n\n\t\t\t}\n\t\t}\n\n\t}\n\n\tprotected abstract Float getElevation(VectorXZ pos);\n\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/heightmap/data/CellularTerrainElevation.java",
"content": "package org.osm2world.core.heightmap.data;\n\nimport org.osm2world.core.math.PolygonXYZ;\nimport org.osm2world.core.math.PolygonXZ;\n\n/**\n * Terrain elevation data that consists of\n * points arranged in a grid structure (2d array).\n * \n * The grid\n * \n * - needs to be complete (points might have unknown elevation, though)\n *
- does not need to have rectangular grid cells, they may be deformed\n *
\n */\npublic interface CellularTerrainElevation extends TerrainElevation {\n\n\t/**\n\t * @return regular two-dimensional array (not jagged)\n\t */\n\tTerrainPoint[][] getTerrainPointGrid();\n\t\n\t/**\n\t * returns the boundary created from the first and last rows and columns\n\t * of the grid.\n\t * This requires that all {@link TerrainPoint}s' elevations have already\n\t * been set to non-null values.\n\t */\n\tPolygonXYZ getBoundaryPolygon();\n\t\n\t/**\n\t * returns the boundary created from the first and last rows and columns\n\t * of the grid.\n\t */\n\tPolygonXZ getBoundaryPolygonXZ();\n\t\n\t/**\n\t * returns Iterable over cells.\n\t * This is a convenience method for operations that need to be\n\t * performed for all cells. The iterator cannot be used to remove cells.\n\t */\n\tIterable getCells();\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/heightmap/data/TerrainElevation.java",
"content": "package org.osm2world.core.heightmap.data;\n\nimport java.util.Collection;\n\n/**\n * elevation data for the ground.\n * Rather abstract interface that doesn't impose restrictions\n * on the order of points with known elevation.\n */\npublic interface TerrainElevation {\n\t\n\tpublic Collection getTerrainPoints();\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/heightmap/data/TerrainElevationCell.java",
"content": "package org.osm2world.core.heightmap.data;\n\nimport java.util.Collection;\n\nimport org.osm2world.core.math.PolygonXYZ;\nimport org.osm2world.core.math.SimplePolygonXZ;\nimport org.osm2world.core.math.datastructures.IntersectionTestObject;\n\npublic interface TerrainElevationCell extends IntersectionTestObject {\n\n\tpublic TerrainPoint getTopLeft();\n\tpublic TerrainPoint getBottomLeft();\n\tpublic TerrainPoint getTopRight();\n\tpublic TerrainPoint getBottomRight();\n\t\n\tpublic Collection getTerrainPoints();\n\t\t\n\t/** returns the counterclockwise polygon surrounding this cell. */\n\tpublic SimplePolygonXZ getPolygonXZ();\n\t\n\t/**\n\t * returns 3d polygon surrounding this cell.\n\t * ordering and XZ coordinates are the same as for {@link #getPolygonXZ()}.\n\t */\n\tpublic PolygonXYZ getPolygonXYZ();\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/heightmap/data/TerrainPoint.java",
"content": "package org.osm2world.core.heightmap.data;\n\nimport org.osm2world.core.math.VectorXYZ;\nimport org.osm2world.core.math.VectorXZ;\n\npublic class TerrainPoint {\n\t\n\tprivate final VectorXZ pos;\n\tprivate Float ele;\n\t\n\tpublic TerrainPoint(VectorXZ pos, Float ele) {\n\t\tthis.pos = pos;\n\t\tthis.ele = ele;\n\t}\n\t\n\tpublic VectorXZ getPos() {\n\t\treturn pos;\n\t}\n\t\n\tpublic VectorXYZ getPosXYZ() {\n\t\treturn pos.xyz(ele);\n\t}\n\t\n\t/**\n\t * returns the point's elevation;\n\t * null indicates an unknown elevation\n\t */\n\tpublic Float getEle() {\n\t\treturn ele;\n\t}\n\t\n\t/**\n\t * sets the point's elevation;\n\t * null indicates an unknown elevation\n\t */\n\tpublic void setEle(float ele) {\n\t\tthis.ele = ele;\n\t}\n\t\n\t@Override\n\tpublic String toString() {\n\t\treturn \"(\" + pos + \",\" + ele + \")\";\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/heightmap/package.html",
"content": "\n\n\n\n\n\nterrain heightmaps\n\n"
},
{
"path": "OSM2World/src/org/osm2world/core/map_data/creation/EmptyTerrainBuilder.java",
"content": "package org.osm2world.core.map_data.creation;\n\nimport static java.lang.Math.min;\n\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.List;\n\nimport org.openstreetmap.josm.plugins.graphview.core.data.EmptyTagGroup;\nimport org.openstreetmap.josm.plugins.graphview.core.data.MapBasedTagGroup;\nimport org.openstreetmap.josm.plugins.graphview.core.data.Tag;\nimport org.osm2world.core.map_data.data.MapArea;\nimport org.osm2world.core.map_data.data.MapNode;\nimport org.osm2world.core.math.AxisAlignedBoundingBoxXZ;\nimport org.osm2world.core.math.VectorGridXZ;\nimport org.osm2world.core.math.VectorXZ;\nimport org.osm2world.core.osm.data.OSMNode;\nimport org.osm2world.core.osm.data.OSMWay;\n\n/**\n * utility class for building geometry representing empty terrain.\n */\npublic class EmptyTerrainBuilder {\n\n\t/** prevents instantiation */\n\tprivate EmptyTerrainBuilder() { }\n\t\n\t/** tag to be internally used on faked ways around \"empty terrain\" */\n\tpublic static final Tag EMPTY_SURFACE_TAG =\n\t\t\tnew Tag(\"surface\", \"osm2world:empty_terrain\");\n\n\t/** faked outline node for the terrain areas */\n\tprivate static final OSMNode EMPTY_SURFACE_NODE = new OSMNode(\n\t\t\tDouble.NaN, Double.NaN, EmptyTagGroup.EMPTY_TAG_GROUP, 0);\n\t\n\t/** faked outline way for the terrain areas */\n\tprivate static final OSMWay EMPTY_SURFACE_WAY = new OSMWay(\n\t\t\tnew MapBasedTagGroup(EMPTY_SURFACE_TAG), 0,\n\t\t\tCollections.emptyList());\n\t\n\tpublic static final double POINT_GRID_DIST = 30;\n\tpublic static final int PATCH_SIZE_POINTS = 10;\n\t\n\t/**\n\t * creates a grid of square {@link MapArea}s to represent empty terrain.\n\t * The areas are connected with each other, but do not overlap,\n\t * and cover the entire data bounds.\n\t * \n\t * These areas do not come from OSM data, but they are treated the same\n\t * as mapped areas later on to avoid unnecessary special case handling.\n\t */\n\tstatic void createAreasForEmptyTerrain(List mapNodes,\n\t\t\tList mapAreas, AxisAlignedBoundingBoxXZ dataBounds) {\n\t\t\n\t\tVectorGridXZ posGrid = new VectorGridXZ(\n\t\t\t\tdataBounds.pad(POINT_GRID_DIST), POINT_GRID_DIST);\n\t\t\n\t\t/* create a grid of nodes (leaving points within the future patches blank) */\n\t\t\n\t\tMapNode[][] nodeGrid = new MapNode[posGrid.sizeX()][posGrid.sizeZ()];\n\t\t\n\t\tfor (int x = 0; x < posGrid.sizeX(); x++) {\n\t\t\tfor (int z = 0; z < posGrid.sizeZ(); z++) {\n\t\t\t\t\n\t\t\t\tif (x % PATCH_SIZE_POINTS == 0 || x == posGrid.sizeX() - 1\n\t\t\t\t\t\t|| z % PATCH_SIZE_POINTS == 0 || z == posGrid.sizeZ() - 1) {\n\t\t\t\t\t\n\t\t\t\t\tVectorXZ pos = posGrid.get(x, z);\n\t\t\t\t\t\n\t\t\t\t\tMapNode mapNode = new MapNode(pos, EMPTY_SURFACE_NODE);\n\t\t\t\t\t\n\t\t\t\t\tnodeGrid[x][z] = mapNode;\n\t\t\t\t\tmapNodes.add(mapNode);\n\t\t\t\t\t\n\t\t\t\t}\n\t\t\t\t\n\t\t\t}\n\t\t}\n\t\t\n\t\t/* create a grid of areas based on the nodes */\n\t\t\t\n\t\t// calculate the number of patches, but always round up\n\t\tint numPatchesX = (nodeGrid.length + PATCH_SIZE_POINTS - 2) / PATCH_SIZE_POINTS;\n\t\tint numPatchesZ = (nodeGrid[0].length + PATCH_SIZE_POINTS - 2) / PATCH_SIZE_POINTS;\n\n\t\tfor (int patchX = 0; patchX < numPatchesX; patchX++) {\n\t\t\tfor (int z = 0; z < numPatchesZ; z++) {\n\t\t\t\t\n\t\t\t\tmapAreas.add(createAreaForPatch(nodeGrid,\n\t\t\t\t\t\tpatchX * PATCH_SIZE_POINTS,\n\t\t\t\t\t\tz * PATCH_SIZE_POINTS));\n\t\t\t\t\n\t\t\t}\n\t\t}\n\t\t\n\t}\n\t\n\tprivate static MapArea createAreaForPatch(MapNode[][] nodeGrid,\n\t\t\tint startX, int startZ) {\n\t\t\n\t\tint endX = min(startX + PATCH_SIZE_POINTS + 1, nodeGrid.length);\n\t\tint endZ = min(startZ + PATCH_SIZE_POINTS + 1, nodeGrid[0].length);\n\t\t\n\t\tList nodes = new ArrayList();\n\t\t\n\t\t// first row\n\t\tfor (int x = startX; x < endX; x++) {\n\t\t\tnodes.add(nodeGrid[x][startZ]);\n\t\t}\n\t\t\n\t\t// last column\n\t\tfor (int z = startZ + 1; z < endZ - 1; z++) {\n\t\t\tnodes.add(nodeGrid[endX - 1][z]);\n\t\t}\n\t\t\n\t\t// last row\n\t\tfor (int x = endX - 1; x >= startX; x--) {\n\t\t\tnodes.add(nodeGrid[x][endZ - 1]);\n\t\t}\n\t\t\n\t\t// first column\n\t\tfor (int z = endZ - 2; z >= startZ /* start will be added again */; z--) {\n\t\t\tnodes.add(nodeGrid[startX][z]);\n\t\t}\n\t\t\n\t\treturn new MapArea(EMPTY_SURFACE_WAY, nodes);\n\t\t\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/map_data/creation/LatLon.java",
"content": "package org.osm2world.core.map_data.creation;\n\n/**\n * an immutable coordinate pair with latitude and longitude\n */\npublic class LatLon {\n\t\n\tpublic final double lat;\n\tpublic final double lon;\n\t\n\tpublic LatLon(double lat, double lon) {\n\t\tthis.lat = lat;\n\t\tthis.lon = lon;\n\t}\n\t\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/map_data/creation/MapProjection.java",
"content": "package org.osm2world.core.map_data.creation;\n\nimport org.osm2world.core.math.VectorXZ;\n\n/**\n * function that converts latitude/longitude coordinates\n * to internally used x/z coordinates\n */\npublic interface MapProjection {\n\t\n\tpublic VectorXZ calcPos(double lat, double lon);\n\t\n\tpublic VectorXZ calcPos(LatLon latlon);\n\t\n\t/**\n\t * inverse for {@link #calcPos(double, double)}\n\t */\n\tpublic double calcLat(VectorXZ pos);\n\t\n\t/**\n\t * inverse for {@link #calcPos(double, double)}\n\t */\n\tpublic double calcLon(VectorXZ pos);\n\t\n\t/**\n\t * returns a vector that points one meter to the north\n\t * from the position that becomes the coordinate origin\n\t */\n\tpublic VectorXZ getNorthUnit();\n\n\t/**\n\t * returns the origin (i.e. the latlon that maps to (0,0)\n\t */\n\tpublic LatLon getOrigin();\n\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/map_data/creation/MercatorProjection.java",
"content": "package org.osm2world.core.map_data.creation;\n\nimport static java.lang.Math.PI;\nimport static java.lang.Math.atan;\nimport static java.lang.Math.exp;\nimport static java.lang.Math.log;\nimport static java.lang.Math.pow;\nimport static java.lang.Math.sin;\nimport static java.lang.Math.sqrt;\nimport static java.lang.Math.tan;\nimport static java.lang.Math.toDegrees;\nimport static java.lang.Math.toRadians;\n\nfinal class MercatorProjection {\n\n\tprivate MercatorProjection() {\n\t}\n\n\tprivate static final double R_MAJOR = 6378137.0;\n\tprivate static final double R_MINOR = 6356752.3142;\n\tprivate static final double RATIO = R_MINOR / R_MAJOR;\n\tprivate static final double ECCENT = sqrt(1.0 - (RATIO * RATIO));\n\tprivate static final double COM = 0.5 * ECCENT;\n\tpublic static final double EARTH_CIRCUMFERENCE = 40075016.686;\n\n\t/**\n\t * Calculate earth circumference at given latitude.\n\t */\n\tpublic static double earthCircumference(double latitude) {\n\t\treturn EARTH_CIRCUMFERENCE * Math.cos(toRadians(latitude));\n\t}\n\n\t/**\n\t * Convert longitude to Mercator projection (range [0..1]).\n\t */ \n\tpublic static double lonToX(double longitude) {\n\t\treturn (longitude + 180.0) / 360.0;\n\t}\n\n\t/**\n\t * Convert from Mercator projection (range [0..1]) to longitude.\n\t */\n\tpublic static double xToLon(double x) {\n\t\treturn 360.0 * (x - 0.5);\n\t}\n\n\t/**\n\t * Convert latitude to Mercator projection (range [0..1]).\n\t */ \n\tpublic static double latToY(double latitude) {\n\t\tdouble sinLat = Math.sin(toRadians(latitude));\n\t\treturn Math.log((1.0 + sinLat) / (1.0 - sinLat)) / (4.0 * Math.PI) + 0.5;\n\t}\n\n\t/**\n\t * Convert from Mercator projection (range [0..1]) to latitude.\n\t */\n\tpublic static double yToLat(double y) {\n\t\treturn 360.0 * Math.atan(Math.exp((y - 0.5) * (2.0 * Math.PI))) / Math.PI - 90.0;\n\t}\n\t// This is for the Elliptical Mercator version\n\tpublic static double latToYElliptical(double lat) {\n\t\tlat = Math.min(89.5, Math.max(lat, -89.5));\n\t\tdouble phi = toRadians(lat);\n\t\tdouble sinphi = sin(phi);\n\t\tdouble con = ECCENT * sinphi;\n\t\tcon = pow(((1.0 - con) / (1.0 + con)), COM);\n\t\tdouble ts = tan(0.5 * ((PI * 0.5) - phi)) / con;\n\t\treturn 0 - R_MAJOR * log(ts);\n\t}\n\n\t// This is for the Elliptical Mercator version\n\tpublic static double yToLatElliptical(double y) {\n\t\tdouble ts = exp(-y / R_MAJOR);\n\t\tdouble phi = PI / 2 - 2 * atan(ts);\n\t\tdouble dphi = 1.0;\n\t\tint i = 0;\n\t\twhile ((Math.abs(dphi) > 0.000000001) && (i < 15))\n\t\t{\n\t\t\tdouble con = ECCENT * sin(phi);\n\t\t\tdphi = PI / 2 - 2 * atan(ts * Math.pow((1.0 - con) / (1.0 + con), COM)) - phi;\n\t\t\tphi += dphi;\n\t\t\ti++;\n\t\t}\n\t\treturn toDegrees(phi);\n\t}\n}"
},
{
"path": "OSM2World/src/org/osm2world/core/map_data/creation/MetricMapProjection.java",
"content": "package org.osm2world.core.map_data.creation;\n\nimport static org.osm2world.core.map_data.creation.MercatorProjection.*;\n\nimport org.osm2world.core.math.VectorXZ;\n\n/**\n * Map projection that is intended to use the \"dense\" space\n * of floating point values by making all coordinates relative to\n * the origin. 1 meter distance is roughly represented by 1 internal unit.\n */\npublic class MetricMapProjection extends OriginMapProjection {\n\t\n\tprivate double originX;\n\tprivate double originY;\n\tprivate double scaleFactor;\n\t\t\n\tpublic VectorXZ calcPos(double lat, double lon) {\n\t\tdouble x = lonToX(lon) * scaleFactor - originX;\n\t\tdouble y = latToY(lat) * scaleFactor - originY;\n\n\t\t/* snap to som cm precision, seems to reduce geometry exceptions */\n\t\tx = Math.round(x * 1000) / 1000.0d;\n\t\ty = Math.round(y * 1000) / 1000.0d;\n\n\t\treturn new VectorXZ(x, y); // x and z(!) are 2d here\n\t}\n\n\t@Override\n\tpublic VectorXZ calcPos(LatLon latlon) {\n\t\treturn calcPos(latlon.lat, latlon.lon);\n\t}\n\n\t@Override\n\tpublic double calcLat(VectorXZ pos) {\n\t\treturn yToLat((pos.z + originY) / scaleFactor);\n\t}\n\n\t@Override\n\tpublic double calcLon(VectorXZ pos) {\n\t\treturn xToLon((pos.x + originX) / scaleFactor);\n\t}\n\n\t@Override\n\tpublic VectorXZ getNorthUnit() {\n\t\treturn VectorXZ.Z_UNIT;\n\t}\n\n\t@Override\n\tpublic void setOrigin(LatLon origin) {\n\t\tsuper.setOrigin(origin);\n\n\t\tthis.scaleFactor = earthCircumference(origin.lat);\n\t\tthis.originY = latToY(origin.lat) * scaleFactor;\n\t\tthis.originX = lonToX(origin.lon) * scaleFactor;\n\t}\n}\n"
},
{
"path": "OSM2World/src/org/osm2world/core/map_data/creation/MultipolygonAreaBuilder.java",
"content": "package org.osm2world.core.map_data.creation;\n\nimport static java.lang.Boolean.*;\nimport static java.lang.Double.NaN;\nimport static java.lang.Math.*;\nimport static java.util.Arrays.asList;\nimport static java.util.Collections.*;\nimport static org.osm2world.core.math.GeometryUtil.*;\n\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.Collections;\nimport java.util.Comparator;\nimport java.util.List;\nimport java.util.Map;\n\nimport org.openstreetmap.josm.plugins.graphview.core.data.MapBasedTagGroup;\nimport org.openstreetmap.josm.plugins.graphview.core.data.Tag;\nimport org.openstreetmap.josm.plugins.graphview.core.data.TagGroup;\nimport org.osm2world.core.map_data.data.MapArea;\nimport org.osm2world.core.map_data.data.MapNode;\nimport org.osm2world.core.math.AxisAlignedBoundingBoxXZ;\nimport org.osm2world.core.math.InvalidGeometryException;\nimport org.osm2world.core.math.LineSegmentXZ;\nimport org.osm2world.core.math.PolygonWithHolesXZ;\nimport org.osm2world.core.math.SimplePolygonXZ;\nimport org.osm2world.core.math.VectorXZ;\nimport org.osm2world.core.math.datastructures.IntersectionTestObject;\nimport org.osm2world.core.osm.data.OSMData;\nimport org.osm2world.core.osm.data.OSMElement;\nimport org.osm2world.core.osm.data.OSMMember;\nimport org.osm2world.core.osm.data.OSMNode;\nimport org.osm2world.core.osm.data.OSMRelation;\nimport org.osm2world.core.osm.data.OSMWay;\nimport org.osm2world.core.osm.ruleset.HardcodedRuleset;\nimport org.osm2world.core.osm.ruleset.Ruleset;\n\n/**\n * utility class for creating areas from multipolygon relations,\n * including those with non-closed member ways.\n * \n * Known Limitations:\n * - This cannot reliably handle touching inner rings consisting\n * of non-closed ways.
\n * - Closed touching rings will not break the calculation,\n * but are represented as multiple touching holes.
\n *
\n */\nfinal class MultipolygonAreaBuilder {\n\t\n\t/** prevents instantiation */\n\tprivate MultipolygonAreaBuilder() { }\n\t\n\t/**\n\t * Creates areas for a multipolygon relation.\n\t * Also adds this area to the adjacent nodes using\n\t * {@link MapNode#addAdjacentArea(MapArea)}.\n\t * \n\t * @param relation the multipolygon relation\n\t * @param nodeMap map from {@link OSMNode}s to {@link MapNode}s\n\t * \n\t * @return constructed area(s), multiple areas will be created if there\n\t * is more than one outer ring. Empty for invalid multipolygons.\n\t */\n\tpublic static final Collection createAreasForMultipolygon(\n\t\t\tOSMRelation relation, Map nodeMap) {\n\t\t\n\t\tif (isSimpleMultipolygon(relation)) {\n\t\t\treturn createAreasForSimpleMultipolygon(relation, nodeMap);\n\t\t} else {\n\t\t\treturn createAreasForAdvancedMultipolygon(relation, nodeMap);\n\t\t}\n\t\t\n\t}\n\n\tprivate static final boolean isSimpleMultipolygon(OSMRelation relation) {\n\t\t\n\t\tint numberOuters = 0;\n\t\tboolean closedWays = true;\n\t\t\n\t\tfor (OSMMember member : relation.relationMembers) {\n\t\t\t\n\t\t\tif (\"outer\".equals(member.role)\n\t\t\t\t\t&& member.member instanceof OSMWay) {\n\t\t\t\tnumberOuters += 1;\n\t\t\t}\n\t\t\t\n\t\t\tif ((\"outer\".equals(member.role) || \"inner\".equals(member.role))\n\t\t\t\t\t&& member.member instanceof OSMWay) {\n\t\t\t\t\n\t\t\t\tif (!((OSMWay)member.member).isClosed()) {\n\t\t\t\t\tclosedWays = false;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t}\n\t\t\t\n\t\t}\n\t\t\n\t\treturn numberOuters == 1 && closedWays;\n\t\t\n\t}\n\n\t/**\n\t * handles the common simple case with only one outer way.\n\t * Expected to be faster than the more general method\n\t * {@link #createAreasForAdvancedMultipolygon(OSMRelation, Map)}\n\t * \n\t * @param relation has to be a simple multipolygon relation\n\t * @param nodeMap\n\t */\n\tprivate static final Collection createAreasForSimpleMultipolygon(\n\t\t\tOSMRelation relation, Map nodeMap) {\n\t\t\n\t\tassert isSimpleMultipolygon(relation);\n\t\t\n\t\tOSMElement tagSource = null;\n\t\tList outerNodes = null;\n\t\tList> holes = new ArrayList>();\n\t\t\n\t\tfor (OSMMember member : relation.relationMembers) {\n\t\t\tif (member.member instanceof OSMWay) {\n\t\t\t\t\n\t\t\t\tOSMWay way = (OSMWay)member.member;\n\t\t\t\t\n\t\t\t\tif (\"inner\".equals(member.role)) {\n\t\t\t\t\t\n\t\t\t\t\tList hole = new ArrayList(way.nodes.size());\n\t\t\t\t\t\n\t\t\t\t\tfor (OSMNode node : ((OSMWay)member.member).nodes) {\n\t\t\t\t\t\thole.add(nodeMap.get(node));\n\t\t\t\t\t\t//TODO: add area as adjacent to node for inners' nodes, too?\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tholes.add(hole);\n\t\t\t\t\t\n\t\t\t\t} else if (\"outer\".equals(member.role)) {\n\t\t\t\t\t\n\t\t\t\t\ttagSource = relation.tags.size() > 1 ? relation : way;\n\t\t\t\t\t\n\t\t\t\t\touterNodes = new ArrayList(way.nodes.size());\n\t\t\t\t\tfor (OSMNode node : way.nodes) {\n\t\t\t\t\t\touterNodes.add(nodeMap.get(node));\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t}\n\t\t\t\t\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn singleton(new MapArea(tagSource, outerNodes, holes));\n\t\t\n\t}\n\n\tprivate static final Collection createAreasForAdvancedMultipolygon(\n\t\t\tOSMRelation relation, Map nodeMap) {\n\t\t\n\t\tList innersAndOuters = new ArrayList();\n\t\t\n\t\t/* collect ways */\n\t\t\n\t\tfor (OSMMember member : relation.relationMembers) {\n\t\t\tif (member.member instanceof OSMWay\n\t\t\t\t\t&& (\"outer\".equals(member.role)\n\t\t\t\t\t\t\t|| \"inner\".equals(member.role)) ) {\n\t\t\t\t\n\t\t\t\tinnersAndOuters.add(new NodeSequence(\n\t\t\t\t\t\t(OSMWay)member.member, nodeMap));\n\t\t\t\t\n\t\t\t}\n\t\t}\n\t\t\n\t\t/* build rings, then polygons from the ways */\n\t\t\n\t\tList rings = buildRings(innersAndOuters);\n\t\t\n\t\tif (rings != null) {\n\t\t\t\t\t\t\n\t\t\treturn buildPolygonsFromRings(relation, rings);\n\t\t\t\n\t\t} else {\n\t\t\n\t\t\treturn Collections.emptyList();\n\t\t\t\n\t\t}\n\t\t\n\t}\n\n\t/**\n\t * builds closed rings from any mixture of closed and unclosed segments\n\t * \n\t * @return null if building closed rings isn't possible\n\t */\n\tprivate static final List buildRings(\n\t\t\tList sequences) {\n\t\t\n\t\tList closedRings = new ArrayList();\n\t\t\n\t\tNodeSequence currentRing = null;\n\t\t\n\t\twhile (sequences.size() > 0) {\n\t\t\t\n\t\t\tif (currentRing == null) {\n\t\t\t\t\n\t\t\t\t// start a new ring with any remaining node sequence\n\t\t\t\t\n\t\t\t\tcurrentRing = sequences.remove(sequences.size() - 1);\n\t\t\t\t\n\t\t\t} else {\n\t\t\t\t\n\t\t\t\t// try to continue the ring by appending a node sequence\n\t\t\t\t\n\t\t\t\tNodeSequence assignedSequence = null;\n\t\t\t\t\n\t\t\t\tfor (NodeSequence sequence : sequences) {\n\t\t\t\t\n\t\t\t\t\tif (currentRing.tryAdd(sequence)) {\n\t\t\t\t\t\tassignedSequence = sequence;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (assignedSequence != null) {\n\t\t\t\t\tsequences.remove(assignedSequence);\n\t\t\t\t} else {\n\t\t\t\t\treturn null;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t}\n\t\t\t\n\t\t\t// check whether the ring under construction is closed\n\t\t\t\n\t\t\tif (currentRing != null && currentRing.isClosed()) {\n\t\t\t\ttry {\n\t\t\t\t\tclosedRings.add(new Ring(currentRing));\n\t\t\t\t\tcurrentRing = null;\n\t\t\t\t} catch (InvalidGeometryException e) {\n\t\t\t\t\tthrow new InvalidGeometryException(String.format(\n\t\t\t\t\t\t\t\"self-intersecting ring (with %d nodes)\",\n\t\t\t\t\t\t\tcurrentRing.size() - 1), e);\n\t\t\t\t}\n\t\t\t}\n\t\t\n\t\t}\n\t\t\n\t\tif (currentRing != null) {\n\t\t\t// the last ring could not be closed\n\t\t\treturn null;\n\t\t}\n\t\t\n\t\treturn closedRings;\n\t\t\n\t}\n\n\t/**\n\t * @param rings rings to build polygons from; will be empty afterwards\n\t */\n\tprivate static final Collection buildPolygonsFromRings(\n\t\t\tOSMRelation relation, List rings) {\n\t\t\n\t\tCollection finishedPolygons =\n\t\t\t\tnew ArrayList(rings.size() / 2);\n\t\t\n\t\t/* build polygon */\n\t\t\n\t\twhile (!rings.isEmpty()) {\n\t\t\t\n\t\t\t/* find an outer ring */\n\t\t\t\n\t\t\tRing outerRing = null;\n\t\t\t\n\t\t\tfor (Ring candidate : rings) {\n\t\t\t\t\n\t\t\t\tboolean containedInOtherRings = false;\n\t\t\t\t\n\t\t\t\tfor (Ring otherRing : rings) {\n\t\t\t\t\tif (otherRing != candidate\n\t\t\t\t\t\t\t&& otherRing.containsRing(candidate)) {\n\t\t\t\t\t\tcontainedInOtherRings = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (!containedInOtherRings) {\n\t\t\t\t\touterRing = candidate;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t}\n\t\t\t\n\t\t\t/* find inner rings of that ring */\n\t\t\t\n\t\t\tCollection innerRings = new ArrayList();\n\t\t\t\n\t\t\tfor (Ring ring : rings) {\n\t\t\t\tif (ring != outerRing && outerRing.containsRing(ring)) {\n\t\t\t\t\t\n\t\t\t\t\tboolean containedInOtherRings = false;\n\t\t\t\t\t\n\t\t\t\t\tfor (Ring otherRing : rings) {\n\t\t\t\t\t\tif (otherRing != ring && otherRing != outerRing\n\t\t\t\t\t\t\t\t&& otherRing.containsRing(ring)) {\n\t\t\t\t\t\t\tcontainedInOtherRings = true;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tif (!containedInOtherRings) {\n\t\t\t\t\t\tinnerRings.add(ring);\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\t/* create a new area and remove the used rings */\n\t\t\t\n\t\t\tList> holes = new ArrayList>(innerRings.size());\n\t\t\tList holesXZ = new ArrayList(innerRings.size());\n\t\t\t\n\t\t\tfor (Ring innerRing : innerRings) {\n\t\t\t\tholes.add(innerRing.closedNodeSequence);\n\t\t\t\tholesXZ.add(innerRing.getPolygon());\n\t\t\t}\n\t\t\t\n\t\t\tMapArea area = new MapArea(relation, outerRing.getNodeLoop(), holes,\n\t\t\t\t\tnew PolygonWithHolesXZ(outerRing.getPolygon(), holesXZ));\n\t\t\t\n\t\t\tfinishedPolygons.add(area);\n\t\t\t\n\t\t\trings.remove(outerRing);\n\t\t\trings.removeAll(innerRings);\n\t\t\t\n\t\t}\n\t\t\n\t\treturn finishedPolygons;\n\t\t\n\t}\n\t\n\tprivate static final TagGroup COASTLINE_NODE_TAGS = new MapBasedTagGroup(\n\t\t\tnew Tag(\"osm2world:note\", \"fake node from coastline processing\"));\n\t\n\t/**\n\t * turns all coastline ways into {@link MapArea}s\n\t * based on an artificial natural=water multipolygon relation.\n\t * \n\t * It relies on the direction-dependent drawing of coastlines.\n\t * If coastlines are incomplete, then it is attempted to connect them\n\t * to proper rings. One assumption being used is that they are complete\n\t * within the file's bounds.\n\t * \n\t * It cannot distinguish between water and land tiles if there is no\n\t * coastline at all (it will then guess based on the tags being used),\n\t * but should be able to handle all other cases.\n\t */\n\tpublic static final Collection createAreasForCoastlines(\n\t\t\tOSMData osmData, Map nodeMap,\n\t\t\tCollection