Customizing of Charts

• In PLANTA project, interactive charts can be created, which possess the following advantages compared to Excel charts:.
  • Interactivity with PLANTA systems:
    • Zooming of charts
    • Dynamic display of the chart value over which you moved the mouse as toolbox
  • Animation:
    • 3D charts
    • Display different values per unit
    • Set the chart values at running time

General Procedure

Requirement

• In order to use the charts, you have to create a module with a data area which contains the data (e.g. effort or costs) to be visualized.
  • This data area is used as source data area for the chart.
  • In the data area assignment, the Raw format parameter must be activated.
    • This parameter is in window 9 by default and can be displayed by the user.
  • The source data area must be visible. I.e. Never display must not be activated. Display = 0 "Do not display" is possible.

Create Chart Data Area

Procedure

• Create another data area above the source area:
• Assign the following data item:
  • DF = 004336 Button/IronPython
• Set the following parameters:
  • DF behavior = py
  • DF height: Height of the chart
  • DF width: Width of the chart
• Save. Subsequently open the data area anew so the data field becomes visible for entering the script.

Note

• The DF height and DF width are in the Layout module variant and can be displayed alternatively.

Create Chart Script

Procedure

• Enter the following code for the chart data field in the IronPython script field:

###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

Set the Script Parameter

Procedure

• Copy the following template into the Data field configuration field.

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"]="" 

• In doing so, the parameters listed below will be defined. For each chart type, different parameters must be set.

Tip

• In the Iron Python charts module, sample charts for the different chart types are displayed. With CTRL + F3 on the X above the charts, you can switch to the associated data area.

Set the XAML Parameter

• Open Customizer Master Data XAML Templates.
  • Here, the corresponding XAMLs for the XAML variables xaml_chart, xaml_dataseries, xaml_colorset and xaml_background_brush can be selected in the XML code data field.
• Copy the corresponding XAML code and insert it at the corresponding position in the script in the Data field configuration data field.
• Save.

Set the da_id and title Parameters

• Set the parameters as follows:
  • da_id: specify the ID of the source DA from the DA data field without leading zero.
  • title: Specify the chart title.
    • With df.DataArea.Customizing.Name, the title of the chart data area deposited in the Data area data field is displayed.

Set the df_reference

Pie Chart

• Set the parameters as follows:

#Set datafield_id for chart_values
df_reference["AxisXLabel"]= Specification of the field number for setting the label
df_reference["LegendText"]=""
df_reference["XValue"]=""
df_reference["YValue"]= Specification of the field number for setting the values
df_reference["ZValue"]=""
df_reference["AxisYLabel"]=""

Example

Column Chart

• Set the parameters as follows:

#Set datafield_id for chart_values
df_reference["AxisXLabel"]= Specification of the field number for setting the X axis label
df_reference["LegendText"]=""
df_reference["XValue"]=""
df_reference["YValue"]= Specification of the field number for setting the Y values
df_reference["ZValue"]=""
df_reference["AxisYLabel"]=df_reference["YValue"]

Example

Gantt Chart

• Set the parameters as follows:

#Set datafield_id for chart_values
df_reference["AxisXLabel"]= Specification for setting the unit label
df_reference["LegendText"]=""
df_reference["XValue"]=""
df_reference["YValue"]= Specification for setting the bar value
df_reference["ZValue"]=""
df_reference["AxisYLabel"]=df_reference["YValue"]

Example

Line Chart

• Set the parameters as follows:

#Set datafield_id for chart_values
df_reference["AxisXLabel"]= Specification for setting the unit label
df_reference["LegendText"]= Specification of the field number for setting legend labels
df_reference["XValue"]=""
df_reference["YValue"]= Specification for setting the bar value
df_reference["ZValue"]=""
df_reference["AxisYLabel"]=df_reference["YValue"]

Example

Module Start

• After you have set all parameters:
  • Save.
  • Start the module.

Charts for Milestone Trend Analysis (MTA)

Introduction

• With the help of the milestone trend analysis (MTA), the milestone date estimation of project tasks can be displayed as a diagram or as a chart.
• The display of a milestone trend analysis is realized via module customizing and can be reproduced with the following descriptions.

Overview of the most important points:

• For the display of the charts, the Visifire chart component is resorted to.
• The logic for displaying MTA charts is implemented in an IronPython module.
• The MTA module can be activated via an IronPython macro.

Display a List of Task Series with a Milestone Trend Analysis

Procedure

• Create a module.
• Create the required data areas and data fields.
  • Data areas from data table 354 (Dummy)
    • Arbitrary„placeholder" field with „py DF behavior (e.g. 004336 Button/IronPython)
      • The DF height and DF width define the height and width of the milestone chart.
    • Placeholder field of the 025581 type, background DI: the DF heading of this field is used as chart title.
  • Data areas from data table 824 (task) with the following data fields
    • 008445 Task ID
    • 008636 Task name
    • 008642: Milestone
    • 008805 Status from
    • 008625 Calc. end
