Customizing von Charts

• In PLANTA project können interaktive Charts erstellt werden, die folgende Vorteile im Vergleich zu Excel-Charts besitzen:
  • Interaktivität mit PLANTA-Systemen:
    • Zoomen der Charts
    • Dynamische Anzeige des mit der Maus berührten Chart-Wertes als Toolbox
  • Animation:
    • 3D-Charts.
    • Anzeigen unterschiedlicher Werte pro Einheit
    • Setzen der Chartw-Werte zur Laufzeit

Allgemeine Vorgehensweise

Voraussetzung

• Um die Charts zu nutzen, muss man ein Modul erstellen mit einem Datenbereich, der die zu visualisierenden Daten z.B. Aufwand oder Kosten, enthält.
  • Dieser Datenbereich wird als Quelldatenbereich für den Chart genutzt.
  • In der Datenbereichszuordnung muss der Parameter Raw Format aktiviert werden.
    • Dieser Parameter ist standardmäßig im Fenster 9 und kann eingeblendet werden.
  • Der Quelldatenbereich muss sichtbar sein d.h. Nie anzeigen darf nicht aktiviert sein. Anzeige = 0 "Nicht anzeigen" ist möglich.

Anlegen eines Chart-Datenbereichs

Vorgehensweise

• Oberhalb des Quellbereichs einen weiteren Datenbereich anlegen.
• Folgendes Dataitem zuordnen:
  • DF = 004336 Button/IronPython
• Folgende Parameter setzen:
  • DF-Verhalten = py
  • DF-Höhe: Höhe des Charts
  • DF-Breite: Breite des Charts
• Speichern. Anschließend Datenbereich neu öffnen, damit das Datenfeld zur Eingabe des Skripts sichtbar wird.

Hinweis

• Die Datenfelder DF-Höhe und DF-Breite sind in der Modulvariante Layout oder können alternativ eingeblendet werden.

Anlegen des Chart-Skripts

Vorgehensweise

• Für das Chart-Datenfeld im Feld IronPython Skript folgenden Code einfügen:

###Automatically generated###
###Changes will be overwritten###
Charthelper=ConsoleScope['Charthelper']
PPMS_chart_generator=ConsoleScope['PPMS_chart_generator']
#Initialize variables
df_reference={}
df_reference["AxisXLabel"]=""
df_reference["LegendText"]=""
df_reference["XValue"]=""
df_reference["YValue"]=""
df_reference["ZValue"]=""
df_reference["AxisYLabel"]=""
df_reference["YAxisSuffix"]=""
df_reference["XAxisSuffix"]=""
df_reference["Event"]=""
title=""
da_id=""
xaml_colorset=""
xaml_background_brush=""
xaml_dataseries=""
xaml_chart=""
#Execute datafield configuration
exec(df.Customizing.PythonScriptSettings)
#Get charthelper object
ch = Charthelper(df, df_reference, da_id)

#Get value dictionary
value_dict = ch.value_dict
"""Create PPMS_chart_generator instance
para.1 - xaml_chart, no default value
para.2 - xaml_dataseries, no default value
para.3 - xaml_colorset, no default value
para.4 - xaml_background_brush, no default value
para.5 - dict_values: dictionary, default empty dictionary
para.6 - AxesX _label: String, default empty
para.7 - AxesY _label: String, default empty
para.8 - Title: String, default --> AxesX _label + "/" + AxesY _labell """
#Create PPMS Chart
chart_panel = PPMS_chart_generator(xaml_chart, xaml_dataseries, xaml_colorset, xaml_background_brush, dict_values=ch.value_dict, AxesX _label=ch.get_di_title(df_reference["AxisXLabel"]), AxesY _label=ch.get_di_title(df_reference["AxisYLabel"]), Title=title, modlayout=moduleLayout, dict_event=ch.event_dict, suffix_dict=ch.suffix)
#Get PMS Chart panel
ctl = chart_panel.winpanel

Setzen der Skript-Parameter

