Posts by Tell

import numpy as np

WILLYCONST = 0.25

table = np.array( [
51000.0,
10000.0,
6000.0,
8250.0,
4047.619,
3538.462,
3000.0,
2853.659,
2717.391,
2647.059,
2553.571,
2475.41,
2439.409,
2492.972,
2342.118,
2308.642,
2244.186,
2208.791,
2020.844,
2257.426,
2084.906,
2117.117,
2051.724,
2024.793,
2095.238,
2091.603,
2044.118,
2056.745,
1835.616,
2033.119,
2006.417,
1993.789,
2331.325,
1777.778,
1971.591,
1817.685,
2016.134,
1968.586,
1959.184,
2447.761,
1941.748,
1924.171,
1921.301,
1914.032,
1920.358,
1935.065,
1906.784,
1925.311,
1894.313,
1900.402,
2093.754,
1931.034,
1951.128,
46280.491,
20826.109,
1967.975,
1965.038,
1996.567,
2006.76,
30023.286,
2032.68,
2003.219,
2047.472,
2037.383,
2039.88,
2057.405,
2062.503,
2105.575,
76453.835,
2094.02,
2098.317,
2121.886,
2084.702,
2088.951,
2127.662,
2165.357,
2160.624,
16524.312,
2143.942,
2159.603,
12443.362,
2175.185,
26552.911,
2185.276,
2183.101,
2204.179,
2380.736,
2195.014,
2201.796,
2549.891,
2440.792,
2216.922,
2212.448,
2231.425,
2491.601,
40083.2,
2242.8,
2195.521,
2068.55,
1660.679,
1664.034,
1661.45,
1655.041,
1662.19,
1667.302,
1666.669,
1658.584,
1654.344,
11732.612,
1662.434,
11528.788,
1664.886,
27424.055,
1674.257,
1680.557,
1676.422,
1680.889,
1671.745,
1684.565,
10655.584,
10787.139,
1684.126,
9978.906,
1682.771,
10501.607,
1678.29,
1687.108,
1694.229,
1688.856,
1688.174,
1689.026,
1809.381,
1684.686,
1695.978,
10230.78,
2038.181,
1699.71,
1690.305,
1827.589,
1697.576,
1703.967,
1699.017,
9678.779,
1700.417,
1698.348,
9250.35,
1701.088,
1699.057,
1707.777,
1821.573,
1817.462,
1701.71,
1707.573,
1841.765,
8984.544,
8163.9,
1703.564,
1702.909,
1709.8,
1707.866,
9019.859,
1705.303,
1547.795,
1548.113,
1547.217,
1548.738,
1546.652,
1550.536,
1552.012,
1548.767,
1549.067,
11394.9,
2359.125,
1549.944,
1544.522,
1545.972,
1547.405,
7599.333,
7690.855,
1549.391,
1545.255,
1547.751,
1551.577,
10145.797,
1546.725,
1549.147,
1547.291,
11957.726,
10098.852,
2383.892,
1548.388,
1548.655,
1549.95,
7273.571,
1547.402,
1549.697,
1550.961,
1544.179
] )

m = np.polyfit( range(len(table)), table, 1 )[0]

print( m )

if m > WILLYCONST:
    result = 1
elif m < -WILLYCONST:
    result = -1
else:
    result = 0
 
print( result )

>>> import numpy as np
>>> 
>>> table = np.array( [1.0, 2.0, 3, 4, 5, 1, 1, 1, 4] )
>>> 
>>> m = np.polyfit( range(len(table)), table, 1 )[1]
>>> 
>>> WILLYCONST = 0.25
>>> 
>>> if m > WILLYCONST:
...    result = 1
... elif m < -WILLYCONST:
...    result = -1
... else:
...    result = 0
... 
>>> print( result )
1

import copy
import csv
import pathlib

import matplotlib.pyplot as plt
from matplotlib.figure import Figure

SKRIPTPFAD = pathlib.Path(__file__).parent
PFAD = r"2022-10-09 21-34-30.csv"
MAX_RUNDEN = 100