• Subordinate the data area from data table 824 to the Dummy data area.
• Insert the following IronPython script in the IronPython script data field of the placeholder:

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 = report date
# target date = milestone date
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()

• Save.

Modifications to the IronPython Script

• Configuration of the IronPython Script
  • In the script, a list of variable names, to which appropriate field numbers must be assigned, can be looked at („targetDataArea", „reportDateField" etc.).
  • Such configuration variables must be set in accordance with the following scheme: Variable = "<Value>" in the data field configuration of the placeholder data field.

Information on the Milestone Trend Analysis

• The legend entries in the chart are taken from the Task name field.
• In the tooltips of the individual data items, report date (Status from) and milestone date (Calc. end) are displayed for each task name.
• The time interval of the axis label and the chart grid is defined dynamically depending on the chart measurement/zoom level and the data amount.

Technical Information on the API of the Milestone Trend Analysis

MTA-API Reference (IronPython)

Class milestone_chart

Class milestone_dataseries

Technical Information for Charts Embedding

• For initialization of the visifire charts, you have to create an IronPython class (PPMS_chart_generator) that assumes the drawing of the charts first.
• In order to draw the charts, the .Net API as well as the Visifire DLLs are accessed.
• Another IronPython class (chart helper) takes care of the data preparation. It uses the PLANTA client API.
• Both classes are outsourced to the client directory, so it can be used via the IronPython interface of the PLANTA Client.
• The defined classes are accessed via the PLANTA software. Here, a Python script for initializing the charts is sent from server to client. This is done in a module containing the script as well as all other data.

Create Chart Design

The chart design is described via XAML which is used for creating WPF based surfaces. Example:

<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>

Implementation of IronPython Classes

Carrying out IronPython Scripts on the Client

• For the display of charts in the program, scripts can be deposited in the DataFieldCustomizing of data fields.
• All data is accessed via the data field object that contains the script.

Class: Chart helper

• Todo item: Processing of the data
• Storage location Client directory
• Details:
  • Name: charthelper
  • Attributes
    • df: Type DataField - no default value
      • Object of the DataField class that contains the chart script.
    • df_reference: Type Dictionary (Python Hash-Table) - no default value
      • Each chart parameter is connected to a data field.
    • da_id: Type string - optional
      • Specification of the data area from which the data is taken.
      • The data area that contains the chart is referenced by default.
  • Methods:
    • __init__(): Constructor
      • Sets the attributes and starts the get_chart_dict() method.
    • get_chart_dict: void
      • Carries out the data processing based on the parameters that were defined in df_reference.
        • Returns the processed data as dictionary(hash table),
          • which can be forwarded to the PPMS_Chart_generator class.
    • get_di_title: String
      • Parameters: UID of a data field
      • Return: Returns the data field title

Class: PPMS_chart_generator

• Creation of the PPMS_chart_generator class with IronPython for generating the charts on the basis of the processed data from the chart helper class.
• The PPMS_chart_generator class is outsourced to the client directory.
• Details:
  • Class name: PPMS_chart_generator
  • Constructor parameter:
    • xaml_chart: Type string (XML)
    • Create a chart object.
    • No default value.
  • xaml_dataseries: Type string (XML)
    • Template for the creation of the data pair objects.
      • Defines the chart type
      • The respective data are set in the constructor.
    • No default value.
  • xaml_colorset: Type string (XML)
    • Sets the color for a data pair.
    • If nothing is specified, a default value is used.
  • xaml_background_brush: Type string (XML)
    • Setting the background color with color gradients.
    • If nothing is specified, a default value is used.
  • dict_values: Type dictionary (hash table)
    • Processed data dictionary of the chart helper() class
  • QAxesX_label: Type string
    • Label for x-axis.
  • QAxesY_label: Type string
    • Label for y-axis.
  • Title: Type string
    • Chart title
• Methods:
  • __init__(): Constructor
    • Sets the attributes and starts the chart creation.
  • create_element_host():
    • Sets the WPF chart into an element host.
      • Element host: Links WPF controls with Windows.Forms.Controls.
        • Is required since the client is based on the Windows.Forms library.
  • set_values():
    • Adds the data pairs of the data series.
      • Values are added to the chart.
• Used classes from the .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
• Used classes from the Visifire API:
  • Visifire.Charts

UML diagram of all used classes:

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 converted 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.

Initialization of the Charts per Script

DF Configuration

• The chart specific parameters are saved in a configuration field in the DataFieldCustomizing.
  • Parameters
    • Type (Pie, Gantt chart ...)
    • Background color
    • Reference to data
    • ...
• The parameters are necessary for instancing the chart helper and PPMS_chart_generator class.

Example

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 Script

• The chart helper and PPMS _chart_generator class is opened in the IronPython script field (see DataFieldCustomizing.PythonScript), which is saved in the DataFieldCustomizing.
• This script is the same for all chart macros and can be changed easily for all charts upon changes.
• The chart specific settings are read out from the configuration field.

Example

###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