Demonstrates how to add Error Bars to an iOS Line or Scatter Chart.

There are two Error Bar Series Types in SciChart iOS: The SCIFastErrorBarsRenderableSeries requires an SCIHlcDataSeries as data source. The High, Low values are used to set the high and low position of the errors, while the Close (Y-value) is the center of the error bar.

A second error bar type is the SCIFixedErrorBarsRenderableSeries. This requires only a SCIXyDataSeries with X,Y values. Error values are fixed and specified by the properties errorHigh and errorLow. The errorType property specifies whether the error is Relative or Absolute.

Tip!

Do you need to change the width of the Error Bars? Try the dataPointWidth property. This alters how much space the bar takes up.

// ErrorBarsChartView.m

//
//  ErrorBarsChartView.m
//  SciChartDemo
//
//  Created by Hrybenuik Mykola on 9/17/16.
//  Copyright © 2016 ABT. All rights reserved.
//

#import "ErrorBarsChartView.h"
#import <SciChart/SciChart.h>
#import "DataManager.h"

@implementation ErrorBarsChartView


@synthesize surface;

- (void)initializeSurfaceRenderableSeries {
    
    SCIXyDataSeries * data = [[SCIXyDataSeries alloc] initWithXType:SCIDataType_Float YType:SCIDataType_Float];
    [DataManager getFourierSeriesZoomed:data amplitude:1.0 phaseShift:0.1 xStart:5.0 xEnd:5.15 count:5000];
    
    SCIHlDataSeries * dataSeries0 = [[SCIHlDataSeries alloc] initWithXType:SCIDataType_Float YType:SCIDataType_Float];
    SCIHlDataSeries * dataSeries1 = [[SCIHlDataSeries alloc] initWithXType:SCIDataType_Float YType:SCIDataType_Float];
    
    [self fillSeries:dataSeries0 sourceData:data scale:0.06];
    [self fillSeries:dataSeries1 sourceData:data scale:0.1];
    
    SCIFastErrorBarsRenderableSeries * errorBars0 = [SCIFastErrorBarsRenderableSeries new];
    [errorBars0 setDataPointWidth:0.7];
    errorBars0.strokeStyle = [[SCISolidPenStyle alloc] initWithColorCode:0xFFC6E6FF withThickness:1.f];
    errorBars0.dataSeries = dataSeries0;
    
    SCIFastLineRenderableSeries * lineSeries = [SCIFastLineRenderableSeries new];
    lineSeries.strokeStyle = [[SCISolidPenStyle alloc] initWithColorCode:0xFFC6E6FF withThickness:1.f];
    lineSeries.dataSeries = dataSeries0;
    
    SCIEllipsePointMarker * pMarker = [[SCIEllipsePointMarker alloc]init];
    pMarker.width = 5;
    pMarker.height = 5;
    pMarker.fillStyle = [[SCISolidBrushStyle alloc]initWithColorCode:0xFFC6E6FF];
    lineSeries.pointMarker = pMarker;
    
    [surface.renderableSeries add:errorBars0];
    [surface.renderableSeries add:lineSeries];
    
    SCIFastErrorBarsRenderableSeries * errorBars1 = [SCIFastErrorBarsRenderableSeries new];
    errorBars1.strokeStyle = [[SCISolidPenStyle alloc] initWithColorCode:0xFFC6E6FF withThickness:1.f];
    errorBars1.dataSeries = dataSeries1;
    [errorBars1 setDataPointWidth:0.7];
    SCIXyScatterRenderableSeries * scatterSeries = [SCIXyScatterRenderableSeries new];
    scatterSeries.dataSeries = dataSeries1;
    
    SCIEllipsePointMarker * sMarker = [[SCIEllipsePointMarker alloc]init];
    sMarker.width = 7;
    sMarker.height = 7;
    sMarker.fillStyle = [[SCISolidBrushStyle alloc]initWithColorCode:0x00FFFFFF];
    scatterSeries.style.pointMarker = sMarker;
    scatterSeries.dataSeries = dataSeries1;
    
    [surface.renderableSeries add:errorBars1];
    [surface.renderableSeries add:scatterSeries];
    
    [surface invalidateElement];
}

