daniel/pylib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add geometry functions to translate and rotate lists and define lines and cubic lines

Browse Source 
add data function to fold a list and geometry_plot functions to plot lines and tests for the geometry functions
This commit is contained in:
Daniel Weschke
2019-08-28 11:39:50 +02:00
parent 5b6d8b77ae
commit f47fa19cd2
35 changed files with 12169 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
docs/build/html/_modules/data.html vendored
View File

@@ -138,9 +138,26 @@
<span class="c1"># every dump needs a load</span>
<span class="n">pickle</span><span class="o">.</span><span class="n">dump</span><span class="p">(</span><span class="n">object_data</span><span class="p">,</span> <span class="n">output</span><span class="p">,</span> <span class="n">pickle</span><span class="o">.</span><span class="n">HIGHEST_PROTOCOL</span><span class="p">)</span></div>
<div class="viewcode-block" id="fold_list"><a class="viewcode-back" href="../data.html#data.fold_list">[docs]</a><span class="k">def</span> <span class="nf">fold_list</span><span class="p">(</span><span class="n">lst</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Convert one-dimensional kx1 array (list) to two-dimensional mxn</span>
<span class="sd"> array. m = k / n</span>
<span class="sd"> :param lst: list to convert</span>
<span class="sd"> :type lst: list</span>
<span class="sd"> :param n: length of the second dimenson</span>
<span class="sd"> :type n: int</span>
<span class="sd"> :returns: two-dimensional array (list of lists)</span>
<span class="sd"> :rtype: list</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">k</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">lst</span><span class="p">)</span>
<span class="k">if</span> <span class="n">k</span> <span class="o">%</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="n">length</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">k</span><span class="o">/</span><span class="n">n</span><span class="p">)</span>
<span class="k">return</span> <span class="p">[</span><span class="n">lst</span><span class="p">[</span><span class="n">i</span><span class="o">*</span><span class="n">n</span><span class="p">:</span><span class="n">i</span><span class="o">*</span><span class="n">n</span><span class="o">+</span><span class="n">n</span><span class="p">]</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">length</span><span class="p">)]</span></div>
<div class="viewcode-block" id="unique_ending"><a class="viewcode-back" href="../data.html#data.unique_ending">[docs]</a><span class="k">def</span> <span class="nf">unique_ending</span><span class="p">(</span><span class="n">ids</span><span class="p">,</span> <span class="n">n</span><span class="o">=</span><span class="mi">1</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;From id list get list with unique ending.</span>
<span class="sd"> </span>
<span class="sd"> :param ids: ids</span>
<span class="sd"> :type ids: list</span>
<span class="sd"> :param n: minumum chars or ints</span>
@@ -158,7 +175,7 @@
<div class="viewcode-block" id="get_id"><a class="viewcode-back" href="../data.html#data.get_id">[docs]</a><span class="k">def</span> <span class="nf">get_id</span><span class="p">(</span><span class="n">ids</span><span class="p">,</span> <span class="n">uide</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Get full id from unique id ending.</span>
<span class="sd"> </span>
<span class="sd"> :param ids: ids</span>
<span class="sd"> :type ids: list</span>
<span class="sd"> :param uide: unique id ending</span>
@@ -223,7 +240,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

2
docs/build/html/_modules/date.html vendored
View File

@@ -210,7 +210,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

334
docs/build/html/_modules/geometry.html vendored
View File

@@ -37,12 +37,12 @@
<span class="c1"># -*- coding: utf-8 -*-</span>
<span class="sd">&quot;&quot;&quot;2D geometry objects.</span>
<span class="sd">:Date: 2019-03-21</span>
<span class="sd">:Date: 2019-08-20</span>
<span class="sd">.. module:: geometry</span>
<span class="sd"> :platform: *nix, Windows</span>
<span class="sd"> :synopsis: Geometry objects.</span>
<span class="sd"> </span>
<span class="sd">.. moduleauthor:: Daniel Weschke &lt;daniel.weschke@directbox.de&gt;</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="kn">import</span> <span class="nn">math</span>
@@ -58,14 +58,51 @@
<span class="sd"> :returns: (point_x, point_y) or (point1, point2, ...)</span>
<span class="sd"> :rtype: tuple</span>
<span class="sd"> .. seealso::</span>
<span class="sd"> :meth:`translate_xy`</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">vx</span><span class="p">,</span> <span class="n">vy</span> <span class="o">=</span> <span class="n">vec</span>
<span class="k">return</span> <span class="nb">tuple</span><span class="p">([(</span><span class="n">x</span><span class="o">+</span><span class="n">vx</span><span class="p">,</span> <span class="n">y</span><span class="o">+</span><span class="n">vy</span><span class="p">)</span> <span class="k">for</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span> <span class="ow">in</span> <span class="n">pts</span><span class="p">])</span></div>
<div class="viewcode-block" id="translate_xy"><a class="viewcode-back" href="../geometry.html#geometry.translate_xy">[docs]</a><span class="k">def</span> <span class="nf">translate_xy</span><span class="p">(</span><span class="n">vec</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Translate a point or polygon by a given vector.</span>
<span class="sd"> :param vec: translation vector</span>
<span class="sd"> :type vec: tuple</span>
<span class="sd"> :param x: points to translate</span>
<span class="sd"> :type x: int or float or list</span>
<span class="sd"> :param y: points to translate</span>
<span class="sd"> :type y: int or float or list</span>
<span class="sd"> :returns: (x&#39;, y&#39;)</span>
<span class="sd"> :rtype: tuple</span>
<span class="sd"> .. seealso::</span>
<span class="sd"> :meth:`translate`</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">vx</span><span class="p">,</span> <span class="n">vy</span> <span class="o">=</span> <span class="n">vec</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="s2">&quot;__len__&quot;</span><span class="p">):</span>
<span class="n">x</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span><span class="p">]</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="s2">&quot;__len__&quot;</span><span class="p">):</span>
<span class="n">y</span> <span class="o">=</span> <span class="p">[</span><span class="n">y</span><span class="p">]</span>
<span class="n">xp</span> <span class="o">=</span> <span class="p">[</span><span class="n">xi</span><span class="o">+</span><span class="n">vx</span> <span class="k">for</span> <span class="n">xi</span> <span class="ow">in</span> <span class="n">x</span><span class="p">]</span>
<span class="n">yp</span> <span class="o">=</span> <span class="p">[</span><span class="n">yi</span><span class="o">+</span><span class="n">vy</span> <span class="k">for</span> <span class="n">yi</span> <span class="ow">in</span> <span class="n">y</span><span class="p">]</span>
<span class="c1"># no list if it is only one value</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">xp</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">return</span> <span class="n">xp</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">yp</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="k">return</span> <span class="n">xp</span><span class="p">,</span> <span class="n">yp</span></div>
<div class="viewcode-block" id="rotate"><a class="viewcode-back" href="../geometry.html#geometry.rotate">[docs]</a><span class="k">def</span> <span class="nf">rotate</span><span class="p">(</span><span class="n">origin</span><span class="p">,</span> <span class="n">angle</span><span class="p">,</span> <span class="o">*</span><span class="n">pts</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Rotate a point or polygon counterclockwise by a given angle around a given</span>
<span class="sd"> origin. The angle should be given in radians.</span>
<span class="sd">&quot;&quot;&quot;Rotate a point or polygon counterclockwise by a given angle</span>
<span class="sd"> around a given origin. The angle should be given in radians.</span>
<span class="sd"> :param origin: the center of rotation</span>
<span class="sd"> :type origin: tuple</span>
@@ -76,17 +113,21 @@
<span class="sd"> :returns: (point_x, point_y) or (point1, point2, ...)</span>
<span class="sd"> :rtype: tuple</span>
<span class="sd"> .. seealso::</span>
<span class="sd"> :meth:`rotate_xy`</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">ox</span><span class="p">,</span> <span class="n">oy</span> <span class="o">=</span> <span class="n">origin</span>
<span class="c1"># add first point to the end</span>
<span class="k">if</span> <span class="n">kwargs</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">and</span> <span class="s2">&quot;closed&quot;</span> <span class="ow">in</span> <span class="n">kwargs</span> <span class="ow">and</span> <span class="n">kwargs</span><span class="p">[</span><span class="s2">&quot;closed&quot;</span><span class="p">]</span> <span class="ow">is</span> <span class="kc">True</span><span class="p">:</span>
<span class="k">if</span> <span class="s2">&quot;closed&quot;</span> <span class="ow">in</span> <span class="n">kwargs</span> <span class="ow">and</span> <span class="n">kwargs</span><span class="p">[</span><span class="s2">&quot;closed&quot;</span><span class="p">]</span> <span class="ow">is</span> <span class="kc">True</span><span class="p">:</span>
<span class="n">pts</span> <span class="o">+=</span> <span class="p">(</span><span class="n">pts</span><span class="p">[</span><span class="mi">0</span><span class="p">],)</span>
<span class="n">result</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">([(</span><span class="n">ox</span> <span class="o">+</span> <span class="n">math</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">angle</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">px</span> <span class="o">-</span> <span class="n">ox</span><span class="p">)</span> <span class="o">-</span> <span class="n">math</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">angle</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">py</span> <span class="o">-</span> <span class="n">oy</span><span class="p">),</span>
<span class="n">oy</span> <span class="o">+</span> <span class="n">math</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">angle</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">px</span> <span class="o">-</span> <span class="n">ox</span><span class="p">)</span> <span class="o">+</span> <span class="n">math</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">angle</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">py</span> <span class="o">-</span> <span class="n">oy</span><span class="p">))</span>
<span class="k">for</span> <span class="p">(</span><span class="n">px</span><span class="p">,</span> <span class="n">py</span><span class="p">)</span> <span class="ow">in</span> <span class="n">pts</span><span class="p">])</span>
<span class="c1"># no tuple in tuple if it is only one point</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">pts</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">return</span> <span class="n">result</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">],</span> <span class="n">result</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">]</span>
@@ -94,8 +135,8 @@
<div class="viewcode-block" id="rotate_deg"><a class="viewcode-back" href="../geometry.html#geometry.rotate_deg">[docs]</a><span class="k">def</span> <span class="nf">rotate_deg</span><span class="p">(</span><span class="n">origin</span><span class="p">,</span> <span class="n">angle</span><span class="p">,</span> <span class="o">*</span><span class="n">pts</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Rotate a point or polygon counterclockwise by a given angle around a given</span>
<span class="sd"> origin. The angle should be given in degrees.</span>
<span class="sd">&quot;&quot;&quot;Rotate a point or polygon counterclockwise by a given angle</span>
<span class="sd"> around a given origin. The angle should be given in degrees.</span>
<span class="sd"> :param origin: the center of rotation</span>
<span class="sd"> :type origin: tuple</span>
@@ -113,13 +154,56 @@
<span class="k">return</span> <span class="n">rotate</span><span class="p">(</span><span class="n">origin</span><span class="p">,</span> <span class="n">angle</span><span class="o">*</span><span class="n">math</span><span class="o">.</span><span class="n">pi</span><span class="o">/</span><span class="mi">180</span><span class="p">,</span> <span class="o">*</span><span class="n">pts</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span></div>
<div class="viewcode-block" id="rotate_xy"><a class="viewcode-back" href="../geometry.html#geometry.rotate_xy">[docs]</a><span class="k">def</span> <span class="nf">rotate_xy</span><span class="p">(</span><span class="n">origin</span><span class="p">,</span> <span class="n">angle</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Rotate x and y coordinates counterclockwise by a given angle</span>
<span class="sd"> around a given origin. The angle should be given in radians.</span>
<span class="sd"> :param origin: the center of rotation</span>
<span class="sd"> :type origin: tuple</span>
<span class="sd"> :param angle: the rotation angle</span>
<span class="sd"> :type angle: int or float</span>
<span class="sd"> :param x: x coordinates</span>
<span class="sd"> :type x: int or float or list</span>
<span class="sd"> :param y: y coordinates</span>
<span class="sd"> :type y: int or float or list</span>
<span class="sd"> :param `**kwargs`: options</span>
<span class="sd"> .. seealso::</span>
<span class="sd"> :meth:`rotate`</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">ox</span><span class="p">,</span> <span class="n">oy</span> <span class="o">=</span> <span class="n">origin</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="s2">&quot;__len__&quot;</span><span class="p">):</span>
<span class="n">x</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span><span class="p">]</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="s2">&quot;__len__&quot;</span><span class="p">):</span>
<span class="n">y</span> <span class="o">=</span> <span class="p">[</span><span class="n">y</span><span class="p">]</span>
<span class="c1"># add first point to the end</span>
<span class="k">if</span> <span class="s2">&quot;closed&quot;</span> <span class="ow">in</span> <span class="n">kwargs</span> <span class="ow">and</span> <span class="n">kwargs</span><span class="p">[</span><span class="s2">&quot;closed&quot;</span><span class="p">]</span> <span class="ow">is</span> <span class="kc">True</span><span class="p">:</span>
<span class="n">x</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="n">y</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">y</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="n">x_result</span> <span class="o">=</span> <span class="p">[</span><span class="n">ox</span> <span class="o">+</span> <span class="n">math</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">angle</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">xi</span> <span class="o">-</span> <span class="n">ox</span><span class="p">)</span> <span class="o">-</span> <span class="n">math</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">angle</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">yi</span> <span class="o">-</span> <span class="n">oy</span><span class="p">)</span>
<span class="k">for</span> <span class="n">xi</span><span class="p">,</span> <span class="n">yi</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)]</span>
<span class="n">y_result</span> <span class="o">=</span> <span class="p">[</span><span class="n">oy</span> <span class="o">+</span> <span class="n">math</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">angle</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">xi</span> <span class="o">-</span> <span class="n">ox</span><span class="p">)</span> <span class="o">+</span> <span class="n">math</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">angle</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="n">yi</span> <span class="o">-</span> <span class="n">oy</span><span class="p">)</span>
<span class="k">for</span> <span class="n">xi</span><span class="p">,</span> <span class="n">yi</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)]</span>
<span class="c1"># no list if it is only one value</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">x_result</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">return</span> <span class="n">x_result</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">y_result</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="k">return</span> <span class="n">x_result</span><span class="p">,</span> <span class="n">y_result</span></div>
<div class="viewcode-block" id="rectangle"><a class="viewcode-back" href="../geometry.html#geometry.rectangle">[docs]</a><span class="k">def</span> <span class="nf">rectangle</span><span class="p">(</span><span class="n">width</span><span class="p">,</span> <span class="n">height</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;\</span>
<span class="sd"> :param width: the width of the rectangle</span>
<span class="sd"> :type width: int or float</span>
<span class="sd"> :param height: the height of the rectangle</span>
<span class="sd"> :type height: int or float</span>
<span class="sd"> </span>
<span class="sd"> :returns: (point1, point2, point3, point4)</span>
<span class="sd"> :rtype: tuple</span>
<span class="sd"> &quot;&quot;&quot;</span>
@@ -134,7 +218,7 @@
<span class="sd">&quot;&quot;&quot;\</span>
<span class="sd"> :param width: the edge size of the square</span>
<span class="sd"> :type width: int or float</span>
<span class="sd"> </span>
<span class="sd"> :returns: (point1, point2, point3, point4)</span>
<span class="sd"> :rtype: tuple</span>
@@ -144,36 +228,222 @@
<span class="k">return</span> <span class="n">rectangle</span><span class="p">(</span><span class="n">width</span><span class="p">,</span> <span class="n">width</span><span class="p">)</span></div>
<div class="viewcode-block" id="lines"><a class="viewcode-back" href="../geometry.html#geometry.lines">[docs]</a><span class="k">def</span> <span class="nf">lines</span><span class="p">(</span><span class="n">pts</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Lines defined by a list of end points.</span>
<span class="sd"> :param pts: list of points in absolute global coordinate system. If</span>
<span class="sd"> keyword inc is given than the inc decides what the left and the</span>
<span class="sd"> right end point of the line is, otherwise it is assumed that the</span>
<span class="sd"> points build a solid line, that is lines between the given points</span>
<span class="sd"> in given order.</span>
<span class="sd"> :type pts: list</span>
<span class="sd"> :param `**kwargs`: options:</span>
<span class="sd"> * deformation -- list of points. Additional deformation</span>
<span class="sd"> (translation) at point.</span>
<span class="sd"> * factor -- factor of the deformation (default = 1).</span>
<span class="sd"> * inc -- the incidence table, a list of 2 element lists. The inc</span>
<span class="sd"> decides what the left and the right end point of the line is.</span>
<span class="sd"> * index_offset -- starting index of lists (default = 0).</span>
<span class="sd"> :returns: list of endpoints for each line;</span>
<span class="sd"> [((point1_x, point1_y), (point2_x, point2_y)),</span>
<span class="sd"> (p1, p2),</span>
<span class="sd"> ...]</span>
<span class="sd"> :rtype: list</span>
<span class="sd"> .. seealso::</span>
<span class="sd"> :meth:`~geometry_plot.plot_lines` of the :mod:`geometry_plot`</span>
<span class="sd"> module to plot the lines</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="s1">&#39;index_offset&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">if</span> <span class="s1">&#39;deformation&#39;</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="k">if</span> <span class="s1">&#39;factor&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">pts</span> <span class="o">=</span> <span class="p">[(</span><span class="n">p</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">+</span><span class="n">d</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">],</span> <span class="n">p</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">+</span><span class="n">d</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">])</span> <span class="k">for</span>
<span class="n">p</span><span class="p">,</span> <span class="n">d</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">pts</span><span class="p">,</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;deformation&#39;</span><span class="p">])]</span>
<span class="k">if</span> <span class="s1">&#39;inc&#39;</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="k">return</span> <span class="p">[(</span><span class="n">pts</span><span class="p">[</span><span class="n">l</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">]],</span>
<span class="n">pts</span><span class="p">[</span><span class="n">r</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">]])</span> <span class="k">for</span> <span class="n">l</span><span class="p">,</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;inc&#39;</span><span class="p">]]</span>
<span class="k">return</span> <span class="nb">list</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="n">pts</span><span class="p">[:</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span> <span class="n">pts</span><span class="p">[</span><span class="mi">1</span><span class="p">:]))</span></div>
<div class="viewcode-block" id="cubics"><a class="viewcode-back" href="../geometry.html#geometry.cubics">[docs]</a><span class="k">def</span> <span class="nf">cubics</span><span class="p">(</span><span class="n">pts</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Cubic lines defined by a list of two end points. The deformation</span>
<span class="sd"> as displacement and rotation (radians) is defined element wise as</span>
<span class="sd"> keyword argument deformation or global node wise as</span>
<span class="sd"> global_deformation. The global coordinate system is xy. x in the</span>
<span class="sd"> right direction and y in the top direction.</span>
<span class="sd"> :param pts: list of points in absolute global coordinate system. If</span>
<span class="sd"> keyword inc is given than the inc decides what the left and the</span>
<span class="sd"> right end point of the line is, otherwise it is assumed that the</span>
<span class="sd"> points build a solid line, that is lines between the given points</span>
<span class="sd"> in given order.</span>
<span class="sd"> :type pts_rot: list</span>
<span class="sd"> :param `**kwargs`: options:</span>
<span class="sd"> * deformation -- list of deformation element wise. Additional</span>
<span class="sd"> deformation (translation and rotation in radians) at element</span>
<span class="sd"> left and right node.</span>
<span class="sd"> * rotation_plane -- rotation plane of the element wise</span>
<span class="sd"> deformation defined by a string; either &#39;xy&#39; or &#39;xz&#39; (default</span>
<span class="sd"> = &#39;xy&#39;). x in the right direction and y in the top direction</span>
<span class="sd"> or z in the bottom direction.</span>
<span class="sd"> * global_deformation -- list of deformation global node wise.</span>
<span class="sd"> Additional deformation (horizontal translation, vertical</span>
<span class="sd"> translation and rotation in radians) at node.</span>
<span class="sd"> * factor -- factor of the derformation (default = 1).</span>
<span class="sd"> * inc -- the incidence table, a list of 2 element lists. The inc</span>
<span class="sd"> decides what the left and the right end point of the line is.</span>
<span class="sd"> * index_offset -- starting index of lists (default = 0).</span>
<span class="sd"> :returns: list of endpoints for each line;</span>
<span class="sd"> [(((point1_x, point1_y) angle1), ((point2_x, point2_y), angle2),</span>
<span class="sd"> (p1, angle1, p2, angle2),</span>
<span class="sd"> ...]</span>
<span class="sd"> :rtype: list</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="s1">&#39;index_offset&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">if</span> <span class="s1">&#39;deformation&#39;</span> <span class="ow">in</span> <span class="n">kwargs</span> <span class="ow">or</span> <span class="s1">&#39;global_deformation&#39;</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="k">if</span> <span class="s1">&#39;factor&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">if</span> <span class="s1">&#39;inc&#39;</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="k">if</span> <span class="s1">&#39;global_deformation&#39;</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="n">lr</span> <span class="o">=</span> <span class="p">[(</span><span class="n">pts</span><span class="p">[</span><span class="n">l</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">]],</span>
<span class="n">pts</span><span class="p">[</span><span class="n">r</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">]])</span> <span class="k">for</span> <span class="n">l</span><span class="p">,</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;inc&#39;</span><span class="p">]]</span>
<span class="n">ang</span> <span class="o">=</span> <span class="p">[</span><span class="n">math</span><span class="o">.</span><span class="n">atan2</span><span class="p">(</span><span class="n">r</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">l</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">r</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">-</span><span class="n">l</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="k">for</span> <span class="n">l</span><span class="p">,</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">lr</span><span class="p">]</span>
<span class="c1"># system deformation</span>
<span class="n">U</span> <span class="o">=</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;global_deformation&#39;</span><span class="p">]</span>
<span class="k">if</span> <span class="s1">&#39;rotation_plane&#39;</span> <span class="ow">in</span> <span class="n">kwargs</span> <span class="ow">and</span> <span class="s1">&#39;xz&#39;</span> <span class="o">==</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;rotation_plane&#39;</span><span class="p">]:</span>
<span class="c1"># system deformation left X Z RY right X Z RY element wise</span>
<span class="c1"># Z downwards -&gt; convert to X Y RZ</span>
<span class="n">Ue</span> <span class="o">=</span> <span class="p">[[</span> <span class="n">U</span><span class="p">[(</span><span class="n">l</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">0</span><span class="p">],</span>
<span class="o">-</span><span class="n">U</span><span class="p">[(</span><span class="n">l</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">1</span><span class="p">],</span>
<span class="n">U</span><span class="p">[(</span><span class="n">l</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">2</span><span class="p">],</span>
<span class="n">U</span><span class="p">[(</span><span class="n">r</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">0</span><span class="p">],</span>
<span class="o">-</span><span class="n">U</span><span class="p">[(</span><span class="n">r</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">1</span><span class="p">],</span>
<span class="n">U</span><span class="p">[(</span><span class="n">r</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">2</span><span class="p">]]</span> <span class="k">for</span> <span class="n">l</span><span class="p">,</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;inc&#39;</span><span class="p">]]</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># system deformation left X Y RZ right X Y RZ element wise</span>
<span class="n">Ue</span> <span class="o">=</span> <span class="p">[[</span><span class="n">U</span><span class="p">[(</span><span class="n">l</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">0</span><span class="p">],</span>
<span class="n">U</span><span class="p">[(</span><span class="n">l</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">1</span><span class="p">],</span>
<span class="n">U</span><span class="p">[(</span><span class="n">l</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">2</span><span class="p">],</span>
<span class="n">U</span><span class="p">[(</span><span class="n">r</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">0</span><span class="p">],</span>
<span class="n">U</span><span class="p">[(</span><span class="n">r</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">1</span><span class="p">],</span>
<span class="n">U</span><span class="p">[(</span><span class="n">r</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">])][</span><span class="mi">2</span><span class="p">]]</span> <span class="k">for</span> <span class="n">l</span><span class="p">,</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;inc&#39;</span><span class="p">]]</span>
<span class="c1"># element deformation, X Y RZ to x r rz</span>
<span class="c1"># back transformation T^T = [[c, s, 0], [-s, c, 0], [0, 0, 1]]</span>
<span class="n">u</span> <span class="o">=</span> <span class="p">[[(</span> <span class="n">math</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">angi</span><span class="p">)</span><span class="o">*</span><span class="n">Uei</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">+</span><span class="n">math</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">angi</span><span class="p">)</span><span class="o">*</span><span class="n">Uei</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">],</span>
<span class="p">(</span><span class="o">-</span><span class="n">math</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">angi</span><span class="p">)</span><span class="o">*</span><span class="n">Uei</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">+</span><span class="n">math</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">angi</span><span class="p">)</span><span class="o">*</span><span class="n">Uei</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">],</span>
<span class="n">Uei</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">],</span>
<span class="p">(</span> <span class="n">math</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">angi</span><span class="p">)</span><span class="o">*</span><span class="n">Uei</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span><span class="o">+</span><span class="n">math</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">angi</span><span class="p">)</span><span class="o">*</span><span class="n">Uei</span><span class="p">[</span><span class="mi">4</span><span class="p">])</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">],</span>
<span class="p">(</span><span class="o">-</span><span class="n">math</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">angi</span><span class="p">)</span><span class="o">*</span><span class="n">Uei</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span><span class="o">+</span><span class="n">math</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">angi</span><span class="p">)</span><span class="o">*</span><span class="n">Uei</span><span class="p">[</span><span class="mi">4</span><span class="p">])</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">],</span>
<span class="n">Uei</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span> <span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">]]</span>
<span class="k">for</span> <span class="n">Uei</span><span class="p">,</span> <span class="n">angi</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">Ue</span><span class="p">,</span> <span class="n">ang</span><span class="p">)]</span>
<span class="k">else</span><span class="p">:</span> <span class="c1"># deformation</span>
<span class="c1"># the deformation is in element coordinate system, therefore the angle is needed</span>
<span class="k">if</span> <span class="s1">&#39;rotation_plane&#39;</span> <span class="ow">in</span> <span class="n">kwargs</span> <span class="ow">and</span> <span class="s1">&#39;xz&#39;</span> <span class="o">==</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;rotation_plane&#39;</span><span class="p">]:</span>
<span class="n">u</span> <span class="o">=</span> <span class="p">[[</span> <span class="n">ue</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">],</span>
<span class="o">-</span><span class="n">ue</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">],</span>
<span class="n">ue</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">],</span>
<span class="n">ue</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">],</span>
<span class="o">-</span><span class="n">ue</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">],</span>
<span class="n">ue</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">]]</span> <span class="k">for</span> <span class="n">ue</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;deformation&#39;</span><span class="p">]]</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">u</span> <span class="o">=</span> <span class="p">[[</span><span class="n">ui</span><span class="o">*</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">]</span> <span class="k">for</span> <span class="n">ui</span> <span class="ow">in</span> <span class="n">ue</span><span class="p">]</span> <span class="k">for</span> <span class="n">ue</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;deformation&#39;</span><span class="p">]]</span>
<span class="k">return</span> <span class="p">[(</span><span class="n">pts</span><span class="p">[</span><span class="n">l</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">]],</span>
<span class="n">pts</span><span class="p">[</span><span class="n">r</span><span class="o">-</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;index_offset&#39;</span><span class="p">]],</span>
<span class="n">d</span><span class="p">)</span> <span class="k">for</span> <span class="p">(</span><span class="n">l</span><span class="p">,</span> <span class="n">r</span><span class="p">),</span> <span class="n">d</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;inc&#39;</span><span class="p">],</span> <span class="n">u</span><span class="p">)]</span>
<span class="k">return</span> <span class="nb">list</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="n">pts</span><span class="p">[:</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span> <span class="n">pts</span><span class="p">[</span><span class="mi">1</span><span class="p">:]))</span></div>
<div class="viewcode-block" id="interpolate_hermite"><a class="viewcode-back" href="../geometry.html#geometry.interpolate_hermite">[docs]</a><span class="k">def</span> <span class="nf">interpolate_hermite</span><span class="p">(</span><span class="n">lvd</span><span class="p">,</span> <span class="n">lr</span><span class="p">,</span> <span class="n">rvd</span><span class="p">,</span> <span class="n">rr</span><span class="p">,</span> <span class="n">lhd</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">rhd</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">scale_x</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">scale_y</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">samples</span><span class="o">=</span><span class="mi">10</span><span class="p">):</span>
<span class="sa">r</span><span class="sd">&quot;&quot;&quot;Interpolate cubic line with hermite boundary conditions.</span>
<span class="sd"> :param lvd: left vertcal deflection</span>
<span class="sd"> :type lvd: int or float</span>
<span class="sd"> :param lr: left rotation</span>
<span class="sd"> :type lr: int or float</span>
<span class="sd"> :param rvd: right vertical deflection</span>
<span class="sd"> :type rvd: int or float</span>
<span class="sd"> :param rr: right rotation</span>
<span class="sd"> :type rr: int or float</span>
<span class="sd"> :param lhd: left horizontal deformation (default = 0)</span>
<span class="sd"> :type lhd: int or float</span>
<span class="sd"> :param rhd: right horizontal deformation (default = 0)</span>
<span class="sd"> :type rhd: int or float</span>
<span class="sd"> :param scale_x: length of element (default = 1)</span>
<span class="sd"> :type scale_x: int or float</span>
<span class="sd"> :param scale_y: factor of the deformation (default = 1).</span>
<span class="sd"> This does not change the length.</span>
<span class="sd"> :type scale_y: int or float</span>
<span class="sd"> :param samples: number of sampling points (default = 10)</span>
<span class="sd"> :type samples: int</span>
<span class="sd"> .. math::</span>
<span class="sd"> s = \frac{x - x_1}{L} \\</span>
<span class="sd"> x = s\,L + x_1</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">L</span> <span class="o">=</span> <span class="n">scale_x</span>
<span class="n">Lp</span> <span class="o">=</span> <span class="n">L</span> <span class="o">+</span> <span class="n">rhd</span> <span class="o">-</span> <span class="n">lhd</span>
<span class="c1"># x=[0,1] in non-dimensional coordinates</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">num</span><span class="o">=</span><span class="n">samples</span><span class="p">)</span>
<span class="n">N1</span> <span class="o">=</span> <span class="mi">1</span> <span class="o">-</span> <span class="mi">3</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="mi">2</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="mi">3</span>
<span class="n">N2</span> <span class="o">=</span> <span class="p">(</span> <span class="n">x</span> <span class="o">-</span> <span class="mi">2</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="n">x</span><span class="o">**</span><span class="mi">3</span><span class="p">)</span><span class="o">*</span><span class="n">Lp</span>
<span class="n">N3</span> <span class="o">=</span> <span class="mi">3</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="o">-</span> <span class="mi">2</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="mi">3</span>
<span class="n">N4</span> <span class="o">=</span> <span class="p">(</span> <span class="o">-</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="n">x</span><span class="o">**</span><span class="mi">3</span><span class="p">)</span><span class="o">*</span><span class="n">Lp</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">x</span><span class="o">*</span><span class="n">Lp</span>
<span class="c1"># x=[0,L] in global coordinates</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">Lp</span><span class="p">,</span> <span class="n">num</span><span class="o">=</span><span class="n">samples</span><span class="p">)</span>
<span class="n">N1</span> <span class="o">=</span> <span class="mi">1</span> <span class="o">-</span> <span class="mi">3</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="o">/</span><span class="n">Lp</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="mi">2</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="mi">3</span><span class="o">/</span><span class="n">Lp</span><span class="o">**</span><span class="mi">3</span>
<span class="n">N2</span> <span class="o">=</span> <span class="n">x</span> <span class="o">-</span> <span class="mi">2</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="o">/</span><span class="n">Lp</span> <span class="o">+</span> <span class="n">x</span><span class="o">**</span><span class="mi">3</span><span class="o">/</span><span class="n">Lp</span><span class="o">**</span><span class="mi">2</span>
<span class="n">N3</span> <span class="o">=</span> <span class="mi">3</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="o">/</span><span class="n">Lp</span><span class="o">**</span><span class="mi">2</span> <span class="o">-</span> <span class="mi">2</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="mi">3</span><span class="o">/</span><span class="n">Lp</span><span class="o">**</span><span class="mi">3</span>
<span class="n">N4</span> <span class="o">=</span> <span class="o">-</span> <span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="o">/</span><span class="n">Lp</span> <span class="o">+</span> <span class="n">x</span><span class="o">**</span><span class="mi">3</span><span class="o">/</span><span class="n">Lp</span><span class="o">**</span><span class="mi">2</span>
<span class="n">v</span> <span class="o">=</span> <span class="n">N1</span><span class="o">*</span><span class="n">lvd</span> <span class="o">+</span> <span class="n">N2</span><span class="o">*</span><span class="n">lr</span> <span class="o">+</span> <span class="n">N3</span><span class="o">*</span><span class="n">rvd</span> <span class="o">+</span> <span class="n">N4</span><span class="o">*</span><span class="n">rr</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">lhd</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">v</span><span class="o">*</span><span class="n">scale_y</span>
<span class="k">return</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span></div>
<span class="c1">#</span>
<span class="c1"># matplotlib format, return lists for x and y</span>
<span class="c1">#</span>
<div class="viewcode-block" id="points"><a class="viewcode-back" href="../geometry.html#geometry.points">[docs]</a><span class="k">def</span> <span class="nf">points</span><span class="p">(</span><span class="o">*</span><span class="n">pts</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;\</span>
<span class="sd"> :param `*pts`: points to rearrange</span>
<span class="sd"> </span>
<span class="sd"> :returns: ((point1_x, point2_x), (point1_y, point2_y), ...)</span>
<span class="sd"> :rtype: tuple</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="nb">zip</span><span class="p">(</span><span class="o">*</span><span class="n">pts</span><span class="p">)</span></div>
<div class="viewcode-block" id="line"><a class="viewcode-back" href="../geometry.html#geometry.line">[docs]</a><span class="k">def</span> <span class="nf">line</span><span class="p">(</span><span class="n">point1</span><span class="p">,</span> <span class="n">point2</span><span class="p">,</span> <span class="n">samples</span><span class="o">=</span><span class="mi">2</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;\</span>
<span class="sd">&quot;&quot;&quot;Line defined by two end points.</span>
<span class="sd"> .. math::</span>
<span class="sd"> y = \\frac{y_2-y_1}{x_2-x_1}(x-x_1) + y_1</span>
<span class="sd"> </span>
<span class="sd"> :param point1: one end point</span>
<span class="sd"> :type point1: tuple</span>
<span class="sd"> :param point2: other end point</span>
<span class="sd"> :type point2: tuple</span>
<span class="sd"> :param samples: number of sampling points</span>
<span class="sd"> :param samples: number of sampling points (default = 2)</span>
<span class="sd"> :type samples: int</span>
<span class="sd"> :returns: ((point1_x, point2_x), (points1_y, point2_y)) or</span>
<span class="sd"> ([sample_point1_x, sample_point2_x, ...],</span>
<span class="sd"> [sample_points1_y, sample_point2_y, ...])</span>
<span class="sd"> :rtype: tuple</span>
<span class="sd"> :Example:</span>
<span class="sd"> &gt;&gt;&gt; x, y = line((0, 0), (1, 0))</span>
<span class="sd"> &gt;&gt;&gt; print(x, y)</span>
<span class="sd"> ((0, 1), (0, 0))</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">p1x</span><span class="p">,</span> <span class="n">p1y</span> <span class="o">=</span> <span class="n">point1</span>
<span class="n">p2x</span><span class="p">,</span> <span class="n">p2y</span> <span class="o">=</span> <span class="n">point2</span>
@@ -181,7 +451,7 @@
<span class="n">denominator</span> <span class="o">=</span> <span class="p">(</span><span class="n">p1x</span> <span class="o">-</span> <span class="n">p2x</span><span class="p">)</span>
<span class="k">if</span> <span class="n">samples</span> <span class="o">&gt;</span> <span class="mi">2</span> <span class="ow">and</span> <span class="n">denominator</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="n">p1x</span><span class="p">,</span> <span class="n">p2x</span><span class="p">)</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="n">p1x</span><span class="p">,</span> <span class="n">p2x</span><span class="p">,</span> <span class="n">samples</span><span class="p">)</span>
<span class="n">a</span> <span class="o">=</span> <span class="p">(</span><span class="n">p1y</span> <span class="o">-</span> <span class="n">p2y</span><span class="p">)</span> <span class="o">/</span> <span class="n">denominator</span>
<span class="n">b</span> <span class="o">=</span> <span class="p">(</span><span class="n">p1x</span><span class="o">*</span><span class="n">p2y</span> <span class="o">-</span> <span class="n">p2x</span><span class="o">*</span><span class="n">p1y</span><span class="p">)</span> <span class="o">/</span> <span class="n">denominator</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">a</span><span class="o">*</span><span class="n">x</span> <span class="o">+</span> <span class="n">b</span>
@@ -189,8 +459,10 @@
<span class="k">return</span> <span class="p">(</span><span class="n">p1x</span><span class="p">,</span> <span class="n">p2x</span><span class="p">),</span> <span class="p">(</span><span class="n">p1y</span><span class="p">,</span> <span class="n">p2y</span><span class="p">)</span> <span class="c1"># matplotlib format</span></div>
<div class="viewcode-block" id="cubic"><a class="viewcode-back" href="../geometry.html#geometry.cubic">[docs]</a><span class="k">def</span> <span class="nf">cubic</span><span class="p">(</span><span class="n">point1</span><span class="p">,</span> <span class="n">angle1</span><span class="p">,</span> <span class="n">point2</span><span class="p">,</span> <span class="n">angle2</span><span class="p">,</span> <span class="n">samples</span><span class="o">=</span><span class="mi">50</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;\</span>
<div class="viewcode-block" id="cubic"><a class="viewcode-back" href="../geometry.html#geometry.cubic">[docs]</a><span class="k">def</span> <span class="nf">cubic</span><span class="p">(</span><span class="n">point1</span><span class="p">,</span> <span class="n">angle1</span><span class="p">,</span> <span class="n">point2</span><span class="p">,</span> <span class="n">angle2</span><span class="p">,</span> <span class="n">samples</span><span class="o">=</span><span class="mi">10</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Cubic line defined by two end points and the rotation in radians</span>
<span class="sd"> at the points.</span>
<span class="sd"> :param point1: one end point</span>
<span class="sd"> :type point1: tuple</span>
<span class="sd"> :param angle1: the slope at the one end point</span>
@@ -199,9 +471,9 @@
<span class="sd"> :type point2: tuple</span>
<span class="sd"> :param angle2: the slope at the other end point</span>
<span class="sd"> :type angle2: int or float</span>
<span class="sd"> :param samples: number of sampling points</span>
<span class="sd"> :param samples: number of sampling points (default = 10)</span>
<span class="sd"> :type samples: int</span>
<span class="sd"> </span>
<span class="sd"> :returns: ([sample_point1_x, sample_point2_x, ...],</span>
<span class="sd"> [sample_points1_y, sample_point2_y, ...])</span>
<span class="sd"> :rtype: tuple</span>
@@ -222,7 +494,9 @@
<div class="viewcode-block" id="cubic_deg"><a class="viewcode-back" href="../geometry.html#geometry.cubic_deg">[docs]</a><span class="k">def</span> <span class="nf">cubic_deg</span><span class="p">(</span><span class="n">point1</span><span class="p">,</span> <span class="n">angle1</span><span class="p">,</span> <span class="n">point2</span><span class="p">,</span> <span class="n">angle2</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;\</span>
<span class="sd">&quot;&quot;&quot;Cubic line defined by two end points and the roation in degree</span>
<span class="sd"> at the points.</span>
<span class="sd"> :param point1: one end point</span>
<span class="sd"> :type point1: tuple</span>
<span class="sd"> :param angle1: the slope at the one end point</span>
@@ -231,7 +505,7 @@
<span class="sd"> :type point2: tuple</span>
<span class="sd"> :param angle2: the slope at the other end point</span>
<span class="sd"> :type angle2: int or float</span>
<span class="sd"> </span>
<span class="sd"> :returns: ([sample_point1_x, sample_point2_x, ...],</span>
<span class="sd"> [sample_points1_y, sample_point2_y, ...])</span>
<span class="sd"> :rtype: tuple</span>
@@ -294,7 +568,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

183
docs/build/html/_modules/geometry_plot.html vendored Normal file
View File

@@ -0,0 +1,183 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta charset="utf-8" />
<title>geometry_plot &#8212; pylib 2019.5.19 documentation</title>
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<link rel="stylesheet" href="../_static/custom.css" type="text/css" />
<script type="text/javascript" id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<script type="text/javascript" src="../_static/language_data.js"></script>
<script async="async" type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" />
<link rel="stylesheet" href="../_static/custom.css" type="text/css" />
<meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
</head><body>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<h1>Source code for geometry_plot</h1><div class="highlight"><pre>
<span></span><span class="ch">#!/usr/bin/env python</span>
<span class="c1"># -*- coding: utf-8 -*-</span>
<span class="sd">&quot;&quot;&quot;2D geometry plotter using matplotlib (pylab).</span>
<span class="sd">:Date: 2019-08-20</span>
<span class="sd">.. module:: geometry_plot</span>
<span class="sd"> :platform: *nix, Windows</span>
<span class="sd"> :synopsis: Geometry plotting.</span>
<span class="sd">.. moduleauthor:: Daniel Weschke &lt;daniel.weschke@directbox.de&gt;</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="kn">import</span> <span class="nn">math</span>
<span class="kn">import</span> <span class="nn">pylab</span>
<span class="kn">from</span> <span class="nn">geometry</span> <span class="k">import</span> <span class="n">line</span><span class="p">,</span> <span class="n">interpolate_hermite</span><span class="p">,</span> <span class="n">rotate_xy</span><span class="p">,</span> <span class="n">translate_xy</span>
<span class="n">pylab</span><span class="o">.</span><span class="n">style</span><span class="o">.</span><span class="n">use</span><span class="p">(</span><span class="s1">&#39;dark_background&#39;</span><span class="p">)</span>
<span class="n">pylab</span><span class="o">.</span><span class="n">rcParams</span><span class="p">[</span><span class="s1">&#39;grid.color&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;gray&#39;</span>
<span class="c1"># The kwargs are Line2D properties:</span>
<span class="c1"># https://matplotlib.org/3.1.1/_modules/matplotlib/lines.html#Line2D</span>
<span class="c1"># https://matplotlib.org/devdocs/_modules/matplotlib/lines.html#Line2D</span>
<span class="n">pylab_Line2D_properties</span> <span class="o">=</span> <span class="p">[</span>
<span class="s1">&#39;linewidth&#39;</span><span class="p">,</span> <span class="s1">&#39;linestyle&#39;</span><span class="p">,</span> <span class="s1">&#39;color&#39;</span><span class="p">,</span>
<span class="s1">&#39;marker&#39;</span><span class="p">,</span> <span class="s1">&#39;markersize&#39;</span><span class="p">,</span> <span class="s1">&#39;markeredgewidth&#39;</span><span class="p">,</span> <span class="s1">&#39;markeredgecolor&#39;</span><span class="p">,</span>
<span class="s1">&#39;markerfacecolor&#39;</span><span class="p">,</span> <span class="s1">&#39;markerfacecoloralt&#39;</span><span class="p">,</span>
<span class="s1">&#39;fillstyle&#39;</span><span class="p">,</span> <span class="s1">&#39;antialiased&#39;</span><span class="p">,</span>
<span class="s1">&#39;dash_capstyle&#39;</span><span class="p">,</span> <span class="s1">&#39;solid_capstyle&#39;</span><span class="p">,</span>
<span class="s1">&#39;dash_joinstyle&#39;</span><span class="p">,</span> <span class="s1">&#39;solid_joinstyle&#39;</span><span class="p">,</span>
<span class="s1">&#39;pickradius&#39;</span><span class="p">,</span> <span class="s1">&#39;drawstyle&#39;</span><span class="p">,</span> <span class="s1">&#39;markevery&#39;</span><span class="p">,</span>
<span class="p">]</span>
<div class="viewcode-block" id="plot_lines"><a class="viewcode-back" href="../geometry_plot.html#geometry_plot.plot_lines">[docs]</a><span class="k">def</span> <span class="nf">plot_lines</span><span class="p">(</span><span class="n">lns</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
<span class="k">if</span> <span class="s1">&#39;color&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="c1"># Colors from &quot;tab10&quot; colormap</span>
<span class="n">cmap</span> <span class="o">=</span> <span class="n">pylab</span><span class="o">.</span><span class="n">get_cmap</span><span class="p">(</span><span class="s2">&quot;tab10&quot;</span><span class="p">)</span>
<span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;color&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">cmap</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="c1"># Colors from color cycle</span>
<span class="n">cycle</span> <span class="o">=</span> <span class="n">pylab</span><span class="o">.</span><span class="n">rcParams</span><span class="p">[</span><span class="s1">&#39;axes.prop_cycle&#39;</span><span class="p">]</span><span class="o">.</span><span class="n">by_key</span><span class="p">()[</span><span class="s1">&#39;color&#39;</span><span class="p">]</span>
<span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;color&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">cycle</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="c1"># Colors from CN notation (same as the first 10 colors from the color cycle)</span>
<span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;color&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s2">&quot;C0&quot;</span>
<span class="k">for</span> <span class="n">ln</span> <span class="ow">in</span> <span class="n">lns</span><span class="p">:</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">line</span><span class="p">(</span><span class="o">*</span><span class="n">ln</span><span class="p">)</span>
<span class="n">pylab</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span></div>
<div class="viewcode-block" id="plot_cubic_lines"><a class="viewcode-back" href="../geometry_plot.html#geometry_plot.plot_cubic_lines">[docs]</a><span class="k">def</span> <span class="nf">plot_cubic_lines</span><span class="p">(</span><span class="n">lns</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
<span class="k">if</span> <span class="s1">&#39;color&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="c1"># Colors from &quot;tab10&quot; colormap</span>
<span class="n">cmap</span> <span class="o">=</span> <span class="n">pylab</span><span class="o">.</span><span class="n">get_cmap</span><span class="p">(</span><span class="s2">&quot;tab10&quot;</span><span class="p">)</span>
<span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;color&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">cmap</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="c1"># Colors from color cycle</span>
<span class="n">cycle</span> <span class="o">=</span> <span class="n">pylab</span><span class="o">.</span><span class="n">rcParams</span><span class="p">[</span><span class="s1">&#39;axes.prop_cycle&#39;</span><span class="p">]</span><span class="o">.</span><span class="n">by_key</span><span class="p">()[</span><span class="s1">&#39;color&#39;</span><span class="p">]</span>
<span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;color&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">cycle</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="c1"># Colors from CN notation (same as the first 10 colors from the color cycle)</span>
<span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;color&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s2">&quot;C0&quot;</span>
<span class="n">factor</span> <span class="o">=</span> <span class="mi">1</span>
<span class="k">if</span> <span class="s1">&#39;factor&#39;</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="n">factor</span> <span class="o">=</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;factor&#39;</span><span class="p">]</span>
<span class="n">samples</span> <span class="o">=</span> <span class="mi">10</span>
<span class="k">if</span> <span class="s1">&#39;samples&#39;</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
<span class="n">samples</span> <span class="o">=</span> <span class="n">kwargs</span><span class="p">[</span><span class="s1">&#39;samples&#39;</span><span class="p">]</span>
<span class="n">kwargs</span> <span class="o">=</span> <span class="p">{</span><span class="n">k</span><span class="p">:</span> <span class="n">v</span> <span class="k">for</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="k">if</span> <span class="n">k</span> <span class="ow">in</span> <span class="n">pylab_Line2D_properties</span><span class="p">}</span>
<span class="k">for</span> <span class="n">ln</span> <span class="ow">in</span> <span class="n">lns</span><span class="p">:</span>
<span class="n">l</span><span class="p">,</span> <span class="n">r</span><span class="p">,</span> <span class="n">d</span> <span class="o">=</span> <span class="n">ln</span>
<span class="n">L</span> <span class="o">=</span> <span class="n">math</span><span class="o">.</span><span class="n">sqrt</span><span class="p">((</span><span class="n">r</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">-</span><span class="n">l</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="p">(</span><span class="n">r</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">l</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
<span class="n">ang</span> <span class="o">=</span> <span class="n">math</span><span class="o">.</span><span class="n">atan2</span><span class="p">(</span><span class="n">r</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">l</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">r</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">-</span><span class="n">l</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">interpolate_hermite</span><span class="p">(</span><span class="n">d</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">d</span><span class="p">[</span><span class="mi">2</span><span class="p">],</span> <span class="n">d</span><span class="p">[</span><span class="mi">4</span><span class="p">],</span> <span class="n">d</span><span class="p">[</span><span class="mi">5</span><span class="p">],</span> <span class="n">d</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">d</span><span class="p">[</span><span class="mi">3</span><span class="p">],</span>
<span class="n">scale_x</span><span class="o">=</span><span class="n">L</span><span class="p">,</span> <span class="n">scale_y</span><span class="o">=</span><span class="n">factor</span><span class="p">,</span> <span class="n">samples</span><span class="o">=</span><span class="n">samples</span><span class="p">)</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">rotate_xy</span><span class="p">((</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="n">ang</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">translate_xy</span><span class="p">(</span><span class="n">l</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="n">pylab</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span></div>
</pre></div>
</div>
</div>
</div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="../index.html">pylib</a></h1>
<h3>Navigation</h3>
<div class="relations">
<h3>Related Topics</h3>
<ul>
<li><a href="../index.html">Documentation overview</a><ul>
<li><a href="index.html">Module code</a><ul>
</ul></li>
</ul></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
<h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="../search.html" method="get">
<input type="text" name="q" aria-labelledby="searchlabel" />
<input type="submit" value="Go" />
</form>
</div>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="footer">
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>
</body>
</html>

3
docs/build/html/_modules/index.html vendored
View File

@@ -36,6 +36,7 @@
<ul><li><a href="data.html">data</a></li>
<li><a href="date.html">date</a></li>
<li><a href="geometry.html">geometry</a></li>
<li><a href="geometry_plot.html">geometry_plot</a></li>
<li><a href="numerical/fit.html">numerical.fit</a></li>
<li><a href="numerical/integration.html">numerical.integration</a></li>
<li><a href="numerical/ode.html">numerical.ode</a></li>
@@ -93,7 +94,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

2
docs/build/html/_modules/numerical/fit.html vendored
View File

@@ -182,7 +182,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

2
docs/build/html/_modules/numerical/integration.html vendored
View File

@@ -238,7 +238,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

2
docs/build/html/_modules/numerical/ode.html vendored
View File

@@ -528,7 +528,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

2
docs/build/html/_modules/numerical/ode_model.html vendored
View File

@@ -207,7 +207,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

2
docs/build/html/_modules/time_of_day.html vendored
View File

@@ -243,7 +243,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

7
docs/build/html/_sources/geometry_plot.rst.txt vendored Normal file
View File

@@ -0,0 +1,7 @@
geometry\_plot module
=====================
.. automodule:: geometry_plot
:members:
:undoc-members:
:show-inheritance:

1
docs/build/html/_sources/modules.rst.txt vendored
View File

@@ -7,5 +7,6 @@ src
data
date
geometry
geometry_plot
numerical
time_of_day

11
docs/build/html/_static/basic.css vendored
View File

@@ -520,14 +520,15 @@ dl.citation > dd:after {
}
dl.field-list {
display: flex;
flex-wrap: wrap;
display: grid;
grid-template-columns: fit-content(30%) auto;
}
dl.field-list > dt {
flex-basis: 20%;
font-weight: bold;
word-break: break-word;
padding-left: 0.5em;
padding-right: 5px;
}
dl.field-list > dt:after {
@@ -535,8 +536,8 @@ dl.field-list > dt:after {
}
dl.field-list > dd {
flex-basis: 70%;
padding-left: 1em;
padding-left: 0.5em;
margin-top: 0em;
margin-left: 0em;
margin-bottom: 0em;
}

10598
docs/build/html/_static/jquery-3.4.1.js vendored Normal file
View File

File diff suppressed because it is too large Load Diff

6
docs/build/html/_static/jquery.js vendored
View File

File diff suppressed because one or more lines are too long

23
docs/build/html/data.html vendored
View File

@@ -41,6 +41,27 @@
</dd>
</dl>
<span class="target" id="module-data"></span><dl class="function">
<dt id="data.fold_list">
<code class="sig-name descname">fold_list</code><span class="sig-paren">(</span><em class="sig-param">lst</em>, <em class="sig-param">n</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/data.html#fold_list"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#data.fold_list" title="Permalink to this definition"></a></dt>
<dd><p>Convert one-dimensional kx1 array (list) to two-dimensional mxn
array. m = k / n</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>lst</strong> (<em>list</em>) – list to convert</p></li>
<li><p><strong>n</strong> (<em>int</em>) – length of the second dimenson</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>two-dimensional array (list of lists)</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>list</p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="data.get_id">
<code class="sig-name descname">get_id</code><span class="sig-paren">(</span><em class="sig-param">ids</em>, <em class="sig-param">uide</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/data.html#get_id"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#data.get_id" title="Permalink to this definition"></a></dt>
<dd><p>Get full id from unique id ending.</p>
@@ -205,7 +226,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
|

2
docs/build/html/date.html vendored
View File

@@ -212,7 +212,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
|

28
docs/build/html/genindex.html vendored
View File

@@ -73,6 +73,8 @@
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="geometry.html#geometry.cubic_deg">cubic_deg() (in module geometry)</a>
</li>
<li><a href="geometry.html#geometry.cubics">cubics() (in module geometry)</a>
</li>
</ul></td>
</tr></table>
@@ -126,6 +128,8 @@
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="data.html#data.fold_list">fold_list() (in module data)</a>
</li>
<li><a href="numerical.html#numerical.ode.fpi">fpi() (in module numerical.ode)</a>
</li>
</ul></td>
@@ -138,11 +142,13 @@
</li>
<li><a href="numerical.html#numerical.fit.gauss_fit">gauss_fit() (in module numerical.fit)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="date.html#date.gaußsche_osterformel">gaußsche_osterformel() (in module date)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="geometry.html#module-geometry">geometry (module)</a>, <a href="geometry.html#module-geometry">[1]</a>
</li>
<li><a href="geometry_plot.html#module-geometry_plot">geometry_plot (module)</a>, <a href="geometry_plot.html#module-geometry_plot">[1]</a>
</li>
<li><a href="data.html#data.get_id">get_id() (in module data)</a>
</li>
@@ -166,11 +172,13 @@
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="numerical.html#numerical.ode.i1">i1() (in module numerical.ode)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="time_of_day.html#time_of_day.in_seconds">in_seconds() (in module time_of_day)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="numerical.html#module-integration">integration (module)</a>
</li>
<li><a href="geometry.html#geometry.interpolate_hermite">interpolate_hermite() (in module geometry)</a>
</li>
</ul></td>
</tr></table>
@@ -182,6 +190,8 @@
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="geometry.html#geometry.lines">lines() (in module geometry)</a>
</li>
<li><a href="data.html#data.load">load() (in module data)</a>
</li>
</ul></td>
@@ -240,7 +250,9 @@
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="geometry.html#geometry.points">points() (in module geometry)</a>
<li><a href="geometry_plot.html#geometry_plot.plot_cubic_lines">plot_cubic_lines() (in module geometry_plot)</a>
</li>
<li><a href="geometry_plot.html#geometry_plot.plot_lines">plot_lines() (in module geometry_plot)</a>
</li>
</ul></td>
</tr></table>
@@ -257,6 +269,8 @@
<li><a href="geometry.html#geometry.rotate">rotate() (in module geometry)</a>
</li>
<li><a href="geometry.html#geometry.rotate_deg">rotate_deg() (in module geometry)</a>
</li>
<li><a href="geometry.html#geometry.rotate_xy">rotate_xy() (in module geometry)</a>
</li>
</ul></td>
</tr></table>
@@ -287,6 +301,8 @@
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="geometry.html#geometry.translate">translate() (in module geometry)</a>
</li>
<li><a href="geometry.html#geometry.translate_xy">translate_xy() (in module geometry)</a>
</li>
<li><a href="numerical.html#numerical.integration.trapez">trapez() (in module numerical.integration)</a>
</li>
@@ -361,7 +377,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

201
docs/build/html/geometry.html vendored
View File

@@ -37,20 +37,22 @@
<p>2D geometry objects.</p>
<dl class="field-list simple">
<dt class="field-odd">Date</dt>
<dd class="field-odd"><p>2019-03-21</p>
<dd class="field-odd"><p>2019-08-20</p>
</dd>
</dl>
<span class="target" id="module-geometry"></span><dl class="function">
<dt id="geometry.cubic">
<code class="sig-name descname">cubic</code><span class="sig-paren">(</span><em class="sig-param">point1</em>, <em class="sig-param">angle1</em>, <em class="sig-param">point2</em>, <em class="sig-param">angle2</em>, <em class="sig-param">samples=50</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#cubic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.cubic" title="Permalink to this definition"></a></dt>
<dd><dl class="field-list simple">
<code class="sig-name descname">cubic</code><span class="sig-paren">(</span><em class="sig-param">point1</em>, <em class="sig-param">angle1</em>, <em class="sig-param">point2</em>, <em class="sig-param">angle2</em>, <em class="sig-param">samples=10</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#cubic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.cubic" title="Permalink to this definition"></a></dt>
<dd><p>Cubic line defined by two end points and the rotation in radians
at the points.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>point1</strong> (<em>tuple</em>) – one end point</p></li>
<li><p><strong>angle1</strong> (<em>int</em><em> or </em><em>float</em>) – the slope at the one end point</p></li>
<li><p><strong>point2</strong> (<em>tuple</em>) – other end point</p></li>
<li><p><strong>angle2</strong> (<em>int</em><em> or </em><em>float</em>) – the slope at the other end point</p></li>
<li><p><strong>samples</strong> (<em>int</em>) – number of sampling points</p></li>
<li><p><strong>samples</strong> (<em>int</em>) – number of sampling points (default = 10)</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
@@ -66,7 +68,9 @@
<dl class="function">
<dt id="geometry.cubic_deg">
<code class="sig-name descname">cubic_deg</code><span class="sig-paren">(</span><em class="sig-param">point1</em>, <em class="sig-param">angle1</em>, <em class="sig-param">point2</em>, <em class="sig-param">angle2</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#cubic_deg"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.cubic_deg" title="Permalink to this definition"></a></dt>
<dd><dl class="field-list simple">
<dd><p>Cubic line defined by two end points and the roation in degree
at the points.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>point1</strong> (<em>tuple</em>) – one end point</p></li>
@@ -89,17 +93,91 @@
</div>
</dd></dl>
<dl class="function">
<dt id="geometry.cubics">
<code class="sig-name descname">cubics</code><span class="sig-paren">(</span><em class="sig-param">pts</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#cubics"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.cubics" title="Permalink to this definition"></a></dt>
<dd><p>Cubic lines defined by a list of two end points. The deformation
as displacement and rotation (radians) is defined element wise as
keyword argument deformation or global node wise as
global_deformation. The global coordinate system is xy. x in the
right direction and y in the top direction.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>pts</strong> – list of points in absolute global coordinate system. If
keyword inc is given than the inc decides what the left and the
right end point of the line is, otherwise it is assumed that the
points build a solid line, that is lines between the given points
in given order.</p></li>
<li><p><strong>**kwargs</strong> – <p>options:</p>
<ul>
<li><p>deformation – list of deformation element wise. Additional
deformation (translation and rotation in radians) at element
left and right node.</p></li>
<li><p>rotation_plane – rotation plane of the element wise
deformation defined by a string; either ‘xy’ or ‘xz’ (default
= ‘xy’). x in the right direction and y in the top direction
or z in the bottom direction.</p></li>
<li><p>global_deformation – list of deformation global node wise.
Additional deformation (horizontal translation, vertical
translation and rotation in radians) at node.</p></li>
<li><p>factor – factor of the derformation (default = 1).</p></li>
<li><p>inc – the incidence table, a list of 2 element lists. The inc
decides what the left and the right end point of the line is.</p></li>
<li><p>index_offset – starting index of lists (default = 0).</p></li>
</ul>
</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>list of endpoints for each line;
[(((point1_x, point1_y) angle1), ((point2_x, point2_y), angle2),
(p1, angle1, p2, angle2),
…]</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>list</p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="geometry.interpolate_hermite">
<code class="sig-name descname">interpolate_hermite</code><span class="sig-paren">(</span><em class="sig-param">lvd</em>, <em class="sig-param">lr</em>, <em class="sig-param">rvd</em>, <em class="sig-param">rr</em>, <em class="sig-param">lhd=0</em>, <em class="sig-param">rhd=0</em>, <em class="sig-param">scale_x=1</em>, <em class="sig-param">scale_y=1</em>, <em class="sig-param">samples=10</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#interpolate_hermite"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.interpolate_hermite" title="Permalink to this definition"></a></dt>
<dd><p>Interpolate cubic line with hermite boundary conditions.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>lvd</strong> (<em>int</em><em> or </em><em>float</em>) – left vertcal deflection</p></li>
<li><p><strong>lr</strong> (<em>int</em><em> or </em><em>float</em>) – left rotation</p></li>
<li><p><strong>rvd</strong> (<em>int</em><em> or </em><em>float</em>) – right vertical deflection</p></li>
<li><p><strong>rr</strong> (<em>int</em><em> or </em><em>float</em>) – right rotation</p></li>
<li><p><strong>lhd</strong> (<em>int</em><em> or </em><em>float</em>) – left horizontal deformation (default = 0)</p></li>
<li><p><strong>rhd</strong> (<em>int</em><em> or </em><em>float</em>) – right horizontal deformation (default = 0)</p></li>
<li><p><strong>scale_x</strong> (<em>int</em><em> or </em><em>float</em>) – length of element (default = 1)</p></li>
<li><p><strong>scale_y</strong> (<em>int</em><em> or </em><em>float</em>) – factor of the deformation (default = 1).
This does not change the length.</p></li>
<li><p><strong>samples</strong> (<em>int</em>) – number of sampling points (default = 10)</p></li>
</ul>
</dd>
</dl>
<div class="math notranslate nohighlight">
\[\begin{split}s = \frac{x - x_1}{L} \\
x = s\,L + x_1\end{split}\]</div>
</dd></dl>
<dl class="function">
<dt id="geometry.line">
<code class="sig-name descname">line</code><span class="sig-paren">(</span><em class="sig-param">point1</em>, <em class="sig-param">point2</em>, <em class="sig-param">samples=2</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#line"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.line" title="Permalink to this definition"></a></dt>
<dd><div class="math notranslate nohighlight">
<dd><p>Line defined by two end points.</p>
<div class="math notranslate nohighlight">
\[y = \frac{y_2-y_1}{x_2-x_1}(x-x_1) + y_1\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>point1</strong> (<em>tuple</em>) – one end point</p></li>
<li><p><strong>point2</strong> (<em>tuple</em>) – other end point</p></li>
<li><p><strong>samples</strong> (<em>int</em>) – number of sampling points</p></li>
<li><p><strong>samples</strong> (<em>int</em>) – number of sampling points (default = 2)</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
@@ -110,23 +188,55 @@
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>tuple</p>
</dd>
<dt class="field-even">Example</dt>
<dd class="field-even"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">line</span><span class="p">((</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="go">((0, 1), (0, 0))</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="geometry.points">
<code class="sig-name descname">points</code><span class="sig-paren">(</span><em class="sig-param">*pts</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#points"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.points" title="Permalink to this definition"></a></dt>
<dd><dl class="field-list simple">
<dt id="geometry.lines">
<code class="sig-name descname">lines</code><span class="sig-paren">(</span><em class="sig-param">pts</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#lines"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.lines" title="Permalink to this definition"></a></dt>
<dd><p>Lines defined by a list of end points.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>*pts</strong> – points to rearrange</p>
<dd class="field-odd"><ul class="simple">
<li><p><strong>pts</strong> (<em>list</em>) – list of points in absolute global coordinate system. If
keyword inc is given than the inc decides what the left and the
right end point of the line is, otherwise it is assumed that the
points build a solid line, that is lines between the given points
in given order.</p></li>
<li><p><strong>**kwargs</strong> – <p>options:</p>
<ul>
<li><p>deformation – list of points. Additional deformation
(translation) at point.</p></li>
<li><p>factor – factor of the deformation (default = 1).</p></li>
<li><p>inc – the incidence table, a list of 2 element lists. The inc
decides what the left and the right end point of the line is.</p></li>
<li><p>index_offset – starting index of lists (default = 0).</p></li>
</ul>
</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>((point1_x, point2_x), (point1_y, point2_y), …)</p>
<dd class="field-even"><p>list of endpoints for each line;
[((point1_x, point1_y), (point2_x, point2_y)),
(p1, p2),
…]</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>tuple</p>
<dd class="field-odd"><p>list</p>
</dd>
</dl>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="geometry_plot.html#geometry_plot.plot_lines" title="geometry_plot.plot_lines"><code class="xref py py-meth docutils literal notranslate"><span class="pre">plot_lines()</span></code></a> of the <a class="reference internal" href="geometry_plot.html#module-geometry_plot" title="geometry_plot: Geometry plotting. (*nix, Windows)"><code class="xref py py-mod docutils literal notranslate"><span class="pre">geometry_plot</span></code></a>
module to plot the lines</p>
</div>
</dd></dl>
<dl class="function">
@@ -151,8 +261,8 @@
<dl class="function">
<dt id="geometry.rotate">
<code class="sig-name descname">rotate</code><span class="sig-paren">(</span><em class="sig-param">origin</em>, <em class="sig-param">angle</em>, <em class="sig-param">*pts</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#rotate"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.rotate" title="Permalink to this definition"></a></dt>
<dd><p>Rotate a point or polygon counterclockwise by a given angle around a given
origin. The angle should be given in radians.</p>
<dd><p>Rotate a point or polygon counterclockwise by a given angle
around a given origin. The angle should be given in radians.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
@@ -169,13 +279,17 @@ origin. The angle should be given in radians.</p>
<dd class="field-odd"><p>tuple</p>
</dd>
</dl>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#geometry.rotate_xy" title="geometry.rotate_xy"><code class="xref py py-meth docutils literal notranslate"><span class="pre">rotate_xy()</span></code></a></p>
</div>
</dd></dl>
<dl class="function">
<dt id="geometry.rotate_deg">
<code class="sig-name descname">rotate_deg</code><span class="sig-paren">(</span><em class="sig-param">origin</em>, <em class="sig-param">angle</em>, <em class="sig-param">*pts</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#rotate_deg"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.rotate_deg" title="Permalink to this definition"></a></dt>
<dd><p>Rotate a point or polygon counterclockwise by a given angle around a given
origin. The angle should be given in degrees.</p>
<dd><p>Rotate a point or polygon counterclockwise by a given angle
around a given origin. The angle should be given in degrees.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
@@ -198,6 +312,28 @@ origin. The angle should be given in degrees.</p>
</div>
</dd></dl>
<dl class="function">
<dt id="geometry.rotate_xy">
<code class="sig-name descname">rotate_xy</code><span class="sig-paren">(</span><em class="sig-param">origin</em>, <em class="sig-param">angle</em>, <em class="sig-param">x</em>, <em class="sig-param">y</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#rotate_xy"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.rotate_xy" title="Permalink to this definition"></a></dt>
<dd><p>Rotate x and y coordinates counterclockwise by a given angle
around a given origin. The angle should be given in radians.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>origin</strong> (<em>tuple</em>) – the center of rotation</p></li>
<li><p><strong>angle</strong> (<em>int</em><em> or </em><em>float</em>) – the rotation angle</p></li>
<li><p><strong>x</strong> (<em>int</em><em> or </em><em>float</em><em> or </em><em>list</em>) – x coordinates</p></li>
<li><p><strong>y</strong> (<em>int</em><em> or </em><em>float</em><em> or </em><em>list</em>) – y coordinates</p></li>
<li><p><strong>**kwargs</strong> – options</p></li>
</ul>
</dd>
</dl>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#geometry.rotate" title="geometry.rotate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">rotate()</span></code></a></p>
</div>
</dd></dl>
<dl class="function">
<dt id="geometry.square">
<code class="sig-name descname">square</code><span class="sig-paren">(</span><em class="sig-param">width</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#square"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.square" title="Permalink to this definition"></a></dt>
@@ -236,6 +372,35 @@ origin. The angle should be given in degrees.</p>
<dd class="field-odd"><p>tuple</p>
</dd>
</dl>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#geometry.translate_xy" title="geometry.translate_xy"><code class="xref py py-meth docutils literal notranslate"><span class="pre">translate_xy()</span></code></a></p>
</div>
</dd></dl>
<dl class="function">
<dt id="geometry.translate_xy">
<code class="sig-name descname">translate_xy</code><span class="sig-paren">(</span><em class="sig-param">vec</em>, <em class="sig-param">x</em>, <em class="sig-param">y</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry.html#translate_xy"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry.translate_xy" title="Permalink to this definition"></a></dt>
<dd><p>Translate a point or polygon by a given vector.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>vec</strong> (<em>tuple</em>) – translation vector</p></li>
<li><p><strong>x</strong> (<em>int</em><em> or </em><em>float</em><em> or </em><em>list</em>) – points to translate</p></li>
<li><p><strong>y</strong> (<em>int</em><em> or </em><em>float</em><em> or </em><em>list</em>) – points to translate</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>(x’, y’)</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>tuple</p>
</dd>
</dl>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#geometry.translate" title="geometry.translate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">translate()</span></code></a></p>
</div>
</dd></dl>
</div>
@@ -291,7 +456,7 @@ origin. The angle should be given in degrees.</p>
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
|

118
docs/build/html/geometry_plot.html vendored Normal file
View File

@@ -0,0 +1,118 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta charset="utf-8" />
<title>geometry_plot module &#8212; pylib 2019.5.19 documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<link rel="stylesheet" href="_static/custom.css" type="text/css" />
<script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<script type="text/javascript" src="_static/language_data.js"></script>
<script async="async" type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" />
<link rel="stylesheet" href="_static/custom.css" type="text/css" />
<meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
</head><body>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<div class="section" id="module-geometry_plot">
<span id="geometry-plot-module"></span><h1>geometry_plot module<a class="headerlink" href="#module-geometry_plot" title="Permalink to this headline"></a></h1>
<p>2D geometry plotter using matplotlib (pylab).</p>
<dl class="field-list simple">
<dt class="field-odd">Date</dt>
<dd class="field-odd"><p>2019-08-20</p>
</dd>
</dl>
<span class="target" id="module-geometry_plot"></span><dl class="function">
<dt id="geometry_plot.plot_cubic_lines">
<code class="sig-name descname">plot_cubic_lines</code><span class="sig-paren">(</span><em class="sig-param">lns</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry_plot.html#plot_cubic_lines"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry_plot.plot_cubic_lines" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="function">
<dt id="geometry_plot.plot_lines">
<code class="sig-name descname">plot_lines</code><span class="sig-paren">(</span><em class="sig-param">lns</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/geometry_plot.html#plot_lines"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#geometry_plot.plot_lines" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="index.html">pylib</a></h1>
<h3>Navigation</h3>
<div class="relations">
<h3>Related Topics</h3>
<ul>
<li><a href="index.html">Documentation overview</a><ul>
</ul></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
<h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="search.html" method="get">
<input type="text" name="q" aria-labelledby="searchlabel" />
<input type="submit" value="Go" />
</form>
</div>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="footer">
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
|
<a href="_sources/geometry_plot.rst.txt"
rel="nofollow">Page source</a>
</div>
</body>
</html>

2
docs/build/html/index.html vendored
View File

@@ -97,7 +97,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
|

3
docs/build/html/modules.html vendored
View File

@@ -39,6 +39,7 @@
<li class="toctree-l1"><a class="reference internal" href="data.html">data module</a></li>
<li class="toctree-l1"><a class="reference internal" href="date.html">date module</a></li>
<li class="toctree-l1"><a class="reference internal" href="geometry.html">geometry module</a></li>
<li class="toctree-l1"><a class="reference internal" href="geometry_plot.html">geometry_plot module</a></li>
<li class="toctree-l1"><a class="reference internal" href="numerical.html">numerical package</a><ul>
<li class="toctree-l2"><a class="reference internal" href="numerical.html#submodules">Submodules</a></li>
<li class="toctree-l2"><a class="reference internal" href="numerical.html#module-numerical.fit">numerical.fit module</a></li>
@@ -104,7 +105,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
|

2
docs/build/html/numerical.html vendored
View File

@@ -569,7 +569,7 @@ equations.</p>
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
|

BIN
docs/build/html/objects.inv vendored
View File

Binary file not shown.

7
docs/build/html/py-modindex.html vendored
View File

@@ -82,6 +82,11 @@
<td>
<a href="geometry.html#module-geometry"><code class="xref">geometry</code></a> <em>(*nix, Windows)</em></td><td>
<em>Geometry objects.</em></td></tr>
<tr>
<td></td>
<td>
<a href="geometry_plot.html#module-geometry_plot"><code class="xref">geometry_plot</code></a> <em>(*nix, Windows)</em></td><td>
<em>Geometry plotting.</em></td></tr>
<tr class="pcap"><td></td><td>&#160;</td><td></td></tr>
<tr class="cap" id="cap-i"><td></td><td>
<strong>i</strong></td><td></td></tr>
@@ -193,7 +198,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

4
docs/build/html/search.html vendored
View File

@@ -52,7 +52,7 @@
containing fewer words won't appear in the result list.
</p>
<form action="" method="get">
<input type="text" name="q" value="" />
<input type="text" name="q" aria-labelledby="search-documentation" value="" />
<input type="submit" value="search" />
<span id="search-progress" style="padding-left: 10px"></span>
</form>
@@ -101,7 +101,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>

2
docs/build/html/searchindex.js vendored
View File

File diff suppressed because one or more lines are too long

2
docs/build/html/time_of_day.html vendored
View File

@@ -267,7 +267,7 @@
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.1.2</a>
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.0</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
|

7
docs/source/geometry_plot.rst Normal file
View File

@@ -0,0 +1,7 @@
geometry\_plot module
=====================
.. automodule:: geometry_plot
:members:
:undoc-members:
:show-inheritance:

1
docs/source/modules.rst
View File

@@ -7,5 +7,6 @@ src
data
date
geometry
geometry_plot
numerical
time_of_day

17
src/data.py
View File

@@ -103,6 +103,23 @@ def store(file_name, object_data):
# every dump needs a load
pickle.dump(object_data, output, pickle.HIGHEST_PROTOCOL)
def fold_list(lst, n):
"""Convert one-dimensional kx1 array (list) to two-dimensional mxn
array. m = k / n
:param lst: list to convert
:type lst: list
:param n: length of the second dimenson
:type n: int
:returns: two-dimensional array (list of lists)
:rtype: list
"""
k = len(lst)
if k % n == 0:
length = int(k/n)
return [lst[i*n:i*n+n] for i in range(length)]
def unique_ending(ids, n=1):
"""From id list get list with unique ending.

332
src/geometry.py
View File

@@ -2,12 +2,12 @@
# -*- coding: utf-8 -*-
"""2D geometry objects.
:Date: 2019-03-21
:Date: 2019-08-20
.. module:: geometry
:platform: *nix, Windows
:synopsis: Geometry objects.
.. moduleauthor:: Daniel Weschke <daniel.weschke@directbox.de>
"""
import math
@@ -23,14 +23,51 @@ def translate(vec, *pts):
:returns: (point_x, point_y) or (point1, point2, ...)
:rtype: tuple
.. seealso::
:meth:`translate_xy`
"""
vx, vy = vec
return tuple([(x+vx, y+vy) for (x, y) in pts])
def translate_xy(vec, x, y):
"""Translate a point or polygon by a given vector.
:param vec: translation vector
:type vec: tuple
:param x: points to translate
:type x: int or float or list
:param y: points to translate
:type y: int or float or list
:returns: (x', y')
:rtype: tuple
.. seealso::
:meth:`translate`
"""
vx, vy = vec
if not hasattr(x, "__len__"):
x = [x]
if not hasattr(y, "__len__"):
y = [y]
xp = [xi+vx for xi in x]
yp = [yi+vy for yi in y]
# no list if it is only one value
if len(xp) == 1:
return xp[0], yp[0]
return xp, yp
def rotate(origin, angle, *pts, **kwargs):
"""Rotate a point or polygon counterclockwise by a given angle around a given
origin. The angle should be given in radians.
"""Rotate a point or polygon counterclockwise by a given angle
around a given origin. The angle should be given in radians.
:param origin: the center of rotation
:type origin: tuple
@@ -41,17 +78,21 @@ def rotate(origin, angle, *pts, **kwargs):
:returns: (point_x, point_y) or (point1, point2, ...)
:rtype: tuple
.. seealso::
:meth:`rotate_xy`
"""
ox, oy = origin
# add first point to the end
if kwargs is not None and "closed" in kwargs and kwargs["closed"] is True:
if "closed" in kwargs and kwargs["closed"] is True:
pts += (pts[0],)
result = tuple([(ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy),
oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy))
for (px, py) in pts])
# no tuple in tuple if it is only one point
if len(pts) == 1:
return result[0][0], result[0][1]
@@ -59,8 +100,8 @@ def rotate(origin, angle, *pts, **kwargs):
def rotate_deg(origin, angle, *pts, **kwargs):
"""Rotate a point or polygon counterclockwise by a given angle around a given
origin. The angle should be given in degrees.
"""Rotate a point or polygon counterclockwise by a given angle
around a given origin. The angle should be given in degrees.
:param origin: the center of rotation
:type origin: tuple
@@ -78,13 +119,56 @@ def rotate_deg(origin, angle, *pts, **kwargs):
return rotate(origin, angle*math.pi/180, *pts, **kwargs)
def rotate_xy(origin, angle, x, y, **kwargs):
"""Rotate x and y coordinates counterclockwise by a given angle
around a given origin. The angle should be given in radians.
:param origin: the center of rotation
:type origin: tuple
:param angle: the rotation angle
:type angle: int or float
:param x: x coordinates
:type x: int or float or list
:param y: y coordinates
:type y: int or float or list
:param `**kwargs`: options
.. seealso::
:meth:`rotate`
"""
ox, oy = origin
if not hasattr(x, "__len__"):
x = [x]
if not hasattr(y, "__len__"):
y = [y]
# add first point to the end
if "closed" in kwargs and kwargs["closed"] is True:
x.append(x[0])
y.append(y[0])
x_result = [ox + math.cos(angle) * (xi - ox) - math.sin(angle) * (yi - oy)
for xi, yi in zip(x, y)]
y_result = [oy + math.sin(angle) * (xi - ox) + math.cos(angle) * (yi - oy)
for xi, yi in zip(x, y)]
# no list if it is only one value
if len(x_result) == 1:
return x_result[0], y_result[0]
return x_result, y_result
def rectangle(width, height):
"""\
:param width: the width of the rectangle
:type width: int or float
:param height: the height of the rectangle
:type height: int or float
:returns: (point1, point2, point3, point4)
:rtype: tuple
"""
@@ -99,7 +183,7 @@ def square(width):
"""\
:param width: the edge size of the square
:type width: int or float
:returns: (point1, point2, point3, point4)
:rtype: tuple
@@ -109,36 +193,222 @@ def square(width):
return rectangle(width, width)
def lines(pts, **kwargs):
"""Lines defined by a list of end points.
:param pts: list of points in absolute global coordinate system. If
keyword inc is given than the inc decides what the left and the
right end point of the line is, otherwise it is assumed that the
points build a solid line, that is lines between the given points
in given order.
:type pts: list
:param `**kwargs`: options:
* deformation -- list of points. Additional deformation
(translation) at point.
* factor -- factor of the deformation (default = 1).
* inc -- the incidence table, a list of 2 element lists. The inc
decides what the left and the right end point of the line is.
* index_offset -- starting index of lists (default = 0).
:returns: list of endpoints for each line;
[((point1_x, point1_y), (point2_x, point2_y)),
(p1, p2),
...]
:rtype: list
.. seealso::
:meth:`~geometry_plot.plot_lines` of the :mod:`geometry_plot`
module to plot the lines
"""
if 'index_offset' not in kwargs:
kwargs['index_offset'] = 0
if 'deformation' in kwargs:
if 'factor' not in kwargs:
kwargs['factor'] = 1
pts = [(p[0]+d[0]*kwargs['factor'], p[1]+d[1]*kwargs['factor']) for
p, d in zip(pts, kwargs['deformation'])]
if 'inc' in kwargs:
return [(pts[l-kwargs['index_offset']],
pts[r-kwargs['index_offset']]) for l, r in kwargs['inc']]
return list(zip(pts[:-1], pts[1:]))
def cubics(pts, **kwargs):
"""Cubic lines defined by a list of two end points. The deformation
as displacement and rotation (radians) is defined element wise as
keyword argument deformation or global node wise as
global_deformation. The global coordinate system is xy. x in the
right direction and y in the top direction.
:param pts: list of points in absolute global coordinate system. If
keyword inc is given than the inc decides what the left and the
right end point of the line is, otherwise it is assumed that the
points build a solid line, that is lines between the given points
in given order.
:type pts_rot: list
:param `**kwargs`: options:
* deformation -- list of deformation element wise. Additional
deformation (translation and rotation in radians) at element
left and right node.
* rotation_plane -- rotation plane of the element wise
deformation defined by a string; either 'xy' or 'xz' (default
= 'xy'). x in the right direction and y in the top direction
or z in the bottom direction.
* global_deformation -- list of deformation global node wise.
Additional deformation (horizontal translation, vertical
translation and rotation in radians) at node.
* factor -- factor of the derformation (default = 1).
* inc -- the incidence table, a list of 2 element lists. The inc
decides what the left and the right end point of the line is.
* index_offset -- starting index of lists (default = 0).
:returns: list of endpoints for each line;
[(((point1_x, point1_y) angle1), ((point2_x, point2_y), angle2),
(p1, angle1, p2, angle2),
...]
:rtype: list
"""
if 'index_offset' not in kwargs:
kwargs['index_offset'] = 0
if 'deformation' in kwargs or 'global_deformation' in kwargs:
if 'factor' not in kwargs:
kwargs['factor'] = 1
if 'inc' in kwargs:
if 'global_deformation' in kwargs:
lr = [(pts[l-kwargs['index_offset']],
pts[r-kwargs['index_offset']]) for l, r in kwargs['inc']]
ang = [math.atan2(r[1]-l[1], r[0]-l[0]) for l, r in lr]
# system deformation
U = kwargs['global_deformation']
if 'rotation_plane' in kwargs and 'xz' == kwargs['rotation_plane']:
# system deformation left X Z RY right X Z RY element wise
# Z downwards -> convert to X Y RZ
Ue = [[ U[(l-kwargs['index_offset'])][0],
-U[(l-kwargs['index_offset'])][1],
U[(l-kwargs['index_offset'])][2],
U[(r-kwargs['index_offset'])][0],
-U[(r-kwargs['index_offset'])][1],
U[(r-kwargs['index_offset'])][2]] for l, r in kwargs['inc']]
else:
# system deformation left X Y RZ right X Y RZ element wise
Ue = [[U[(l-kwargs['index_offset'])][0],
U[(l-kwargs['index_offset'])][1],
U[(l-kwargs['index_offset'])][2],
U[(r-kwargs['index_offset'])][0],
U[(r-kwargs['index_offset'])][1],
U[(r-kwargs['index_offset'])][2]] for l, r in kwargs['inc']]
# element deformation, X Y RZ to x r rz
# back transformation T^T = [[c, s, 0], [-s, c, 0], [0, 0, 1]]
u = [[( math.cos(angi)*Uei[0]+math.sin(angi)*Uei[1])*kwargs['factor'],
(-math.sin(angi)*Uei[0]+math.cos(angi)*Uei[1])*kwargs['factor'],
Uei[2] *kwargs['factor'],
( math.cos(angi)*Uei[3]+math.sin(angi)*Uei[4])*kwargs['factor'],
(-math.sin(angi)*Uei[3]+math.cos(angi)*Uei[4])*kwargs['factor'],
Uei[5] *kwargs['factor']]
for Uei, angi in zip(Ue, ang)]
else: # deformation
# the deformation is in element coordinate system, therefore the angle is needed
if 'rotation_plane' in kwargs and 'xz' == kwargs['rotation_plane']:
u = [[ ue[0]*kwargs['factor'],
-ue[1]*kwargs['factor'],
ue[2]*kwargs['factor'],
ue[3]*kwargs['factor'],
-ue[4]*kwargs['factor'],
ue[5]*kwargs['factor']] for ue in kwargs['deformation']]
else:
u = [[ui*kwargs['factor'] for ui in ue] for ue in kwargs['deformation']]
return [(pts[l-kwargs['index_offset']],
pts[r-kwargs['index_offset']],
d) for (l, r), d in zip(kwargs['inc'], u)]
return list(zip(pts[:-1], pts[1:]))
def interpolate_hermite(lvd, lr, rvd, rr, lhd=0, rhd=0, scale_x=1, scale_y=1, samples=10):
r"""Interpolate cubic line with hermite boundary conditions.
:param lvd: left vertcal deflection
:type lvd: int or float
:param lr: left rotation
:type lr: int or float
:param rvd: right vertical deflection
:type rvd: int or float
:param rr: right rotation
:type rr: int or float
:param lhd: left horizontal deformation (default = 0)
:type lhd: int or float
:param rhd: right horizontal deformation (default = 0)
:type rhd: int or float
:param scale_x: length of element (default = 1)
:type scale_x: int or float
:param scale_y: factor of the deformation (default = 1).
This does not change the length.
:type scale_y: int or float
:param samples: number of sampling points (default = 10)
:type samples: int
.. math::
s = \frac{x - x_1}{L} \\
x = s\,L + x_1
"""
L = scale_x
Lp = L + rhd - lhd
# x=[0,1] in non-dimensional coordinates
x = np.linspace(0, 1, num=samples)
N1 = 1 - 3*x**2 + 2*x**3
N2 = ( x - 2*x**2 + x**3)*Lp
N3 = 3*x**2 - 2*x**3
N4 = ( - x**2 + x**3)*Lp
x = x*Lp
# x=[0,L] in global coordinates
x = np.linspace(0, Lp, num=samples)
N1 = 1 - 3*x**2/Lp**2 + 2*x**3/Lp**3
N2 = x - 2*x**2/Lp + x**3/Lp**2
N3 = 3*x**2/Lp**2 - 2*x**3/Lp**3
N4 = - x**2/Lp + x**3/Lp**2
v = N1*lvd + N2*lr + N3*rvd + N4*rr
x = x + lhd
y = v*scale_y
return x, y
#
# matplotlib format, return lists for x and y
#
def points(*pts):
"""\
:param `*pts`: points to rearrange
:returns: ((point1_x, point2_x), (point1_y, point2_y), ...)
:rtype: tuple
"""
return zip(*pts)
def line(point1, point2, samples=2):
"""\
"""Line defined by two end points.
.. math::
y = \\frac{y_2-y_1}{x_2-x_1}(x-x_1) + y_1
:param point1: one end point
:type point1: tuple
:param point2: other end point
:type point2: tuple
:param samples: number of sampling points
:param samples: number of sampling points (default = 2)
:type samples: int
:returns: ((point1_x, point2_x), (points1_y, point2_y)) or
([sample_point1_x, sample_point2_x, ...],
[sample_points1_y, sample_point2_y, ...])
:rtype: tuple
:Example:
>>> x, y = line((0, 0), (1, 0))
>>> print(x, y)
((0, 1), (0, 0))
"""
p1x, p1y = point1
p2x, p2y = point2
@@ -146,7 +416,7 @@ def line(point1, point2, samples=2):
denominator = (p1x - p2x)
if samples > 2 and denominator > 0:
x = np.linspace(p1x, p2x)
x = np.linspace(p1x, p2x, samples)
a = (p1y - p2y) / denominator
b = (p1x*p2y - p2x*p1y) / denominator
y = a*x + b
@@ -154,8 +424,10 @@ def line(point1, point2, samples=2):
return (p1x, p2x), (p1y, p2y) # matplotlib format
def cubic(point1, angle1, point2, angle2, samples=50):
"""\
def cubic(point1, angle1, point2, angle2, samples=10):
"""Cubic line defined by two end points and the rotation in radians
at the points.
:param point1: one end point
:type point1: tuple
:param angle1: the slope at the one end point
@@ -164,9 +436,9 @@ def cubic(point1, angle1, point2, angle2, samples=50):
:type point2: tuple
:param angle2: the slope at the other end point
:type angle2: int or float
:param samples: number of sampling points
:param samples: number of sampling points (default = 10)
:type samples: int
:returns: ([sample_point1_x, sample_point2_x, ...],
[sample_points1_y, sample_point2_y, ...])
:rtype: tuple
@@ -187,7 +459,9 @@ def cubic(point1, angle1, point2, angle2, samples=50):
def cubic_deg(point1, angle1, point2, angle2):
"""\
"""Cubic line defined by two end points and the roation in degree
at the points.
:param point1: one end point
:type point1: tuple
:param angle1: the slope at the one end point
@@ -196,7 +470,7 @@ def cubic_deg(point1, angle1, point2, angle2):
:type point2: tuple
:param angle2: the slope at the other end point
:type angle2: int or float
:returns: ([sample_point1_x, sample_point2_x, ...],
[sample_points1_y, sample_point2_y, ...])
:rtype: tuple

84
src/geometry_plot.py Normal file
View File

@@ -0,0 +1,84 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""2D geometry plotter using matplotlib (pylab).
:Date: 2019-08-20
.. module:: geometry_plot
:platform: *nix, Windows
:synopsis: Geometry plotting.
.. moduleauthor:: Daniel Weschke <daniel.weschke@directbox.de>
"""
import math
import pylab
from geometry import line, interpolate_hermite, rotate_xy, translate_xy
pylab.style.use('dark_background')
pylab.rcParams['grid.color'] = 'gray'
# The kwargs are Line2D properties:
# https://matplotlib.org/3.1.1/_modules/matplotlib/lines.html#Line2D
# https://matplotlib.org/devdocs/_modules/matplotlib/lines.html#Line2D
pylab_Line2D_properties = [
'linewidth', 'linestyle', 'color',
'marker', 'markersize', 'markeredgewidth', 'markeredgecolor',
'markerfacecolor', 'markerfacecoloralt',
'fillstyle', 'antialiased',
'dash_capstyle', 'solid_capstyle',
'dash_joinstyle', 'solid_joinstyle',
'pickradius', 'drawstyle', 'markevery',
]
def plot_lines(lns, **kwargs):
if 'color' not in kwargs:
# Colors from "tab10" colormap
cmap = pylab.get_cmap("tab10")
kwargs['color'] = cmap(0)
# Colors from color cycle
cycle = pylab.rcParams['axes.prop_cycle'].by_key()['color']
kwargs['color'] = cycle[0]
# Colors from CN notation (same as the first 10 colors from the color cycle)
kwargs['color'] = "C0"
for ln in lns:
x, y = line(*ln)
pylab.plot(x, y, **kwargs)
def plot_cubic_lines(lns, **kwargs):
if 'color' not in kwargs:
# Colors from "tab10" colormap
cmap = pylab.get_cmap("tab10")
kwargs['color'] = cmap(0)
# Colors from color cycle
cycle = pylab.rcParams['axes.prop_cycle'].by_key()['color']
kwargs['color'] = cycle[0]
# Colors from CN notation (same as the first 10 colors from the color cycle)
kwargs['color'] = "C0"
factor = 1
if 'factor' in kwargs:
factor = kwargs['factor']
samples = 10
if 'samples' in kwargs:
samples = kwargs['samples']
kwargs = {k: v for k, v in kwargs.items() if k in pylab_Line2D_properties}
for ln in lns:
l, r, d = ln
L = math.sqrt((r[0]-l[0])**2 + (r[1]-l[1])**2)
ang = math.atan2(r[1]-l[1], r[0]-l[0])
x, y = interpolate_hermite(d[1], d[2], d[4], d[5], d[0], d[3],
scale_x=L, scale_y=factor, samples=samples)
x, y = rotate_xy((0, 0), ang, x, y)
x, y = translate_xy(l, x, y)
pylab.plot(x, y, **kwargs)

18
tests/test_fit.py
View File

@@ -24,11 +24,11 @@ class TestFit(unittest.TestCase):
"""test function"""
file_name = "test_fit.dat"
x, y = data_read(file_name, 3, 2)
subplot(2,2,1)
subplot(2, 2, 1)
plot(x, y, '.-')
subplot(2,2,2)
subplot(2, 2, 2)
dx = x[1] - x[0]
dydx = gradient(y, dx) # central differences
x_fit = linspace(x[0], x[-1], 150 if len(x) < 50 else len(x)*3)
@@ -36,16 +36,16 @@ class TestFit(unittest.TestCase):
plot(x, dydx, '.-')
plot(x_fit, y_fit, 'r:')
title('FWHM: %f' % FWHM)
subplot(2,2,3)
subplot(2, 2, 3)
plot(x, y, '.-')
xlim(popt[1]-2*FWHM, popt[1]+2*FWHM)
subplot(2,2,4)
subplot(2, 2, 4)
plot(x, dydx, '.-')
plot(x_fit, y_fit, 'r:')
xlim(popt[1]-2*FWHM, popt[1]+2*FWHM)
show()
self.assertEqual(FWHM, 0.12975107355013618)

259
tests/test_geometry.py Normal file
View File

@@ -0,0 +1,259 @@
"""Test of geometry module.
:Date: 2019-08-20
.. module:: test_geometry
:platform: *nix, Windows
:synopsis: Test of geometry module.
.. moduleauthor:: Daniel Weschke <daniel.weschke@directbox.de>
"""
import unittest
import os
import sys
import math
from numpy import allclose
sys.path.insert(0, os.path.abspath('../src'))
from data import fold_list
from geometry import translate_xy, rotate_xy, interpolate_hermite, lines, cubics
from geometry_plot import plot_lines, plot_cubic_lines
class TestGeometry(unittest.TestCase):
global_points = [(0, 0),
(0, 3),
(3, 3),
(3, 0),
(3, 6),
(5, 6),
(5, 3),
(5, 0),
(7, 0)]
inc = [[1, 2],
[2, 3],
[4, 3],
[3, 5],
[5, 6],
[6, 7],
[7, 8],
[9, 7]]
# global deformation, horizontal right, vertical down, rotation
U = [
0.00000, 0.00000, -5.02012,
12.77012, 0.06333, -2.72988,
12.69350, 0.08599, 3.14685,
0.00000, 0.00000, -7.92017,
-12.39817, 0.17450, 4.14446,
-12.43490, 0.32001, -3.10697,
-26.77684, 0.16528, 2.98214,
0.00000, 0.00000, 0.00000,
-26.50991, 0.00000, -1.36053,
]
U = [Ui/1000 for Ui in U]
# global deformation, only horizontal right and vertical down
U2 = [ui for i, ui in enumerate(U) if i%3 != 2]
# global deformation, horizontal right, vertical up, rotation
UN = [Ui if i%3 != 1 else -Ui for i, Ui in enumerate(U)]
# local deformation, horizontal right, vertical down, rotation
u = [
[ 0.000000, 0.000000, -0.005020, -0.000063, 0.012770, -0.002730],
[ 0.012770, 0.000063, -0.002730, 0.012693, 0.000086, 0.003147],
[ 0.000000, 0.000000, -0.007920, -0.000086, 0.012693, 0.003147],
[-0.000086, 0.012693, 0.003147, -0.000175, -0.012398, 0.004144],
[-0.012398, 0.000175, 0.004144, -0.012435, 0.000320, -0.003107],
[ 0.000320, 0.012435, -0.003107, 0.000165, 0.026777, 0.002982],
[ 0.000165, 0.026777, 0.002982, 0.000000, 0.000000, 0.000000],
[ 0.014705, -0.022058, -0.001361, 0.014716, -0.022371, 0.002982],
]
# local deformation, horizontal right, vertical up, rotation
uN = [[uii if i%3 != 1 else -uii for i, uii in enumerate(ui)] for ui in u]
# exaggeration factor for the deformation
factor = 20
# test of cubic lines
test_lns_l = [((0, 0), (0, 3), [0.0, -0.0, -0.1004, -0.00126, -0.2554, -0.0546]),
((0, 3), (3, 3), [0.2554, -0.00126, -0.0546, 0.25386, -0.00172, 0.06294]),
((3, 0), (3, 3), [0.0, -0.0, -0.1584, -0.00172, -0.25386, 0.06294]),
((3, 3), (3, 6), [-0.00172, -0.25386, 0.06294, -0.0035, 0.24796, 0.08288]),
((3, 6), (5, 6), [-0.24796, -0.0035, 0.08288, -0.2487, -0.0064, -0.06214]),
((5, 6), (5, 3), [0.0064, -0.2487, -0.06214, 0.0033, -0.53554, 0.05964]),
((5, 3), (5, 0), [0.0033, -0.53554, 0.05964, 0.0, -0.0, 0.0]),
((7, 0), (5, 3), [0.2941, 0.44116, -0.02722, 0.29432, 0.44742, 0.05964])]
test_lns_g = [((0, 0), (0, 3), [0.0, -0.0, -0.1004024, -0.0012666, -0.2554024, -0.0545976]),
((0, 3), (3, 3), [0.2554024, -0.0012666, -0.0545976, 0.25387, -0.0017198, 0.062937]),
((3, 0), (3, 3), [0.0, -0.0, -0.1584034, -0.0017198, -0.25387, 0.062937]),
((3, 3), (3, 6), [-0.0017198, -0.25387, 0.062937, -0.00349, 0.2479634, 0.0828892]),
((3, 6), (5, 6), [-0.2479634, -0.00349, 0.0828892, -0.248698, -0.0064002, -0.0621394]),
((5, 6), (5, 3), [0.0064002, -0.248698, -0.0621394, 0.0033056, -0.5355368, 0.0596428]),
((5, 3), (5, 0), [0.0033056, -0.5355368, 0.0596428, 0.0, 0.0, 0.0]),
((7, 0), (5, 3), [0.2941010455782632, 0.441151568367395, -0.0272106, 0.29431194259286797, 0.4474271690373891, 0.0596428])]
def test_lines(self):
"""test lines function (undeformed structure)"""
lns = lines(self.global_points, inc=self.inc, index_offset=1)
test = [((0, 0), (0, 3)), ((0, 3), (3, 3)), ((3, 0), (3, 3)),
((3, 3), (3, 6)), ((3, 6), (5, 6)), ((5, 6), (5, 3)),
((5, 3), (5, 0)), ((7, 0), (5, 3))]
self.assertEqual(lns, test)
plot_lines(lns, linestyle=':')
def test_lines_deformation(self):
"""test lines function with deformation (deformed structure)"""
lns = lines(self.global_points, deformation=fold_list(self.U2, 2), factor=self.factor, inc=self.inc, index_offset=1)
test = [((0.0, 0.0), (0.25540240000000003, 3.0012666)), ((0.25540240000000003, 3.0012666), (3.25387, 3.0017198)), ((3.0, 0.0), (3.25387, 3.0017198)), ((3.25387, 3.0017198), (2.7520366, 6.00349)), ((2.7520366, 6.00349), (4.751302, 6.0064002)), ((4.751302, 6.0064002), (4.4644632, 3.0033056)), ((4.4644632, 3.0033056), (5.0, 0.0)), ((6.4698018, 0.0), (4.4644632, 3.0033056))]
self.assertEqual(lns, test)
plot_lines(lns, color='C2')
def test_translate_xy(self):
"""test translate_xy function with single values"""
x = 2
y = 4
xp, yp = translate_xy((0.5, 1), x, y)
xt = 2.5
yt = 5
self.assertEqual(xp, xt)
self.assertEqual(yp, yt)
def test_translate_xy_list(self):
"""test translate_xy function"""
x = [ 0. , 0.33333333, 0.66666667, 1. , 1.33333333,
1.66666667, 2. , 2.33333333, 2.66666667, 3. ]
y = [ 6.30000000e-05, -7.58828532e-04, -1.39770233e-03,
-1.84370370e-03, -2.08691495e-03, -2.11741838e-03,
-1.92529630e-03, -1.50063100e-03, -8.33504801e-04,
8.60000000e-05]
xp, yp = translate_xy((1, 0.001), x, y)
xt = [1.0,
1.3333333333333333,
1.6666666666666665,
2.0,
2.333333333333333,
2.666666666666667,
3.0,
3.333333333333333,
3.6666666666666665,
4.0]
yt = [0.0010629999999999999,
0.00024117146776406044,
-0.00039770233196159102,
-0.0008437037037037035,
-0.0010869149519890263,
-0.0011174183813443071,
-0.00092529629629629624,
-0.00050063100137174286,
0.0001664951989026062,
0.0010859999999999999]
self.assertTrue(allclose(xp, xt))
self.assertTrue(allclose(yp, yt))
def test_rotate_xy(self):
"""test translate_xy function with single values"""
x = 2
y = 4
xp, yp = rotate_xy((0.5, 1), math.pi/2, x, y)
xt = -2.5
yt = 2.5
self.assertEqual(xp, xt)
self.assertEqual(yp, yt)
def test_rotate_xy_list(self):
"""test translate_xy function"""
x = [ 0. , 0.33333333, 0.66666667, 1. , 1.33333333,
1.66666667, 2. , 2.33333333, 2.66666667, 3. ]
y = [ 6.30000000e-05, -7.58828532e-04, -1.39770233e-03,
-1.84370370e-03, -2.08691495e-03, -2.11741838e-03,
-1.92529630e-03, -1.50063100e-03, -8.33504801e-04,
8.60000000e-05]
xp, yp = rotate_xy((0, 0), math.pi/2, x, y)
xt = [-6.3e-05,
0.00075882853223595997,
0.0013977023319616318,
0.0018437037037037647,
0.0020869149519891078,
0.002117418381344409,
0.0019252962962964188,
0.0015006310013718858,
0.0008335048010975571,
-8.5999999999816312e-05]
yt = [3.8576374173141622e-21,
0.33333333333333331,
0.66666666666666663,
1.0,
1.3333333333333333,
1.6666666666666667,
2.0,
2.333333333333333,
2.6666666666666665,
3.0]
self.assertTrue(allclose(xp, xt))
self.assertTrue(allclose(yp, yt))
def test_interpolate_hermite(self):
"""test translate_xy function"""
# u:
# - left side displacement to right
# - left side rotation counterclockwise
# - right side displacement to right
# - right side rotation counterclockwise
u = [ 0.012770, 0.000063, -0.002730, 0.012693, 0.000086, 0.003147]
x, y = interpolate_hermite(u[1], u[2], u[4], u[5], scale_x=3)
xt = [ 0. , 0.33333333, 0.66666667, 1. , 1.33333333,
1.66666667, 2. , 2.33333333, 2.66666667, 3. ]
yt = [ 6.30000000e-05, -7.58828532e-04, -1.39770233e-03,
-1.84370370e-03, -2.08691495e-03, -2.11741838e-03,
-1.92529630e-03, -1.50063100e-03, -8.33504801e-04,
8.60000000e-05]
self.assertTrue(allclose(x, xt))
self.assertTrue(allclose(y, yt))
def test_cubics_deformation_xz(self):
"""test cubics function with (local) deformation"""
lns = cubics(self.global_points, deformation=self.u, rotation_plane='xz', factor=self.factor, inc=self.inc, index_offset=1)
for l, t in zip(lns, self.test_lns_l):
self.assertEqual(l[0], t[0]) # left point
self.assertEqual(l[1], t[1]) # right point
#self.assertEqual(l[2], t[2]) # deformation
self.assertTrue(allclose(l[2], t[2]))
plot_cubic_lines(lns, color='C3', samples=40)
def test_cubics_deformation_xy(self):
"""test cubics function with (local) deformation"""
lns = cubics(self.global_points, deformation=self.uN, rotation_plane='xy', factor=self.factor, inc=self.inc, index_offset=1)
for l, t in zip(lns, self.test_lns_l):
self.assertEqual(l[0], t[0]) # left point
self.assertEqual(l[1], t[1]) # right point
#self.assertEqual(l[2], t[2]) # deformation
self.assertTrue(allclose(l[2], t[2]))
plot_cubic_lines(lns, color='C3', samples=40)
def test_cubics_global_deformation_xz(self):
"""test cubics function with global_deformation"""
lns = cubics(self.global_points, global_deformation=fold_list(self.U, 3), rotation_plane='xz', factor=self.factor, inc=self.inc, index_offset=1)
for l, t in zip(lns, self.test_lns_g):
self.assertEqual(l[0], t[0]) # left point
self.assertEqual(l[1], t[1]) # right point
#self.assertEqual(l[2], t[2]) # deformation
self.assertTrue(allclose(l[2], t[2]))
plot_cubic_lines(lns, color='C4', samples=40)
def test_cubics_global_deformation_xy(self):
"""test cubics function with global_deformation"""
lns = cubics(self.global_points, global_deformation=fold_list(self.UN, 3), rotation_plane='xy', factor=self.factor, inc=self.inc, index_offset=1)
for l, t in zip(lns, self.test_lns_g):
self.assertEqual(l[0], t[0]) # left point
self.assertEqual(l[1], t[1]) # right point
#self.assertEqual(l[2], t[2]) # deformation
self.assertTrue(allclose(l[2], t[2]))
plot_cubic_lines(lns, color='C4', samples=40)
if __name__ == '__main__':
unittest.main()