class Statistik:
    def __init__(self):
        self.angriff_hp = [[] for _ in range(MAX_RUNDEN)]
        self.angriff_schild = [[] for _ in range(MAX_RUNDEN)]
        self.angriff_abgemilderter_schaden = [[] for _ in range(MAX_RUNDEN)]
        self.angriff_gesamt = [[] for _ in range(MAX_RUNDEN)]
        self.deff_hp = [[] for _ in range(MAX_RUNDEN)]
        self.deff_schild = [[] for _ in range(MAX_RUNDEN)]
        self.deff_abgemilderter_schaden = [[] for _ in range(MAX_RUNDEN)]
        self.deff_gesamt = [[] for _ in range(MAX_RUNDEN)]

    def addiere_schaden(self, typ, wert, runde):
        index = int(runde) - 1
        wert = int(wert)

        if typ == "angriff_hp":
            self.angriff_hp[index].append(wert)
        elif typ == "angriff_schild":
            self.angriff_schild[index].append(wert)
        elif typ == "angriff_abgemilderter_schaden":
            self.angriff_abgemilderter_schaden[index].append(wert)
        elif typ == "angriff_gesamt":
            self.angriff_gesamt[index].append(wert)
        elif typ == "deff_hp":
            self.deff_hp[index].append(wert)
        elif typ == "deff_schild":
            self.deff_schild[index].append(wert)
        elif typ == "deff_abgemilderter_schaden":
            self.deff_abgemilderter_schaden[index].append(wert)
        elif typ == "deff_gesamt":
            self.deff_gesamt[index].append(wert)


def schaden_addieren(row, teilnehmer):
    angreifer = row[3]
    verteidiger = row[7]
    runde = row[0]

    if row[12] != "--":
        teilnehmer[angreifer].addiere_schaden("angriff_hp", row[12], runde)
        teilnehmer[verteidiger].addiere_schaden("deff_hp", row[12], runde)
    if row[13] != "--":
        teilnehmer[angreifer].addiere_schaden("angriff_schild", row[13], runde)
        teilnehmer[verteidiger].addiere_schaden("deff_schild", row[13], runde)
    if row[14] != "--":
        teilnehmer[angreifer].addiere_schaden(
            "angriff_abgemilderter_schaden", row[14], runde
        )
        teilnehmer[verteidiger].addiere_schaden(
            "deff_abgemilderter_schaden", row[14], runde
        )
    if row[15] != "--":
        teilnehmer[angreifer].addiere_schaden("angriff_gesamt", row[15], runde)
        teilnehmer[verteidiger].addiere_schaden("deff_gesamt", row[15], runde)

    if row[22] != "--":
        teilnehmer[angreifer].addiere_schaden("angriff_hp", 0, runde)
        teilnehmer[angreifer].addiere_schaden("angriff_schild", 0, runde)
        teilnehmer[angreifer].addiere_schaden("angriff_abgemilderter_schaden", 0, runde)
        teilnehmer[angreifer].addiere_schaden("angriff_gesamt", 0, runde)


def csv_auswerten(pfad, teilnehmer):
    bericht = False

    with open(pfad, newline="", encoding="utf-8") as csvfile:
        csv_inhalt = csv.reader(csvfile, delimiter="\t", quotechar="|")
        for row in csv_inhalt:
            print(", ".join(row))

            # der IndexError ist durch die leere Liste row ausgelöst worden
            if not row:
                continue

            if bericht:
                """
                # 'Runde'0, 'Kampf-Ereignis'1, 'Typ'2, 'Angreifername'3, 'Angreiferallianz'4, 'Angreiferschiff'5, 'Angreifer - Ist Armada?'6, 'Zielname'7, 'Zielallianz'8, 'Zielschiff'9, 'Ziel - Ist Armada?'10, 'Kritischer Treffer?'11, 'Hüllenschaden'12, 'Schildschaden'13, 'Abgemilderter Schaden'14, 'Gesamtschaden'15, 'Fähigkeitstyp'16, 'Fähigkeitswert'17, 'Fähigkeitsbezeichnung'18, 'Name der Figur mit der Fähigkeit'19, 'Ziel besiegt'20, 'Ziel zerstört'21, 'Waffen laden %'22]
                print(f"Angreifername: {row[3]}")   # Angreifername
                print(f"Ist Armada?: {row[6]}")   # Ist Armada?
                print(f"Zielname: {row[7]}")   # Zielname
                print(f"Ziel ist Armada?: {row[10]}")  # Ziel ist Armada?
                print(f"Kritischer Treffer?: {row[11]}")  # Kritischer Treffer?
                print(f"Hüllenschaden: {row[12]}")  # Hüllenschaden
                print(f"Schildschaden: {row[13]}")  # Schildschaden
                print(f"Abgemilderter Schaden: {row[14]}")  # Abgemilderter Schaden
                print(f"Gesamtschaden: {row[15]}")  # Gesamtschaden
                print(f"Ziel besiegt: {row[20]}")  # Ziel besiegt
                print(f"Ziel zerstört: {row[21]}")  # Ziel zerstört
                print(f"Waffen laden: {row[22]}")  # Waffen laden"""

                if row[3] not in teilnehmer and row[3] != "--":
                    teilnehmer.update({row[3]: Statistik()})
                if row[7] not in teilnehmer and row[7] != "--":
                    teilnehmer.update({row[7]: Statistik()})
                schaden_addieren(row, teilnehmer)
            elif "Runde" in row:
                bericht = True


