RSS Feed
News
Mar
13
Comparison of SciChart vs. Open Source Chart controls
Posted by Andrew on 13 March 2019 09:00 AM

At SciChart we are big fans of open source! We use open source in some of our chart controls, such as SharpDX (a managed wrapper around DirectX), Rene Schulte’s brilliant WriteableBitmapEx (for line drawing in WPF), WordPress/PhP on the website and more. We’ve even written some open source components such as the popular, free WPF Transitionz library. So, we don’t want to disparage the hard work of any open source chart component developers.

However, we do often get asked the questions ‘is your software free?’ and ‘why should I buy SciChart vs. using a free open source chart component?’

In this article we compare our software vs. a few popular free WPF, iOS & Android chart libraries and present reasons & benefits when it may be better to choose SciChart over open source, free charts for your WPF, iOS, Android & Xamarin applications.

Reason #1: Enterprise Tech Support

This first reason almost goes without saying. One of the biggest value-adds of using a commercial WPF, iOS or Android chart control is the insurance of knowing you have Enterprise technical support. If charts are mission critical to your project, and resolving any issues, should they occur, is important to you, it’s a very strong reason to consider a commercial chart control such as SciChart.

The following table shows the reported open issues on four major open source chart projects: OxyPlot (WPF Charts), LiveCharts (WPF Charts), MPAndroidChart (Android Charts) and Charts (iOS). New questions are asked every day on the github repositories for these libraries, and many are unanswered.

Open source project Number of open issues
OxyPlot (WPF Charts) 404 open issues
LiveCharts (WPF Charts) 316 open issues
MPAndroidChart (Android Charts) 1345 open issues
Charts (iOS Charts) 374 open issues
SciChart (WPF, iOS, Android, Xamarin Charts) Over 7,500 support incidents resolved.

Table 1: Open issues on popular open source chart components

We’re not surprised! One twitter influencer described the flood of open source help requests as ‘the fire-hose of open source’: When your open source chart library becomes popular you will be flooded with requests from users asking for help, demanding bug fixes and features, and it can quickly become unsustainable to handle them. So, the open source developers (some of whom have done a great job writing software!) quite rightly stop answering. Even we find it hard work sometimes to answer as many support requests as we do: over 7,500 requests for help, technical support or forum questions to date, and its our job! I can’t imagine having to do this level of work in spare time.

Figure 1: Issues outstanding on the MPAndroidChart open source chart library

What this means for you is, if you use an open source chart control in your business-critical project and one day you need help, and stackoverflow or the community is unable to provide it, you will be stuck… This could cost your business time and money if your application development is delayed if your productivity is affected while trying to find a solution.

SciChart’s 5-star rated Enterprise tech support is an insurance policy against problems you might encounter during your project. Our tech support is not meant to be a replacement for google, or research, but if WPF, iOS, Android or Xamarin charts in your project are mission critical to your business, at some point you may encounter a problem or issue that needs our team to help you. This can save you time and money to get back to what you are supposed to do: developing your application.

Reason #2: Ease of Use & Productivity

Technical support isn’t the only reason to choose SciChart vs. an open source chart component. We think you’ll find that if an API or library is productive and easy to use, it can lead to bigger cost saving than those provided by tech support.

  • Consider how much is your time worth per hour or per day?
  • How much time might you save in a year of using SciChart vs. an open source chart?

Think about the time to get started, learn the API, to find information you need on the web. If you have a requirement that is not simple, you might need to do some research to find the answers. With SciChart, you won’t need to save much time for the license to pay for itself entirely.

Example:

  • Cost of developer time: $60 / hour ($480 per day)
  • Cost of SciChart License: approx ~$1100 for SciChart WPF 2D Professional
  • Only 2.3 developer days need to be saved in a year before SciChart pays for itself.

It’s quite reasonable to assume you might save an hour per week when using SciChart vs. an Open Source chart component. More if your project is chart heavy. An hour per week adds up to 48 working hours per year, or 5 days of developer time: much more than the cost of the license.

One of our customers left us a great review, which said this:

We wrestled with a few free chart alternatives for several weeks; but after trying SciChart, we realized that we'd ultimately save money and ship our software faster by investing in such an easy-to-use library

This is really an incredible review and we’re grateful, but did you notice that the author spent several weeks evaluating free alternatives to SciChart? Free software can come with a cost of your time, and although SciChart is a commercial control meaning initial cost to your team, the care and attention that has gone into the API, examples, documentation and online help resources such as tutorials and forums will lead to faster development of the application & cost savings in the long run.

Reason #3: Developer activity & Speed of Bug Fixes

This reason is closely linked to #1. We have noticed that the development activity of many of the popular open source chart controls has declined over time, however, the demand for features and improvements has increased with their popularity.

Github activity for OxyPlot, an open source WPF Chart control

Github Activity for MPAndroidChart, open source Android charts

Github activity for LiveCharts Open Source WPF Chart control

Github activity for Charts, an Open Source iOS Chart control

Above you can see the Github activity of the four main open source chart components.

Below you can see our github activity. In contrast to the open source projects listed above, our development activity has increased; actually in the past two years it has really heated up since every day at SciChart we get new feature requests and demand for more improvements, better performance, compatibility with a new framework etc…

Github activity for SciChart, our enterprise WPF, iOS & Android Chart control

Figure 2: Development Activity on the SciChart Github repository

SciChart started as a project in 2012 and seven years later, we now have 14 developers now working full time on our WPF, iOS & Android charts. I cannot tell you how surprised I am (probably more surprised than you!) that charts (just X,Y values … on a screen … ) would take decades of effort…

So what does this mean for you?

If a new .NET Framework is released (Windows), new version of XCode, iOS, or Swift, a new Android SDK or Xamarin SDK is released then both commercial and open source charts have to be updated to be compatible. Sometimes a new device comes along and an application doesn’t work. Sometimes a critical bug occurs since an operating system or framework update and the chart component has to be fixed.