Vorgehensweise

• Folgendes Template in das Feld Datenfeld-Konfiguration einkopieren.

xaml_chart=""""""
xaml_dataseries=""""""
xaml_colorset=""""""
xaml_background_brush=""""""

#Initialize datarea_id and chart_title -variable
da_id=""
title=df.DataArea.Customizing.Name

"""Define Chart - Properties"""

#Set datafield_id for chart_values
df_reference={}
df_reference["AxisXLabel"]=""
df_reference["LegendText"]=""
df_reference["XValue"]=""
df_reference["YValue"]=""
df_reference["ZValue"]=""
df_reference["AxisYLabel"]="" 

• Hierbei werden folgende Parameter festgelegt. Für jeden Chart-Typ müssen andere Parameter gesetzt werden.

Tipp

• Im Modul Iron Python-Charts werden Beispiel-Charts für die verschiedenen Chart-Typen angezeigt. Mit STRG + F3 auf dem "X" über den Charts kann in den dazugehörigen Datenbereich gewechselt werden.

Setzen der XAML-Parameter

• Customizer Stammdaten --> XAML - Templates aufrufen.
  • Hier können für die XAML-Variablen xaml_chart, xaml_dataseries, xaml_colorset und xaml_background_brush im Datenfeld XML-Code die jeweiligen XAMLs ausgewählt werden.
• Den entsprechenden XAML-Code kopieren und an der dazugehörigen Stelle im Skript im Datenfeld Datenfeld-Konfiguration einfügen.
• Speichern.

Setzen der Parameter da_id und title

• Setzen der Parameter wie folgt:
  • da_id: ID des Quell-DA aus Datenfeld DA ohne führende Nullen angeben.
  • title: Chart-Titel angeben.
    • Mit df.DataArea.Customizing.Name wird der im Datenfeld Datenbereich hinterlegte Titel des Chart-Datenbereichs angezeigt.

Setzen der df_reference

Pie-Chart

• Setzen der Parameter wie folgt:

#Set datafield_id for chart_values
df_reference["AxisXLabel"]= Angabe der Feldnummer zum Setzen der Beschriftung
df_reference["LegendText"]=""
df_reference["XValue"]=""
df_reference["YValue"]= Angabe der Feldnummer zum Setzen der Werte
df_reference["ZValue"]=""
df_reference["AxisYLabel"]=""

Beispiel

Column-Chart

• Setzen der Parameter wie folgt:

#Set datafield_id for chart_values
df_reference["AxisXLabel"]= Angabe der Feldnummer zum Setzen der X-Achsen Beschriftung
df_reference["LegendText"]=""
df_reference["XValue"]=""
df_reference["YValue"]= Angabe der Feldnummer zum Setzen der Y-Werte
df_reference["ZValue"]=""
df_reference["AxisYLabel"]=df_reference["YValue"]

Beispiel

Bar-Chart

• Setzen der Parameter wie folgt:

#Set datafield_id for chart_values
df_reference["AxisXLabel"]= Angabe der Feldnummer zum Setzen der Einheitsbeschriftung
df_reference["LegendText"]=""
df_reference["XValue"]=""
df_reference["YValue"]= Angabe der Feldnummer zum Setzen des Balkenwertes
df_reference["ZValue"]=""
df_reference["AxisYLabel"]=df_reference["YValue"]

Beispiel

Line-Chart

• Setzen der Parameter wie folgt:

#Set datafield_id for chart_values
df_reference["AxisXLabel"]= Angabe der Feldnummer zum Setzen der Einheitsbeschriftung
df_reference["LegendText"]= Angabe der Feldnummer zum Setzen der Legendenbeschriftung
df_reference["XValue"]=""
df_reference["YValue"]= Angabe der Feldnummer zum Setzen des Balkenwertes
df_reference["ZValue"]=""
df_reference["AxisYLabel"]=df_reference["YValue"]

Beispiel

Modulstart

• Nachdem alle Parameter gesetzt wurden:
  • Speichern.
  • Modul starten.