def schaden_pro_runde(teilnehmer, title, name):
    c_teilnehmer = copy.deepcopy(teilnehmer)
    for spieler, statistik in c_teilnehmer.items():
        print( spieler )
        x = []
        y = []
        for runde, schaden in enumerate(getattr(statistik, name), start=1):
            x.append(runde)
            y.append(sum(schaden))
        y.reverse()
        for index, i in enumerate(y):
            if i:
                break
        y.reverse()
        y = y[:-index]
        x = x[:-index]
        plt.plot(x, y, "o", label=spieler)
    plt.title(title)
    plt.legend()
    picpfad = pathlib.Path(SKRIPTPFAD / title.replace(" ", "_").lower())
    plt.savefig(picpfad)
    plt.clf()


def gesamtschaden(teilnehmer, title, name):
    c_teilnehmer = copy.deepcopy(teilnehmer)
    labels = []
    values = []
    for spieler, statistik in c_teilnehmer.items():
        y = [sum(schaden) for schaden in getattr(statistik, name)]
        y.reverse()
        for index, i in enumerate(y):
            if i:
                break
        y.reverse()
        values.append(sum(y[:-index]))
        labels.append(spieler)
    fig, ax = plt.subplots()
    ax.pie(values, labels=labels, autopct="%1.1f%%")
    ax.axis("equal")
    ax.set(title=title)
    picpfad = pathlib.Path(SKRIPTPFAD / title.replace(" ", "_").lower())
    plt.savefig(picpfad)


def daten_auswerten(teilnehmer):
    schaden_pro_runde(teilnehmer, "Ausgeteilter Hüllenschaden pro Runde", "angriff_hp")
    schaden_pro_runde(
        teilnehmer, "Ausgeteilter Schildschaden pro Runde", "angriff_schild"
    )
    # schaden_pro_runde(teilnehmer, "Ausgeteilter Abgemilderter Schaden pro Runde", "angriff_abgemilderter_schaden")
    # schaden_pro_runde(teilnehmer, "Ausgeteilter Gesamtschaden pro Runde", "angriff_gesamt")
    # schaden_pro_runde(teilnehmer, "Genommener Hüllenschaden pro Runde", "deff_hp")
    # schaden_pro_runde(teilnehmer, "Genommener Schildschaden pro Runde", "deff_schild")
    # schaden_pro_runde(teilnehmer, "Genommener abgemilderter Schaden pro Runde", "deff_abgemilderter_schaden")
    # schaden_pro_runde(teilnehmer, "Genommener Gesamtschaden pro Runde", "deff_gesamt")

    # gesamtschaden(teilnehmer, "Ausgeteilter Hüllenschaden Gesamt", "angriff_hp")
    # gesamtschaden(teilnehmer, "Ausgeteilter Schildschaden Gesamt", "angriff_schild")
    # gesamtschaden(teilnehmer, "Ausgeteilter Abgemilderter Schaden Gesamt", "angriff_abgemilderter_schaden")
    # gesamtschaden(teilnehmer, "Ausgeteilter Gesamtschaden Gesamt", "angriff_gesamt")
    # gesamtschaden(teilnehmer, "Genommener Hüllenschaden Gesamt", "deff_hp")
    # gesamtschaden(teilnehmer, "Genommener Schildschaden Gesamt", "deff_schild")
    # gesamtschaden(teilnehmer, "Genommener abgemilderter Schaden Gesamt", "deff_abgemilderter_schaden")
    # gesamtschaden(teilnehmer, "Genommener Gesamtschaden Gesamt", "deff_gesamt")


def main():
    teilnehmer = {}
    csv_auswerten(PFAD, teilnehmer)
    daten_auswerten(teilnehmer)


if __name__ == "__main__":
    main()

from flask import Flask, render_template, jsonify
import random
import datetime

app   = Flask( __name__ )

class Item:
    def __init__( self, timestamp, value ):
        self.timestamp = timestamp
        self.value     = value

def fake_data():
    timestamp = datetime.datetime.now() - datetime.timedelta( minutes=60 )
    value     = 20
    result    = []

    for i in range(60):
        value     += random.random() * 11 - 5
        timestamp += datetime.timedelta( minutes=1 )
        result.append( Item(timestamp,value) )

    return result


@app.route( "/" )
def index():
    return render_template( "index.html", items=fake_data() )

@app.route( "/temperature" )
def temperature():
    with open( "/sys/class/thermal/thermal_zone0/temp", "r" ) as input:
        temperature = float( input.readline() ) / 1000.0

    return jsonify( {"temperature": temperature} )