There is a risk you take when using any free open source or commercial chart control that the developer ceases to update their software, however, with SciChart that risk is minimized since our developer activity and popularity has been increasing over time.

When bugs are reported in our WPF Charts, iOS & Android Charts or Xamarin Charts we will aim to fix the serious ones as fast as possible, because they directly affect our customers, and therefore us!

That’s why we are charge a fee for what we do – we love free software and we think the open source chart developers do a great job, but in order to provide excellent software to you that is always up to date, fixed fast when there’s a problem and incorporating the latest features that you ask for then we must charge. We aren’t perfect, but this is our job and our livelihood and we have a strong incentive to work hard for you so that your projects are a success, plus, a good reputation to maintain!

Reason #4: Depth of Features

At SciChart, we only focus on charts. As a result, we strive to create a depth of features beyond when open source chart components are able to achieve and even beyond what many commercial vendors do too!

Take a look at the features matrix below to see what features SciChart can bring which open source components do not.

Feature SciChart MPAndroidChart iOS-Charts OxyPlot LiveCharts
2D Plots  
 
 
 
 
3D Plots  
*




Active, searchable forums  




Animation of Data  



 
Annotations on Chart  


 

Custom Series  




Custom Zoom or Pan behaviours  




Export / Print  
 
 
 

Fully Documented  




Hardware Acceleration  



 
High Performance & Realtime  




Link Multiple Charts  




Legend Customization  




Logarithmic Axis  


 
 
Multiple X-Axis  



 
Multiple Y-Axis  



 
Per-point colouring  
 
 


Programmatically Change Viewport  
 
 
 
 
Technical Support  




Theme or template customization  


 
 
Tooltips  
 
 
 
 
Touch Interaction  
 
 
 
 
Zoom and Pan  
 
 
 
 

Table 2: Feature comparison of SciChart vs. popular Open Source Chart components such as OxyPlot (WPF), LiveCharts (WPF), MPAndroidChart (Android) and Charts (iOS). *3D Support coming soon to Mobile

Key:

  • Means the feature is supported by the open source chart
  • Means the feature is not supported by the open source chart
  • Means there is limited support (requires workaround, or limited compared to SciChart)

The open source charts are in many cases, good enough for simple applications. If you want to just add a few low point-count 2D charts to your application, they can do the job. However, it’s the depth of features where SciChart really shines.

More on this below …

Reason #5: Flexibility

Most open source or commercial chart controls for WPF, iOS, Android provide the following standard features:

  • Many chart types (e.g. Line Charts, Scatter charts, Column Charts, Pie Charts)
  • Axis types (e.g. Date Axis, Time Axis, Numeric Axis)
  • Basic customisation features (e.g. TextFormatting, Themeing)
  • Inspection support (e.g. Tooltips, Legends)
  • Built-in zooming and panning

It would be easy to compare two chart libraries and see that they all support the above features and conclude ‘They’re the same’. Far from it.

With SciChart, you will find our API allows for complex customization is possible on nearly everything, and if we can’t support something, we will give a workaround, or, accept a feature-request for future development.

Here’s a selection of some of the deep features that SciChart supports which allow greater flexibility when creating charting applications for business.

  1. Series Selection
  2. Data-point Selection
  3. Axis label programmatic string-formatting
  4. Overriding of Axis gridline, label frequency
  5. Custom UIElement or UIView annotations and markers
  6. Per point colouring
  7. Custom interaction behaviours such as custom zooming, panning
  8. Custom Series
  9. Vertical charts
  10. Vertically Stacked Axis
  11. Central Axis
  12. Programmatically change zoom or pan
  13. Undo Redo of zoom
  14. Add Trendlines, best-fit curves, moving averages and splines
  15. Scrollbars on X,Y axis with preview of the chart behind

Its really hard to get these hidden features which provide excellent flexibility of our chart controls into a short list! These are just some of the flexibility options that SciChart has that open source chart controls and even commercial chart vendors do not have. Deeper features and more flexibility means you can get more complex requirements done quickly, which adds up to big cost savings over time, and ROI for your team.

Watch the video below to learn about 15 hidden features in our WPF Chart component to find out more:

Reason #6: Chart Performance

There are plenty of reasons why to choose and consider SciChart even if your application only needs to show modest dataset sizes. However, some of our users have very demanding performance requirements, and SciChart is capable of drawing many millions of points, update charts in realtime and with a low memory and CPU footprint on all the platforms that we support (iOS, Android, Windows/WPF).

We have created the fastest iOS charts & Android charts in the world (by a long way!), and one of the fastest, high-performance charts for WPF and Windows applications. Our charts are based on a hardware-accelerated rendering engine using DirectX (Windows), OpenGL ES (Android) and Metal (iOS) so that you get the fastest charting possible in your applications.

What does this mean to you? It means that SciChart makes impossible projects, possible.

We compared the performance of SciChart vs. some well known open source chart components, and discovered that our iOS & Android charts performed an order of magnitude faster than open source libraries (See iOS Chart Benchmarks and Android Chart Benchmarks). This means more data can be shown in your apps and previously impossible app ideas can now be realised. Our WPF Charts are also similarly fast compared to open source WPF charts. We are also working continually to make better gains in this area of performance and ensure that our charts are smooth and realtime in your applications.

When to choose SciChart vs. Open Source?

So given all of the above, when should you choose SciChart vs. an Open Source Chart component? There are some good arguments above, but you will find some more in the article seven reasons not to use Open Source. Some which are cited include:

  1. When proprietary software is easier to use
  2. When proprietary software offers technical support
  3. When proprietary software works better with your hardware
  4. When you need a vendor to stick around

In the article Open Source: What they’re not telling you there is further discussion to decide when to choose open source vs. a proprietary vendor.

In conclusion: when the requirement complexity is large, or the application is business critical, when features or performance matters and you need a component which is actively developed, you should definitely consider choosing SciChart for the charts in your enterprise applications!

SciChart vs. Open Source ROI Calculations