Charts für Meilensteintrendanalyse (MTA)

Einführung

• Die Meilensteintermineinschätzungen von Projektvorgängen können mithilfe der Meilensteintrendanalyse (MTA) als Diagramm bzw. Chart dargestellt werden.
• Die Darstellung einer Meilensteintrendanalyse wird über ein Modul-Customizing umgesetzt und kann mit den folgenden Beschreibungen nachvollzogen werden.

Die wichtigsten Punkte im Überblick

• Zur Darstellung der Charts wird auf die Chart-Komponente Visifire zurückgegriffen.
• Die Logik zur Anzeige von MTA-Charts ist in einem IronPython-Modul implementiert.
• Das MTA-Modul kann über ein IronPython-Makro angesprochen werden.

Eine Liste von Vorgangsserien mit einem Meilensteintrendanalyse-Chart anzeigen

Vorgehensweise

• Ein Modul anlegen
• Die benötigten Datenbereiche und Datenfelder anlegen
  • Datenbereich aus Datentabelle 354 (Dummy)
    • Beliebiges „Platzhalter"-Feld mit DF-Verhalten „py" (z.B. 004336 Button/IronPython)
      • Die DF-Höhe und DF-Breite bestimmt die Höhe und Breite des Meilenstein-Charts.
    • Platzhalter-Feld vom Typ 025581 Background-DI: die DF-Überschrift dieses Felds wird als Chart-Titel verwendet.
  • Datenbereich aus Datentabelle 824 (Vorgang) mit folgenden Datenfeldern
    • 008445 Vorgangs-ID
    • 008636 Vorgangsbezeichnung
    • 008642 Meilenstein
    • 008805 Status vom
    • 008625 Kalk. Ende
• Den Datenbereich aus Datentabelle 824 dem Dummy-Datenbereich unterordnen.
• Das folgende IronPython-Skripts in das Datenfeld IronPython Skript des Platzhalter-Datenfelds einfügen:

import clr
import sys

# Debug: results in reloaded module to reflect code changes in MilestoneChart
# sys.modules.Remove("MTA")
# sys.modules.Remove("MTA.milestone_chart")

from System import DateTime
from System.Windows.Forms import *
from System.Windows.Media import Brushes

from MTA.milestone_chart import milestone_chart
from MTA.milestone_dataseries import milestone_dataseries
from MTA.time_interval_enum import time_interval_enum


# Used global variables from DataField-Configurations
# - targetDataAreaId
# - processIdField
# - processCaptionField
# - reportDateField
# - targetDateField
# - milestoneField
# - milestoneFilter
# - chartTitleField
# report date = Berichtszeitpunkt
# target date = Meilensteintermin
exec(df.Customizing.PythonScriptSettings)

# Get DataAreaRecords
targetDataArea=targetDataAreaId
records=[]
roots=list(df.Module.Roots)
for root in roots:
    dataAreas=list(root.DAManager)
    for dataAreaRecord in dataAreas:
        if dataAreaRecord.Customizing.Uid == targetDataArea:
            records.append(dataAreaRecord)
            
seriesList = {}
fields = {}

# Get field associations from data field configuration
fields["ProcessID"] = processIdField
fields["ProcessCaption"] = processCaptionField
fields["Milestone"] = milestoneField
fields["ReportDate"] = reportDateField
fields["TargetDate"] = targetDateField
fields["ChartTitle"] = chartTitleField

# Initialize milestone value filter
criterias = {}
criterias["Milestone"]=[milestoneFilter]