-(void) fillSeries:(id<SCIHlDataSeriesProtocol>)dataSeries sourceData:(id<SCIXyDataSeriesProtocol>)sourceData scale:(double)scale{
    SCIArrayController * xValues = [sourceData xValues];
    SCIArrayController * yValues = [sourceData yValues];
    
    for (int i =0 ; i< xValues.count; i++){
        double y = SCIGenericDouble([yValues valueAt:i]) * scale;
        [dataSeries appendX: [xValues valueAt:i] Y:SCIGeneric(y) High:SCIGeneric(randf(0.0, 1.0)*0.2) Low:SCIGeneric(randf(0.0, 1.0)*0.2)];
    }
}

- (instancetype)initWithFrame:(CGRect)frame{
    self = [super initWithFrame:frame];
    
    if (self) {
        SCIChartSurface * view = [[SCIChartSurface alloc]initWithFrame:frame];
        surface = view;
        
        [surface setTranslatesAutoresizingMaskIntoConstraints:NO];
        
        [self addSubview:surface];
        NSDictionary *layout = @{@"SciChart":surface};
        
        [self addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"|-(0)-[SciChart]-(0)-|" options:0 metrics:0 views:layout]];
        [self addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"V:|-(0)-[SciChart]-(0)-|" options:0 metrics:0 views:layout]];
        
        [self setupSurface];
        [self addAxes];
        [self addModifiers];
        [self initializeSurfaceRenderableSeries];
    }
    return self;
}

- (void)setupSurface {
    
}

- (void)addAxes{
    id<SCIAxis2DProtocol> axis = [[SCINumericAxis alloc] init];
    [surface.yAxes add:axis];
    
    axis = [[SCINumericAxis alloc] init];
    [surface.xAxes add:axis];
}

- (void)addModifiers{
    SCIXAxisDragModifier * xDragModifier = [SCIXAxisDragModifier new];
    xDragModifier.dragMode = SCIAxisDragMode_Scale;
    xDragModifier.clipModeX = SCIClipMode_None;
    
    SCIYAxisDragModifier * yDragModifier = [SCIYAxisDragModifier new];
    yDragModifier.dragMode = SCIAxisDragMode_Pan;
    
    SCIPinchZoomModifier * pzm = [[SCIPinchZoomModifier alloc] init];
    
    SCIZoomExtentsModifier * zem = [[SCIZoomExtentsModifier alloc] init];
    [zem setModifierName:@"ZoomExtents Modifier"];
    
    SCIRolloverModifier * rollover = [[SCIRolloverModifier alloc] init];
    rollover.style.tooltipSize = CGSizeMake(200, NAN);
    [rollover setModifierName:@"Rollover Modifier"];
    
    SCIChartModifierCollection * gm = [[SCIChartModifierCollection alloc] initWithChildModifiers:@[xDragModifier, yDragModifier, zem, pzm, rollover]];
    surface.chartModifiers = gm;
}

@end

// SCSErrorBarsChartView.swift

//
//  SCSErrorBarsChartView.swift
//  SciChartSwiftDemo
//
//  Created by Hrybenuik Mykola on 9/20/16.
//  Copyright © 2016 SciChart Ltd. All rights reserved.
//

import Foundation
import SciChart