We’ve created some simple ROI calculations below to help you get an idea of the return on investment when purchasing SciChart. Some assumptions are made and no calculator is perfect!

If you consider the number of developers on your team, and the developer rate, you can get an idea of cost for your team’s time.

Next, estimate the time saved per developer per month. For example, conservatively estimating 1-hour a week saved from productivity, you might arrive at a figure of 4-hours per month. The actual figure could be higher in applications which are charting-heavy.

Finally, estimate the number of support incidents per year. Support incidents which are serious are rare, perhaps you will only get one or two a year, but each one might block your team for a long time if not resolved. So for example, estimate 2 days per year, but 16 hours of time lost per incident.

The calculator will output the return on investment for your purchase.

These are the results:

Number of developers on team 5
Developer rate / hour $60.00
Time saved (general productivity) per dev per month 4 hours
Time saved (general productivity) entire team per year 240 hours
Cost saved getting started / finding information / Year $14,400.00
Number of critical support incidents / year 2
Time saved for each critical support incident 16 hours
Cost saved for critical support incidents $1,920.00
Number of minor support incidents / year 10
Time saved for each minor support incident 4 hours
Cost saved for minor support incidents $2,400.00
Single SciChart License Cost $1099
Multi-Purchase Discount 30.00%
Cost of 5x SciChart Licenses for your team -$3,846.50
Total productivity costs saved $18,720.00
ROI ($) $14,873.50
ROI (%) 387%

Table 3: Estimated cost savings for a 5-developer team using SciChart

Of course, cost savings depend on many factors and the above doesn’t include the time you will spend learning the SciChart API, however we believe it will be quicker to learn SciChart than an alternative charting API.

Download the ROI Calculator here as an Excel Spreadsheet if you want to play around with the numbers. We have included both single-developer licensing costs vs. ROI as well as site-license costs vs. ROI.

SciChart licensing costs decrease over time

Please note, SciChart is licensed as a perpetual license with royalty free redistribution rights (see Licensing FAQ) and a support and updates subscription. The subscription is not mandatory after 1-year – you can still use SciChart after the support subscription ends, but you won’t be ale to access technical support or updates / bug fixes to the chart (see Renewals FAQ).

Our costs decrease over time as a 2nd year renewal of a support subscription costs just 50% of the 1st year. Your ROI for year two may be even greater.

Finally, you can, if you want, purchase the source-code to SciChart. If you want to modify it, then you have one of the main benefits of open source: ability to inspect, modify and develop the source-code of the chart control.

Best regards,
Andrew
[SciChart Team]

About SciChart: High Performance Realtime Charts.

SciChart provides high performance realtime chart components on the WPF (Windows), iOS, Android and Xamarin platforms. It is our goal to create the best cross-platform WPF, iOS & Android 2D & 3D charts in the world, focusing on performance, developer productivity, ease of use, depth of features and enterprise-grade tech support.

If you have a question about what SciChart can offer you, or if you would like to get a quote, please contact us. Our friendly, helpful support team will be glad to help!

 

The post Comparison of SciChart vs. Open Source Chart controls appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.


Read more »



Mar
12
SciChart iOS with Metal /Android / Xamarin v2.5 released!
Posted by Julia Skorobogata on 12 March 2019 03:07 PM

What’s New in SciChart iOS /Android /Xamarin v 2.5?

There is a large number of improvements and bug fixes made in SciChart iOS/ Android / Xamarin v2.5. It is recommended for all users of SciChart v2.2 to update to the latest version! Please see more information below.

New Features:
  • Metal Support for iOS Charts

SciChart iOS and Xamarin.iOS is now the first hardware-accelerated iOS Chart Control to support the Metal graphics API by Apple, which will replace OpenGL ES in future versions of iOS. By default, our charts render using OpenGL ES, but you can switch to Metal with the following line of code:

// in Swift:
surface.renderSurface = SCIMetalRenderSurface(frame: surface.bounds)

// in Objective-C:
self.surface.renderSurface = [[SCIMetalRenderSurface alloc] initWithFrame:self.surface.bounds];

//in Xamarin:
Surface.RenderSurface = new SCIMetalRenderSurface(Surface.Bounds);

Please note this code should be called after initialization of SCIChartSurface object, before creating any axis, series, or styles.

Also, it is advisable to detect if the current iOS version and the current device has the full support of all the Metal features used in SCIChart using the code below:

// in Swift
if SCIChartSurface.isMetalSupported {
   surface.renderSurface = SCIMetalRenderSurface(frame: surface.bounds)
}

// in Objective-C
if (SCIChartSurface.isMetalSupported) {
   self.surface.renderSurface = [[SCIMetalRenderSurface alloc] initWithFrame:self.surface.bounds];
}

//in Xamarin
if (SCIChartSurfaceView.IsMetalSupported) {
   Surface.RenderSurface = new SCIMetalRenderSurface(Surface.Bounds);
}

This will ensure compatibility on older phones. (Link to Documentation).

We would recommend testing on multiple devices before deploying any apps to the App Store with the new Metal render surface. The OpenGL surface is fundamentally the same and considered the best choice for production apps at this time. Finally, we would really appreciate your feedback on the new Metal renderer.

  • New iOS and Android Documentation

The documentation for iOS Charts and Android Charts now has a new stylish theme, so it is easier and more pleasant to read. We have also taken care of making it easier to find just what you need via Google using Title tags and structured data. It is responsive and works great on all devices including tablets and mobile. There have been many small corrections and improvements made to the documentation and there is more to come!