# Extract needed field-values from records
for record in records:
    values = {}   
    areaCU = record.Customizing
    for key in fields.keys():
        fieldCU = areaCU.ChildrenDFC.TryGetValue(fields[key])[1]
        field = record.ChildrenDF.__getitem__(fieldCU)
        value = field.GetValue[str]()
        values[key] = value
    
    # Filter by milestone value
    if values["Milestone"] in criterias["Milestone"]:
        if values["ReportDate"] != None and values["TargetDate"] != None:
            if values["ProcessID"] not in seriesList.keys():            
                seriesList[values["ProcessID"]] = milestone_dataseries()
            # Create Series from values
            series = seriesList[values["ProcessID"]]
            reportDate = DateTime.Parse(values["ReportDate"])
            targetDate = DateTime.Parse(values["TargetDate"])
            series.data_points.Add(reportDate, targetDate)
            if values["ProcessCaption"] != None and values["ProcessCaption"] != "":
                series.title = values["ProcessCaption"]
        
# Create Chart
chart = milestone_chart(seriesList.values())

#If necessary, define custom time interval here:
#chart.current_time_interval = time_interval_enum.quarters

# Set Chart title from specified DataField
chart.chart_title=df.DataArea.Customizing.ChildrenDFC.TryGetValue(chartTitleField)[1].Title 

# Finally render chart do client-control
ctl = chart.get_element_host()

• Speichern

Anpassungen am IronPython-Skript

• Konfiguration des IronPython-Skript
  • Im Skript kann eine Liste von Variablennamen eingesehen werden, denen entsprechende Feldnummern zugewiesen werden müssen („targetDataArea", „reportDateField" etc.).
  • Das Setzen einer solchen Konfigurationsvariable erfolgt nach dem Schema Variable = "<Wert>" in der Datenfeldkonfiguration des Platzhalter-Datenfelds

Hinweise zur Meilensteintrendanalye-Charts

• Die Legendeneinträge im Chart werden aus dem Feld Vorgangsbezeichnung bezogen
• In den Tooltips der einzelnen Datenpunkte werden zur Vorgangsbezeichnung jeweils Berichtszeitpunkt (Status vom) und Meilensteintermin (Kalk. Ende) angezeigt
• Das Zeitintervall der Achsenbeschriftungen und des Chart-Rasters wird dynamisch in Abhängigkeit von Chart-Abmessungen/Zoom-Level und Datenmenge festgelegt.

Technische Informationen zur API der Meilensteintrendanalyse

MTA-API Reference (IronPython)

Class milestone_chart

Class milestone_dataseries

Technische Informationen zum Einbinden der Charts

• Zur Initialisierung der Visifire Charts, muss zunächst eine IronPython-Klasse (PPMS_Chart_generator) erstellt werden, welche das Zeichnen der Charts übernimmt.
• Zum Zeichnen der Charts wird auf die .Net API, wie auch auf die Visifire DLLs zugegriffen.
• Eine weitere IronPython-Klasse (Charthelper) kümmert sich um die Datenaufbereitung. Sie verwendet die PLANTA-Client API.
• Beide Klassen werden in das Clientverzeichnis ausgelagert, sodass sie über die IronPython-Schnittstelle des PLANTA-Clients genutzt werden können.
• Der Zugriff auf die definierten Klassen erfolgt über die PLANTA Software. Hierbei wird ein Python-Skript, zum Initialisieren der Charts, vom Server zum Client gesendet. Dies erfolgt in einem Modul, welches neben dem Skript auch alle Daten beinhaltet.

Chart-Design erstellen

Das Chart-Design wird über XAML beschrieben, das zur Erstellung von WPF-basierten Oberflächen genutzt wird. Beispiel:

<Grid
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:vc="clr-namespace:Visifire.Charts;assembly=WPFVisifire.Charts"
x:Name="LayoutRoot"
        <vc:Chart Watermark="False"> </Grid>

Implementierung der IronPython-Klassen

Ausführen von IronPython-Skripts am Client

• Zur Darstellung von Charts im Programm können Skripte im DataFieldCustomizing von Datafields hinterlegt werden.
• Der Zugriff auf alle Daten erfolgt über das Datafield-Objekt, in dem sich das Skript befindet.

Klasse: Charthelper