class SCSErrorBarsChartView: UIView {
    let surface = SCIChartSurface()
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        completeConfiguration()
    }
    
    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
        completeConfiguration()
    }
    
    func addDefaultModifiers() {
        
        let xAxisDragmodifier = SCIXAxisDragModifier()
        xAxisDragmodifier.dragMode = .scale
        xAxisDragmodifier.clipModeX = .none
        
        let yAxisDragmodifier = SCIYAxisDragModifier()
        yAxisDragmodifier.dragMode = .pan
        
        let extendZoomModifier = SCIZoomExtentsModifier()
        
        let pinchZoomModifier = SCIPinchZoomModifier()
        
        let rolloverModifier = SCIRolloverModifier()
        rolloverModifier.style.tooltipSize = CGSize(width: 200, height: CGFloat.nan)
        
        let groupModifier = SCIChartModifierCollection(childModifiers: [xAxisDragmodifier, yAxisDragmodifier, pinchZoomModifier, extendZoomModifier, rolloverModifier])
        
        surface.chartModifiers = groupModifier
    }
    
    // MARK: initialize surface
    fileprivate func addSurface() {
        surface.translatesAutoresizingMaskIntoConstraints = true
        surface.frame = bounds
        surface.autoresizingMask = [.flexibleHeight, .flexibleWidth]
        addSubview(surface)
    }
    
    // MARK: Overrided Functions
    
    func completeConfiguration() {
        addSurface()
        addAxes()
        addDefaultModifiers()
        addSeries()
    }
    
    // MARK: Private Functions
    
    fileprivate func addAxes() {
        surface.xAxes.add(SCINumericAxis())
        surface.yAxes.add(SCINumericAxis())
    }
    
    fileprivate func addSeries() {
        
        let dataSeries = SCIXyDataSeries(xType: .float, yType: .float)
        
        SCSDataManager.getFourierDataZoomed(dataSeries, amplitude: 1.0, phaseShift: 0.1, xStart: 5.0, xEnd: 5.15, count: 5000)
        
        let dataSeries0 = SCIHlDataSeries(xType: .float, yType: .float)
        let dataSeries1 = SCIHlDataSeries(xType: .float, yType: .float)
        
        fillSeries(dataSeries: dataSeries0, sourceData: dataSeries, scale: 1.0)
        fillSeries(dataSeries: dataSeries1, sourceData: dataSeries, scale: 1.3)
        
        let errorBars0 = SCIFastErrorBarsRenderableSeries()
        errorBars0.dataPointWidth = 0.7;
        errorBars0.dataSeries = dataSeries0
        errorBars0.strokeStyle = SCISolidPenStyle(colorCode: 0xFFC6E6FF, withThickness: 1.0)
        surface.renderableSeries.add(errorBars0)
        
        let pMarker = SCIEllipsePointMarker()
        pMarker.strokeStyle = SCISolidPenStyle(colorCode:0xFFC6E6FF, withThickness: 1.0)
        pMarker.fillStyle = SCISolidBrushStyle(colorCode: 0xFFC6E6FF)
        pMarker.height = 5
        pMarker.width = 5
        
        let lineRenderSeries = SCIFastLineRenderableSeries()
        lineRenderSeries.strokeStyle = SCISolidPenStyle(colorCode: 0xFFC6E6FF, withThickness: 1.0)
        lineRenderSeries.dataSeries = dataSeries0
        lineRenderSeries.style.pointMarker = pMarker
        surface.renderableSeries.add(lineRenderSeries)
        
        let errorBars1 = SCIFastErrorBarsRenderableSeries()
        errorBars1.dataPointWidth = 0.7;
        errorBars1.dataSeries = dataSeries1
        errorBars1.strokeStyle = SCISolidPenStyle(colorCode: 0xFFC6E6FF, withThickness: 1.0)
        surface.renderableSeries.add(errorBars1)
        
        let ellipsePointMarker1 = SCIEllipsePointMarker()
        ellipsePointMarker1.fillStyle = SCISolidBrushStyle(colorCode:0x00FFFFFF)
        ellipsePointMarker1.height = 7
        ellipsePointMarker1.width = 7
        
        let scatterRenderSeries = SCIXyScatterRenderableSeries()
        scatterRenderSeries.dataSeries = dataSeries1
        scatterRenderSeries.style.pointMarker = ellipsePointMarker1
        
        surface.renderableSeries.add(scatterRenderSeries)
        
        
    }
    
    private func fillSeries(dataSeries: SCIHlDataSeriesProtocol, sourceData:SCIXyDataSeriesProtocol, scale:Double){
        let xValues:SCIArrayController = sourceData.xValues() as! SCIArrayController
        let yValues:SCIArrayController = sourceData.yValues() as! SCIArrayController
        
        for i in 0..
< BACK TO ALL IOS CHART CHART EXAMPLES