Bug Fixes for iOS:
  1. Updated: bindings of SCIMetalRenderSurface to have a proper constructor
  2. Fixed: append and FIFO test cases for SciChart
  3. Fixed: memory leak on OpenGLRenderSurface deallocation Made SCIChartSurfaceViewBase.renderSurfafe property strong to avoid warning
  4. Added: allowing to draw outside of the main scene/end scene sequence + create the regular polygon texture once they are required + comment on the pre-creation;
  5. Fixed yellow triangles in point markers example: new drawing command for raw triangles
  6. Fixed: errata in swift example for scatter series
  7. Fixed: global angle for AquireRegularPolygonSprite
  8. Fixed: brush initialization
  9. Fixed: styling/theming examples
  10. Fixed: Multi-stack chart: use a projection matrix that doesn’t clip in screen space; gradient texture areaways horizontal ( width x 1 ); gradient texture need clamp sampler; approximate the output to match OpenGL by modulating the alpha of the gradient colors.
  11. Fixed: columns don’t appear in swift examples due to long* conversion to SCIGenericType
  12. Fixed SWIFT: heatmap chart example
  13. Fixed for Metal: crash with logarithmic axis where there were no major ticks
  14. Fixed: heatmap red spots issue
  15. Fix for Metal: broken line colors ( fade should be on alpha )
  16. Fixed for Metal: gaps between lines, new metal shaders, also AA lines should only be fading with Alpha on its edges, this way we can evade the 1.5 hackexp fixes for lines in metal
  17. Fixed for Metal: spline line examples
  18. Fixed for Metal: setting wrong screen size to global shader content
  19. Fixed: the multi-surface example, by making sure the correct width and height are passed down
  20. Fixed for Metal: ellipses example crash
  21. Fixed: black screen while app in the background
  22. Added display link to metalRenderSurface to bring back animations
  23. Removed obsolete methods on renderSurface Metal
  24. Multi sampling 4x enabled and 2x multi sampling
  25. Fixed for Metal: drawing of grid-lines\bands with properly saving\restoring matrix state
  26. Fixed: SetDrawingArea command
  27. Fixed for Metal:  errata in SetClipRct and updated Translate code
  28. Fixed for Metal: scaling for lines
  29. Fixed: memory leak in HeatMap chart examples
  30. Fix for Metal: lines thickness to match with OpenGL
  31. Fixed: black bar at the bottom (iPhone X)
  32. Fixed for Metal: Colormap
  33. SCIOS-792: fixed SCICustomAnnotation can’t be selected; Also improved moving it and scaling using available anchor points
  34. SCIOS-791: fixed Pie\Donut series segmentSpacing is ignored
  35. Fixed for Metal: HeatMap Example
  36. Fixed for Metal: Using Point Marker example
  37. Updated forMetal:  Xamarin.iOS bindings to work with Metal integration
  38. Added: new example that shows how to leave rollover on-screen
  39. Fixed: incorrect type of RenderSurface interface
  40. Fixed: Custom Legend Placement
  41. Fixed:  updating renderableSeriesAreaBorder / renderableSeriesAreaFill styles on SCIChartSurface
  42. Fixed: incorrect Call of formatXCursorValue
  43. SCIOS-609: fixed making one stacked in the group invisible makes the whole group invisible
  44. SCIOS-712: fixed cursor modifier shouldn’t show labels on hidden axes
  45. SCIOS-711: fixed ZoomPanModifier shouldn’t trigger inertia if velocity is very low (very gentle swipe)
  46. Fixed and enabled displaying of ARC -related warnings
  47. Fixed: crash on “show source code” feature in example demo
  48. Fixed: Tooltip on RolloverModifier appear outside the Chart area
  49. Improved: SCIRolloverModifier layout to fit chart bounds whenever it’s possible
  50. Updated: pen style in Xamarin.iOS
  51. Added: missing ctor which isn’t inherited from protocol in Xamarin.iOS
  52. Updated: heatmap examples in Xamarin.iOS
Bug Fixes for Android: 
  1. SC_DROID-654: extended need to draw check in AxisTitleRendererComponent to cover the case when axis title is an empty string;
  2. SC_DROID-653: fixed incorrect values displayed by axis tooltips in CursorModifier when using custom layout axis layout such as vertically stacked YAxes;
  3. SC_DROID-652: added handling of the vertical chart for Horizontal/VerticalLineAnnotation;
  4. Fixed: incorrect work of AnnotationCreationModifier when the chart is vertical
  5. SC_DROID-649: replaced invalidateElement() on invalidateLayout() when modifying series collection because series affect layout of pie/donut chart
  6. SC_DROID-650: modified rendering of pie and donut charts – added code which splits arc into two parts to ensure that it will be rendered;
  7. Fixed missing jar name in path to support-annotations; updated to Android 27; updated instructions;
  8. Fixed incorrect parameter in scroll() implementation for axis
  9. SC_DROID-612: fixed incorrect hit test results if xAxis has flipped coordinates – added isCoordinatesSortedAscending() flag for render pass data which is used for findIndex() call with xCoordinates;
  10. Fixed: wrong ColumnPaletteProvider, when colors changed during scrolling of chart;
  11. SC_DROID-607: updated AxisTitleRendererComponent to correctly handle RTL title;
  12. SC_DROID-599: changed LazyGLTexture which should prevent possible NullPointerException in case of any race conditions
  13. SC_DROID-598: added notification about changes of axis layout when settings axis title orientation and placement;
  14. SC_DROID-501: refactored AxisTickLabelsRendererComponent to correctly render multiline tick labels;
  15. Fixed: issue with aapt2-proto library when building a project on new PC where there is no cached version of the library – reordered repositories which are used for downloading dependencies;
  16. Fixed Tooltip on RolloverModifier appear outside the Chart area
  17. SC_DROID-596: improved layout of rollover tooltip to prevent clipping of tooltip at the bottom if there is enough space to place it a bit higher;
  18. SC_DROID-596: refactored VerticalSliceBehaviorBase to allow to override layout of rollover tooltips by creating custom SliceLayout.

Where to get iOS / Android / Xamarin v2.5?

You can get the SciChart iOS/Android/ Xamarin SDK v2.5 from the Downloads page. Source code customers can also get the latest from our Github repository as well as from Cocoapods for iOS, and Maven for Android. We also keep on delivering continuously for bug fixes, features and minor updates to the following package sources.

In addition, our example code is published to Github and is available to clone or download.