• Aufgabe: Aufbereitung der Daten
• Speicherort: Clientverzeichnis
• Details:
  • Name: charthelper
  • Attribute:
    • df: Type DataField - kein Default-Wert
      • Object der Klasse DataField in der sich das Chart-Skript befindet.
    • df_reference: Type Dictionary (Python Hash-Table) - kein Default-Wert
      • Jeder Chart-Parameter wird mit einem Datafield verbunden.
    • da_id: Type String - optional
      • Angabe des Dataareas, aus dem die Daten bezogen werden.
      • Defaultmäßig wird der Dataarea in dem sich der Chart befindet referenziert.
  • Methoden:
    • __init__(): Konstruktor
      • Setzt die Attribute und startet die Methode get_chart_dict().
    • get_chart_dict: void
      • Führt die Datenaufbereitung durch, anhand der Parameter die in df_reference, festgelegt wurden.
        • Liefert die aufbereiteten Daten als Dictionary(Hash-Table) zurück.
          • Welches an die PPMS_Chart_generator Klasse weitergeleitet werden kann.
    • get_di_title: String
      • Parameter: UID eines Datafields
      • Return: Gibt den Datafield-Titel zurück

Klasse: PPMS_chart_generator

• Erstellung der Klasse PPMS_chart_generator mit IronPython zur Generierung der Charts, anhand der aufbereiteten Daten aus der Klasse Charthelper.
• Die PPMS_chart_generator Klasse wird in das Clientverzeichnis ausgelagert.
• Details:
  • Klassenname: PPMS_chart_generator
  • Konstruktor-Parameter:
    • xaml_chart: Type String(XML)
    • Erstellung des Chart-Objektes.
    • Kein Default-Wert.
  • xaml_dataseries: Type String (XML)
    • Template zur Erstellung der Datenpaarobjekte.
      • Legt den Chart-Typ fest.
      • Die jeweiligen Daten werden im Konstruktor gesetzt.
    • Kein Default-Wert.
  • xaml_colorset: Type String(XML)
    • Setzen der Farbe für ein Datenpaar.
    • Wenn keine Angaben gemacht werden, wird ein Default-Wert genommen.
  • xaml_background_brush: Type String(XML)
    • Setzen der Hintergrundfarbe mit Farbverläufen.
    • Wenn keine Angaben gemacht werden, wird ein Default-Wert genommen.
  • dict_values: Type Dictionary (Hash Table)
    • Aufbereitetes Daten-Dictionary der Klasse Charthelper()
  • QAxesX_label: Type String
    • Beschriftung für X - Achse.
  • QAxesY_label: Type String
    • Beschriftung für Y - Achse.
  • Title: Type String
    • Chart-Titel
• Methoden:
  • __init__(): Konstruktor
    • Setzt die Attribute und startet die Chart-Erstellung.
  • create_element_host():
    • Setzt den WPF Chart in einen Element host.
      • Element host: Verknüpft WPF Controls mit Windows.Forms Controls.
        • Wird benötigt, da der Client auf der Windows.Forms Library basiert.
  • set_values():
    • Fügt die Datenpaare der Dataseries hinzu.
      • Werte werden dem Chart hinzugefügt.
• Verwendete Klassen aus der .Net API:
  • System.IO.!QStringReader
  • System.Xml.!XmlReader
  • System.Windows.Markup.!QXamlReader
  • System.Windows.Markup.!QXamlWriter
  • System.Windows.Forms.Integration.!QElementHost
  • System.Windows.Forms.Panel
  • System.Windows.Forms.!QDockStyle
• Verwendete Klassen aus der Visifire API:
  • Visifire.Charts

UML-Diagramm aller verwendeten Klassen:

Public Python Charting-API Reference

Charthelper (charthelper.py)

The Charthelper-class provides methods to prepare raw data for usage within charts. Depending on the specified chart-parameters, values are convertet to be suitable for the Visifire-API.

PPMS_chart_generator (chart_generator.py)

The PPMS_chart_generator-class provides methods for chart-generation with use of custom XAML-formating. Note that generation of charts depends on data that has been processed by an instance of the Charthelper-Class before.