<!DOCTYPE html>
<html lang="de">
 <head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="description" content="Temperatur mit Google Charts darstellen">
  <title>Temperaturverlauf mit Google Charts darstellen</title>
  <style>
   #content article div { padding: 0; }
   div#temperature { height: 40em; }
   input { margin: 0; padding: 0; width: calc( (100% - 8px) / 2); height: 2em; }
  </style>
  <script src="https://www.gstatic.com/charts/loader.js"></script>
 </head>
 <body>
  <div id="content">
   <h1>Temperaturverlauf</h1>
   </div>
   <div>
    <article>
     <h2 itemprop="name">Temperaturverlauf mit Google Charts</h2>
     <div id="temperature"></div>
     <script>
      function drawChart()
      {
         let data = new google.visualization.DataTable() ;
         data.addColumn('datetime', 'time') ;
         data.addColumn('number', 'Temperatur') ;
         data.addColumn({type: 'string', role: 'tooltip'}) ;
      
     data.addRows([
            {% for item in items %}
              [new Date({{item.timestamp.year}},{{item.timestamp.month-1}},{{item.timestamp.day}},{{item.timestamp.hour}},{{item.timestamp.minute}},0), {{ item.value }}, "{{item.timestamp}} {{item.value}}"]{%- if not loop.last -%},{% endif %}
            {% endfor %}
         ]);

         let options = {
             explorer: {
               axis: "horizontal"
             },
             chartArea: { left: "10%", top: "10%", width: "85%", height: "80%" },
             legend: "none",
             hAxis: {
               format: "kk:mm"
             },
             vAxis: {
               title: "Temperatur"
             },
             backgroundColor: "#f1f8e9"
         } ;

         let view  = new google.visualization.DataView( data ) ;
         let chart = new google.visualization.LineChart( document.getElementById('temperature') ) ;

         chart.draw( view, options ) ;
      }

      google.charts.load( 'current', {'packages':['corechart','line']} ) ;
      google.charts.setOnLoadCallback( drawChart ) ;
     </script>
    </article>
   </div>
  </div>
 </body>
</html>

<!DOCTYPE html>
<html lang="de">
 <head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="description" content="Temperatur mit Google Charts darstellen">
  <title>Temperaturverlauf mit Google Charts darstellen</title>
  <style>
   #content article div { padding: 0; }
   div#temperature { height: 40em; }
   input { margin: 0; padding: 0; width: calc( (100% - 8px) / 2); height: 2em; }
  </style>
  <script src="https://www.gstatic.com/charts/loader.js"></script>
 </head>
 <body>
  <div id="content">
   <h1>Temperaturverlauf</h1>
   </div>
   <div>
    <article>
     <h2 itemprop="name">Temperaturverlauf mit Google Charts</h2>
     <div id="temperature"></div>
     <script>
      function drawChart()
      {
         let data = new google.visualization.DataTable() ;
         data.addColumn('datetime', 'time') ;
         data.addColumn('number', 'Temperatur') ;
         data.addColumn({type: 'string', role: 'tooltip'}) ;
      
     data.addRows([
            // Diese Zeilen mit dem Jinja-Template erzeugen
            [new Date(2022,10,14,17,0),  37.8, "tooltip"],
            [new Date(2022,10,14,17,1),  30.9, "another"],
            [new Date(2022,10,14,17,2),  25.4, "tooltip"],
            [new Date(2022,10,14,17,3),  11.7, "tooltip"],
            [new Date(2022,10,14,17,4),  11.9, "tooltip"],
            [new Date(2022,10,14,17,5),   8.8, "tooltip"],
            [new Date(2022,10,14,17,6),   7.6, "tooltip"],
            [new Date(2022,10,14,17,7),  12.3, "tooltip"],
            [new Date(2022,10,14,17,8),  16.9, "tooltip"],
            [new Date(2022,10,14,17,9),  12.8, "tooltip"],
            [new Date(2022,10,14,17,10),  5.3, "tooltip"],
            [new Date(2022,10,14,17,11),  6.6, "tooltip"],
            [new Date(2022,10,14,17,12),  4.8, "tooltip"],
            [new Date(2022,10,14,17,13),  4.2, "tooltip"],
            // Diese Zeilen mit dem Jinja-Template erzeugen
         ]);

         let options = {
             explorer: {
               axis: "horizontal"
             },
             chartArea: { left: "10%", top: "10%", width: "85%", height: "80%" },
             legend: "none",
             hAxis: {
               format: "kk:mm"
             },
             vAxis: {
               title: "Temperatur"
             },
             backgroundColor: "#f1f8e9"
         } ;

         let view  = new google.visualization.DataView( data ) ;
         let chart = new google.visualization.LineChart( document.getElementById('temperature') ) ;

         chart.draw( view, options ) ;
      }

      google.charts.load( 'current', {'packages':['corechart','line']} ) ;
      google.charts.setOnLoadCallback( drawChart ) ;
     </script>
    </article>
   </div>
  </div>
 </body>
</html>