Download SciChart iOS/Android / Xamarin v 2.5

Best regards,
SciChart Team

The post SciChart iOS with Metal /Android / Xamarin v2.5 released! appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.


Read more »



Oct
18
SciChart iOS /Android / Xamarin v2.2.1 released!
Posted by Julia Skorobogata on 18 October 2018 11:42 AM

We are really excited to announce, that SciChart iOS/ Android / Xamarin v2.2.1 is released! 

What’s New in SciChart iOS /Android /Xamarin v 2.2.1?

There is a large number of improvements and bug fixes made in SciChart iOS/ Android / Xamarin v2.2.1. We have made many improvements and bug fixes, major memory leaks have been fixed. It is recommended for all users of SciChart v2.1 to update to the latest version! Please see more information below:

Changes:
  • Made SCIChartSurfaceProtocol conform to SCIChartControllerProtocol
  • Logarithmic axis zoom extents is fixed by SCILogarithmicVisibleRangeAnimator
Bug Fixes:
  • SCIOS-626: Fixed HorizintalLineAnnotation and VerticallLineAnnotation are not clipped by axes and are drawn over them
  • SCIOS-642: Fixed issue with on resize of the SCIChartSurface, lay out the axis labels
  • SCIOS-637: refactored internal scroll and removed velocityValue from improper places, fixed crash caused by SCILogarithmicDoubleCoordinateCalculator not having implemented getVelocityValueFrom
  • SCIOS-672: Fixed chart sync crash (EOG) – caused by TooltipShowOnTouch
  • SCIOS-596: Fixed Error during rendering of the first point when ifDigitalLine = true
  • Fixed major memory leaks in SciRenderable series
  • SC_DROID-558: added check to prevent exception during generation of minor ticks if there are no major ticks
  • SCIOS-682: Fixed iOS annotations seem to update independently from the data series
  • SC_DROID-562: Fixed memory leak in SpritePointMarker when textures were constantly recreated and never properly disposed because of wrong texture hash
  • SC_DROID-564: Fixed incorrect drawing of axis tick label – because StaticLayout had not enough space to fit label in one string so some labels were drawn as two lines of text;
  • SC_DROID-566: Fixed some logcat errors when OpenGL code was called without OpenGL context
  • Fixed SCIOS-687 – surface.Annotations.Clear() doesn’t clear all annotation from surface.
  • SC_DROID-568: Fixed exception because of how onSurfaceCreated() is implemented in GlSurfaceView ; refactored OpenGL renderer to avoid exception because of missing native memory chunk and made it resizable; also moved OpenGL programs creation so they are created only once
  • Fixed SCICustomAnnotation position in chart wrong
  • Fixed SCIXAxisDragModifier stopped working
  • Fixed SCILegendModifier: SCIDefaultLegendItem cell ambiguous width
  • Fixed text annotation formatting
  • Fixed exception if enable debug prints for CubicSpline
Improvements:
  • SC_DROID-566: improving OpenGL start up time – changed GLProgram implementation and made it lazy so we don’t initialize all shaders at once when render surface created
  • SC_DROID-565: added additional render pass data locks to ensure that it won’t be changed from another thread when applying transformation
  • Added default style values for PieSegment; added some common methods for PieSegmentBuilder
  • SC_DROID-563: rewritten GLTextureView rendering from scratch – now it uses Handler + Choreographer to schedule redrawing of render surface when VSync occurs in Android
  • Made custom annotations to support AnchorPoint alignment
  • SC_DROID-578: added propagating of listeners to child series for StackedSeriesCollectionBase
  • SC_DROID-561: added synchronized wrapper for SimpleDateFormat to prevent exception when same instance is accessed from different threads, applied the same approach to prevent possible exceptions when using DecimalFormat

Where to get iOS / Android / Xamarin v2.2.1?

You can get the SciChart iOS/Android/ Xamarin SDK v2.2.1 from the Downloads page. Source code customers can also get the latest from our Github repository as well as from Cocoapods for iOS, and Maven for Android. We also keep on delivering continuously for bug fixes, features and minor updates to the following package sources.

In addition, our example code is published to Github and is available to clone or download.

Download SciChart iOS/Android / Xamarin v 2.2.1

The post SciChart iOS /Android / Xamarin v2.2.1 released! appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.


Read more »



Jul
25
Coming Soon to SciChart Q3/Q4 2018
Posted by Julia Skorobogata on 25 July 2018 01:08 PM

We’ve been quietly working away on a few projects for the past few months and wanted to give you an update to show you where SciChart will be going in the near future.

What’s Coming Soon to SciChart WPF?

SciChart WPF remains our flagship product and drives a lot of development, alongside tech support & maintenance (we have answered 692 support tickets for SciChart WPF and released 166 Nightly builds in the past year alone). We are still developing this product adding new features as our userbase requests and also features that are in strong demand.

Some of these are nearly ready for release and are listed below.

WPF New Chart Type: Free Surface Mesh 3D

A new Free Surface Mesh 3D feature will be presented in the upcoming release which will be SciChart WPF v5.2 (Q3 2018).

Free Surface Mesh 3D is a set of 3D charts that plot a surface mesh in 3D space. This chart type allows plotting closed objects in 3D that are not restricted by data laying down in the XZ plane. The charts can render different types of data including ellipsoid, cylinder, polar and even custom free surface mesh data in 3D. Please see the preview of the examples below:

scichart-surface-mesh-3D-custom-free-surface-mesh-data

Free Surface Mesh 3D with custom data

scichart-surface-mesh-3D-cylinder-data

Free Surface Mesh 3D with cylinder data

scichart-surface-mesh-3D-polar-data

Free Surface Mesh 3D with polar data

scichart-surface-mesh-3D-ellipsoid-data

Free Surface Mesh 3D with ellipsoid data

WPF New Feature: WPF Polar chart 3D