Initialisierung der Charts per Skript

DF-Konfiguration

• Die Chart-spezifischen Parameter werden in einem Konfigurationsfeld im DataFieldCustomizing gespeichert.
  • Parameter
    • Typ (Pie-, Bar-Chart ...)
    • Hintergrundfarbe
    • Referenz zu Daten
    • ...
• Die Parameter werden zum Instanzieren der Charthelper- und PPMS_chart_generator - Klasse benötigt.

Beispiel

xaml_chart="""<Grid
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:vc="clr-namespace:Visifire.Charts;assembly=WPFVisifire.Charts"
        <x:Name="LayoutRoot">
            <vc:Chart Watermark="False">
                <vc:Chart.Titles>
                    <vc:Title Text="" />
                </vc:Chart.Titles>
                <vc:Chart.AxesX>
                    <vc:Axis Title="" />
                </vc:Chart.AxesX>
                <vc:Chart.AxesY>
                    <vc:Axis Title="" />
                </vc:Chart.AxesY>
            <vc:Chart>
        <Grid>"""

xaml_dataseries="""<UserControl
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                xmlns:vc="clr-namespace:Visifire.Charts;
                               <assembly=WPFVisifire.Charts">
             <vc:Chart>
                <vc:Chart.Series>
                    vc:DataSeries RenderAs="Pie" MarkerEnabled="True"
                           <MarkerType="Circle" LegendText="">
                </vc:Chart.Series>
            </vc:Chart>
        </UserControl>"""

xaml_colorset=""
xaml_background_brush=""
"""Define Chart - Properties"""
da_id='42162'
#Set datafield_id for chart_values
df_reference={}
df_reference["AxisXLabel"]="134082"
df_reference["LegendText"]=""
df_reference["XValue"]=""
df_reference["YValue"]="142717"
df_reference["ZValue"]=""
df_reference["AxisYLabel"]= df_reference["YValue"]
title=df.Dataarea.Customizing.Name

IronPython-Skript

• Der Aufruf der Charthelper- und PPMS_chart_generator -Klasse, erfolgt im IronPython-Skriptfeld (siehe DataFieldCustomizing.PythonScript), welches im DataFieldCustomizing gespeichert wird.
• Dieses Skript ist für alle Chartmakros gleich und kann bei Änderung leicht für alle Charts geändert werden.
• Die chartspezifischen Eigenschaften werden aus dem Konfigurationsfeld ausgelesen.

Beispiel

###Automatically generated###
###Changes will be overwritten###
from charthelper import Charthelper
from chart_generator import PPMS_chart_generator
#Execute datafield configuration
exec(df.Customizing.PythonScriptSettings)
#Get charthelper object
ch = Charthelper(df, df_reference, da_id)
#Get value dictionary
value_dict = ch.value_dict
"""Create PPMS_chart_generator instance
para.1 - xaml_chart, no default value
para.2 - xaml_dataseries, no default value
para.3 - xaml_colorset, no default value
para.4 - xaml_background_brush, no default value
para.5 - dict_values: dictionary, default empty dictionary
para.6 - AxesX _label: String, default empty
para.7 - AxesY _label: String, default empty
para.8 - Title: String, default --> AxesX _label + "/" + AxesY _labell """
#Create PPMS Chart
chart_panel = PPMS_chart_generator(xaml_chart, xaml_dataseries, xaml_colorset, xaml_background_brush, dict_values=ch.value_dict, AxesX _label=ch.get_di_title(df_reference["AxisXLabel"]), AxesY _label=ch.get_di_title(df_reference["AxisYLabel"]), Title=title)
#Get PMS Chart panel
ctl = chart_panel.winpanel
#Delete datafield variables
del xaml_chart
del xaml_dataseries
del da_id
del df_reference
del title
del ch
del value_dict
del chart_panel
del Charthelper
del PPMS_chart_generator
del xaml_background_brush
del xaml_colorset