One of the chart types listed above is a 3D Polar Chart type, which allows for a flat disk with optional hole in the center defined by an equation and 2D array of data, contours, and paletted similar to a heatmap or surface-mesh chart. This chart type can be used in 3D mode or when an orthogonal overhead camera is presented, as a 2D Chart.

All new 3D Chart types will be made available to all customers of SciChart WPF SDK Professional, SDK Enterprise and 3D Professional who are in support subscription, free of charge. 

WPF New Feature: Drawing tools and Technical Indicators for trading applications

SciChart is widely used in trading and financial applications by our customers. Since a number of customers approached us to ask for these tools to be built, we have decided to make a step forward with a set of drawing tools for different patterns in trading.

The next release is expecting to bring a number of new annotation types to be used in trading systems, including:

  • Elliott Wave pattern
  • XABCD (Gartley / Bat / Harmonic polygon shapes) drawing
  • Head and Shoulders Pattern
  • Andrew’s Pitch Fork
  • Fibonacci Retracement
  • Fibonacci Extension
  • Also, we will be adding free brush style drawing to mark up the chart.

All of the following can be created programmatically, on user click, edited & dragged about, styled and persisted.

Please see some examples below:

scichart-elliott-wave-pattern-trading-tool

Elliott Wave Pattern, Trading Tools

scichart-xabcd-pattern-trading-tool

XABCD Pattern, Trading Tools

scichart-head-and-shoulders-pattern-trading-tool

Head and Shoulders Pattern, Trading tools

scichart-pitch-fork-pattern-trading-tools

Pitch Fork Pattern, Trading Tools

scichart-fibonacci-retracement-trading-tool

Fibonacci Retracement Trading Tool

scichart-fibonacci-retracement-extension-trading-tool

Fibonacci Retracement Extension Trading Tool

scichart-free-brush-drawing-trading-tools

Free Brush Drawing, Trading Tools

All new drawing tools will be in the SciChart.DrawingTools.dll package and will be made available to all customers of SciChart WPF SDK Professional, SDK Enterprise and 2D Enterprise who are in support subscription, free of charge. These drawing tools will not be available to SciChart WPF 2D Professional customers. 

What’s next in SciChart iOS / Android / Xamarin?

SciChart iOS & Android has been moving along with some progress to support latest SDKs but behind the curtain we are working on our big vision of having 2D & 3D Charts available on all native platforms, including Windows, Mac OSX, iOS, Android and with Xamarin & Xamarin Forms support.

Our next big piece of work is to bring 3D Charts to iOS & Android devices, which we have been working on quietly for the past year 
						<br />
						<a class=Read more »




Jul
12
SciChart iOS /Android / Xamarin v2.2 released!
Posted by Julia Skorobogata on 12 July 2018 01:14 PM

We are really excited to announce, that SciChart iOS/ Android / Xamarin v2.2 is released! 

What’s New in SciChart iOS /Android /Xamarin v 2.2?

There is a large number of improvements and bug fixes made in SciChart iOS/ Android / Xamarin v2.2. We have made a major step forward by refactoring of our examples, fixing memory leaks, crashes, and bugs and other improvements. It is recommended for all users of SciChart v2.1 to update to the latest version! Please see more information below:

Important Changes 
  • iOS Charts have been made compatible with Xcode 10 and iOS 12 by removing deprecated libstdc++ with libc++. SciChart iOS v2.2 no longer uses this library and will work with future version(s) of iOS & Xcode.
  • Android Charts showcase demo and examples project has been updated to work with Android Studio 3.1: updated to Gradle 4.4; updated to SDK 27 ( Oreo ).
  • Android library has been updated to support library 27.1.0 and Kotlin 1.2.30
Bug Fixes:
  • Fixed hitTestAxis method which caused issues with axis tooltips values
  • SCIOS-626: fixed annotations don’t clip by axes and drawn over them.
  • SCIOS-639: fixed annotation added after chart initializing is not being rendered
  • SCIOS-640: fixed Incorrect casting from Swift.Array<Double> to SCIGeneric
  • SC-DROID-526: fixed incorrect rendering of RTL text caused by trying to reuse text layout ( it was defined it with Integer.MAX_VALUE width )
  • SC-DROID-525: fixed incorrect text rendering in heatmap ( added flipping of x and y coordinates if the chart is vertical )
  • SCIOS-624: fixed placing annotations below chart doesn’t work
  • SC-DROID-521: fixed incorrect work of sweep animation with PaletteProvided which was caused by adding new points into render pass data
  • SC-DROID-522: refactored PieSegment and PieDonutRenderableSeriesBase to correctly handle case when PieSegment changes;
  • SC-DROID-520: fixed incorrect hit test which is caused by updating xValues and yValues but not indices:
    • now render pass data remains the same and we just draw spline lines and perform hit test on original data;
    • updated spline calculations which resulted in all NaN values – added n parameter to prevent going outside renderPassData bounds if x/yValues array are larger than
    • actual renderPassData size; removed unused code from spline calculations;
    • changed SplineLineRenderableSeries: now we calculate spline coords for coordinates instead of values right before drawing for correct work of animations;
    • Added behavior options for tooltip modifiers; and added bindings.
  • Fixed: issue in legendDataSource.
  • Fixed: crash during measuring custom legend item is using a custom nib file from the main bundle.
  • Fixed: addPointsPerformance demo example
  • Fixed: crash when try using custom legend item nib file from the main bundle.
  • Fixed: getter for color in gradient brushes.
  • SC-DROID-518: fixed incorrect rendering of rects when use RenderSurface – it was caused by incorrect points index
  • Fixed: memory leak in renderableSeries base
  • Fixed broken units tests: removed usage of reflection for getting parameter names and replaced it on Mono.Cecil which allows doing the same but without loading dependencies of assembly;
  • SC-DROID-511: Fixed cursor tooltip which wasn’t shown for the second half of the last candle in series;  changed calculations in HitTestHelpers.isPointWithinXBounds() to prevent precision problems when performing hit test
  • SC-DROID-513: fixed incorrect layout of horizontal legend – added usage of HorizontalScrollView when legend has horizontal orientation
  • Fixed warning: atomic property cannot pair a synthesized setter/getter with a user-defined setter/getter
  • Fixed: color of marker view of legend item
  • Fixed: broken test by using a proper calendar in SCIDateUtil instead or using NSCalendar currentCalendar
  • Fixed: flickering of the edge labels (also hiding them sometimes)
  • Fixed: error when sometimes onVisibleRangeChanged() wasn’t called at the end of animation; added setMinMaxForced into IRange to set new Min/Max values even if they are equal to current Min/Max values + added tests
  • Fixed: non-working onVisibleRangeChange method in IViewportManager; modified unit tests;
  • Fixed: incorrect buildToolsVersion and updated SciChart dependencies to v2.1 in exported projects
  • Fixed: broken parameter names generation in Xamarin: updated path required for metadata generator;
  • SC-DROID-509: fixed incorrect drawing of pie and donut charts when there is only one segment; refactored drawing code;
  • SCIOS-622: fixed hitTest doesn’t work properly with categoryDateAxis
  • Fixed: SCIChartHeatmapColourMap while creating from xib
  • SC-DROID-503: fixed rounding error when formatting label in LabelProvider for the category axis
Improvements:
  • Added: main.storyboard and launchScreen back to the project
  • SCIOS-623:  refactoring swift examples:
    • refactored speedTesting, hitTest, zoomandPan groups;
    • refactored: styling and theaming group, axis behaviour group, ECG chart, oscilloscope chart, realtime ticking stock chart, stock chart example, multipane stock chart example, realtime chart examples, multi-series chart examples, gauge chart examples, pie and donut series, using themeManager example, and custom charts examples;
    • added common Init method to ExampleViewBase which supposed to contain commonViewINItialisation;
    • added labelProvider to columns side-by-side examples;
  • SCIOS-625:  legend changes:
    • updated Xamarin.iOS bindings and examples;
    • added property which allows dequeuing custom legend items from UICollectionView;
    • refactored updated\changed methods in dataSource;
    • added handling of legendPosition
  • Removed duplicate declaration in h file (already defined in protocol). Also named file properly
  • Added attach To and detach methods to SCIPieSegment
  • Added handling of showCheckBoxes and seriesMarkers
  • Added: SCIChartLegendHorizontalLayout which allows the legend to wrap it’s content horizontally.
  • Added: SCIChartLegendVerticalLayout which allows legend to wrap it’s content; Removed redundant code
  • Added: ctors to h file
  • Added missing ctors for SCISeriesInfo inheritors
  • SC-DROID-510: added correct handling of tooltip placement when a chart is rotated; changed SliceLayout to prevent overlapping of rollover tooltips
  • Added maxAsDouble and minAsDouble to omit conversion calls to SCIGeneric and SCIGenericDouble, even when use asDoubleRange; made asDoubleRange deprecated;
  • Updated swift demo app labelProviders according to recent changes, reverted accidentally commented out deprecated properties in tooltip modifier styles
  • Added: inMinMaxValid method into ranges
  • Added: themeId to SCIThemeColorProvider
  • Made SCIRenderableSeriesProtocol conform to SCIInvalidatableElementProtocol
  • Changed: SeriesInfo seriesColor is now of type UIColor and isn’t nil every time
  • Refactored: default ViewportManager to handle AutoRange.Always case in tryPerformAutoRange instead of onUpdateAxis; updated tests;
  • SC-DROID-480: Added ClipModeTarget which allows specifying target range which will be used for clipping in ZoomPanModifier and XAxisDragModifier; fixing typo in name of setClipModeX method in modifier builders;
  • SC-DROID-505: added correct disposing of resources for OpenGL based RenderSurface implementations; removed onSurfaceDestroyed method because it wasn’t actually called anywhere
  • Changed: default values for pie\donut charts – drawLabels and spacing
  • Reworked speedTest examples as well as modifyAxisBehaviour ones.
  • Moved missing ctors to SCIArrayController from SCIArrayControllerProtocol
  • Created view from xib files
  • SC-DROID-506: added usage of Path instead of simple drawLine to provide correct handling of dashed lines in modifiers.

Where to get iOS / Android / Xamarin v2.2?

You can get the SciChart iOS/Android/ Xamarin SDK v2.2 from the Downloads page. Source code customers can also get the latest from our Github repository as well as from Cocoapods for iOS, and Maven for Android. We also keep on delivering continuously for bug fixes, features and minor updates to the following package sources.

In addition, our example code is published to Github and is available to clone or download.

Download SciChart iOS/Android / Xamarin v 2.2

The post SciChart iOS /Android / Xamarin v2.2 released! appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.


Read more »



Feb
24
SciChart iOS /Android / Xamarin v2.1 released!
Posted by Julia Skorobogata on 24 February 2018 12:05 PM

We are really excited to announce, that SciChart iOS/ Android / Xamarin v2.1 is released!

If you are using SciChart iOS v1.x or Android v1.x then please note that this update introduces breaking changes and is not a drop-in replacement for SciChart iOS/Android v1. 

What is new in SciChart iOS / Android / Xamarin?

New Features
  • SciChart iOS Swift 4 support:

Although we have unofficially supported Swift 4 for a while via our Github and Cocoapod feeds, this official release now includes support for SWIFT 4. The documentation and the examples have been updated.

  • SciChart Xamarin now supports Xamarin 11.
  • SciChart Pie Chart, SciChart Donut Chart and SciChart Nested Chart types are added to both iOS and Android.

Pie, Donut and Nested Charts are very popular in dashboards, sales reports and many other applications. These are found useful when there is a need to  compare the giving category with the total in one chart. Please see SciChart iOS and SciChart Android examples for these charts. Xamarin.iOS and Xamarin.Android Bindings are added for the above chart types as well.

SciChart iOS Pie Chart

SciChart iOS Pie Chart

SciChart Android Pie Chart

SciChart Android Pie Chart

SciChart iOS Donut Chart

SciChart iOS Donut Chart

SciChart Android Donut Chart

SciChart Android Donut Chart

SciChart iOS Nested Pie Chart

SciChart Android Nested Pie Chart

SciChart Android Nested Pie Chart

 

  • SciChart Animations function

We have added animation functions to charts, to let you fade, sweep, or bounce data when data is first added to the chart or when data-points are added. The animations engine is very flexible and powerful and gives your iOS & Android charts that awesome look & feel you are looking for. Be the first one to try those out and make gorgeous applications with SciChart iOS/Android Animated Charts:

 

scichart-logarithmic-chart-animatedscichart-pie-chart-animatedscichart-android-column-chart-animated

 

  • SciChart Trader Showcase

With the high demand in financial applications we have replenished our SciChart Showcase with the Trader Example. It shows how to have multiple chart panes in the application, that are synchronized. There are common candlestick charts combined with the column, band series and volume shown at the main pain at the bottom. You may see how to use the different timescales 5 minutes, 1 hour, 1 day or 1 week. The moving average is there for the demonstration purposes. You may also zoom, pan, show cursor on tap and see the latest values on the chart. You can access the Showcase from our GitHub: SciChart iOS Trader ShowCase and SciChart Android Trader ShowCase.

SciChart-Android-Trader-Demo

SciChart Android Trader Example

SciChart-iOS-Trader-Demo

SciChart iOS Trader Example

Bug fixes and other improvements: 
  • Updated tutorials to cover more on styling, visible range and annotations. Added new articles on new chart types.
  • Fixed bug Axis visible range limit with inertial scroll;
  • SCIOS-575: Fixed broken legend modifier;
  • SCIOS-570: Fixed DataSeries with one element to show at iOS 9 and iOS 10;
  • SCIOS-571: Axis marker annotation crash when position is NaN;
  • SCIOS-483: Fixed and improved StackedColums hit test;
  • SCIOS-594: Added ability to change opacity of renderable series;
  • SCIOS-584: Fixed Xamarin.iOS crashes when using custom label provider;
  • SCIOS-489: Fixed  Xamarin.iOS inertial scroll does not stop on Tap;
  • Add property which allows to set margin for Axis title;
  • Horizontal/VerticalLineAnnotation: NPE if try to set Axis id, it isn’t attached to parent surface and has AnnotationLabe;
  • Axis Title: Add support of flipped vertical AxisTitle;
  •  NPE when Annotation is selected and try to remove it from chart;
  • SC_DROID-450: Stacked Column Side by Side: Exception when all stacked series invisible;
  • SC_DROID-447: Stacked Column Side by Side: Tooltip throws exception if series is invisible;
  • SC_DROID-444: OpenGL error when trying to draw PenStyle with thickness == 0;
  • SC_DROID-486: Incorrect drawing of lines in Canvas RenderSurface;
  • SC_DROID-485: Stacked Column Chart example throws exception on launch;
  • SC_DROID-483: AxisMarkerAnnotation: Incorrect export to Bitmap;
  • SC_DROID-482: PinchZoomModifier: Incorrect zoom because of NaN scale factor with non uniform zoom;
  • SC_DROID-476: ArrayIndexOutOfBoundsException when insert in empty SciList;
  • Updated the code on SCSStylingChartView, StylingChartView to present brushes, styles first then application to axis second. Made styles more consistent with WPF Chart Styling example;
  • Fixed clipping behavior of text annotationAdded documentation: Pen, Brush, Texture – LabelProvider- TextFormatting – Convert Pixel to Data CoordinatesDocumentation updates for Axis types in SciChart, Axis Ranging: AutoRange, Aixs Ranging – Clipping and Value Axis vs. Category Axis;
  • Fixed candlestick issue with swapping colors when drawing reduced data;
  • Fixed memory leak;
  • Add ability to change time zone of date formatter in date label provider;
  • Fixed annotations’ detachSciChartframework – fix inertial scroll in case when xAxis and yAxis are swapped;
  • Fixed scroll when clipModeX is stretchAtextents or clipAtExtents and growBy is nil;
  • Fixed: Color of mountain series does not respect color in legend modifier;
  • GrowBy and inertial scroll when pan modifier is stretchAtExtents;
  • Fixed vertical line axis label alignment;
  • Fixed in axis and axis labels visibility;
  • Fixed dashed line for multiple context;
  • Fixed axis marker theme settings, add ability to change theme in trader demo;
  • Added dashed line for line annotation;
  • Fix axisMarker crash, when position is nan;
  • Fixed issue with stretched line annotation panFixed bug with parsing UIView hierarchy in Xcode.
  • SCIOS-612 – Fixed memory leak related to retain cycle of renderableSeries and animations.

Other news

We are working further port our desktop WPF 3D Charts to iOS/Android, and have a working prototype of 3D scatter, bubble, column, surface mesh and pie charts working on the iOS & Android Platform. If these are of interest to you, or if you have any other feature requests, get in contact as we would be glad to hear your feedback!

Where to get iOS / Android v2.1?

You can get the SciChart iOS/Android/ Xamarin SDK v2.1 from the Downloads page. Source code customers can also get latest from our Github  repository as well as from Cocoapods for iOS, and Maven for Android. We also keep on delivering continuously for bug fixes, features and minor updates to the following package sources.

In addition, our example code is now published to Github and is available to clone or download.

Download SciChart iOS/Android v 2.1

 

Finally

We hope you will enjoy this edition, we are looking forward to hearing your feedback!

Contact Us

 

Best regards,

SciChart team

The post SciChart iOS /Android / Xamarin v2.1 released! appeared first on Fast, Native Chart Controls for WPF, iOS, Android and Xamarin.


Read more »




CONTACT US

Not sure where to start? Contact us, we are happy to help!


CONTACT US

SciChart Ltd, 16 Beaufort Court, Admirals Way, Docklands, London, E14 9XL. Email: Legal Company Number: 07430048, VAT Number: 101957725