dbabacan / core-plot Goto Github PK

As shown by failures in -[CPTextStyleTests testDefaults], the static instance 
of CPTextStyle returned 
by -[CPTextStyle defaultTextStyle] can give unexpected style when used by 
multiple clients.

-[CPTextStyle testDefaults] should return a new instance of CPTextStyle (with 
appropriate defaults) 
from each call.

Please, add a way to add a pair of axes (or just another y-axis) in a
fashion like on this picture:
http://www.yuvalararat.com/wp-content/uploads/2008/09/2y_axis_graph.gif 

Also see the discussion here:
http://groups.google.com/group/coreplot-discuss/browse_thread/thread/ee18ee23415
13d28

At the moment there are only two types of axis labeling: ad-hoc, where the user 
does the labeling 
themselves, and 'fixed interval', where the user picks a fixed point, and fixed 
interval between ticks.

Probably the most important labeling though is a fully automatic version. That 
is, the user can 
choose to target a particular number of ticks along the axis, and the framework 
will automatically 
relabel the axis, trying to attain that number as closely as possible while 
maintaining nice round 
values. 

An algorithm for doing this can be found in the Narrative project. I believe 
the file is 
NRTFloatDiscretizer or some such.

The NSDecimalNumber variables in  [CPAxis tickLocationsBeginningAt]  appear
to rely on NSComparisonMethods protocol, which (I believe) is not defined
in the iPhone 2.0 or 3.0 beta SDK.

Detected with a MacBook Intel/OSX 10.5/Xcode 3.1.3

Use Case:
User runs unit tests, generating a set of output files (TIFF or encoded state) 
corresponding to failed 
comparisons or new tests.

If any tests fail, a UI tool is opened following the test run. This tool 
searches the default output 
location for output files. The tool presents a list of each output file. User 
selects files from the list. 
The selected file's contents are shown in the UI tool, along with the contents 
of the existing 
rendering/state (in Unit Test bundle). For each file, if an existing version 
exists, the user may select 
to keep the existing version or to replace the the existing version with the 
new version. For outputs 
with no existing version, the user may select to add the new version or skip.

Additions to use case:
User may change the folder the UI tool searches for output files using standard 
OS X NSOpenDialog.

-[CPXYGraphTests testRenderScatterWithSymbol] renders as a black line, rather 
than the expected 
green-symbols.

For core plot to succeed, the barrier to entry should be as low as possible. To 
make it as easy for a 
developer to create an attractive graph as possible, factory methods and/or 
theming classes should 
be introduced which allow someone to create good looking graphs with the 
minimum of fuss. This 
would effectively be a library of graph styles, similar to quartz composer or 
core image.

Themes could be stored in property lists, and loaded into a CPTheme class. The 
class could then be 
used to style an existing graph, or create a new one.

Users could also create their own themes, and instantiate a new CPTheme from a 
file.

From the mailinglist:

On Sat, Jun 6, 2009 at 7:49 AM, Dirkjan
Krijnders<[email protected]> wrote:
Hi,
I figured I try it on core-plot since it is already integrated. However
building (of TestMerge) first failed because my mogenerator was too old. I
had 1.5 and TestMerge uses features from 1.10. After that was fixed it
compiled, but the core-plot project tries to start it from another location:
/Users/dirkjan/Projects/core-plot-clean3/framework/build/CorePlot.build/Debug/Co
rePlot-
UnitTests.build/Script-4C37799C0FD87A8B00BA848A.sh:
line 7:
/Users/dirkjan/Projects/core-plot-
clean3/framework/build/Debug/TestMerge.app/Contents/MacOS/TestMerge:
No such file or directory
While the binary is at:
/Users/dirkjan/Projects/core-plot-
clean3/TestMerge/build/Debug/TestMerge.app/Contents/MacOS/TestMerge
Fixing this location made it work.
Apparently ${BUILT_PRODUCTS_DIR}/ points to the build dir of the core-plot
stuff, while TestMerge is build in its own build dir. I don't know enough of
the XCode build system to fix this, but someone else surely does.

Ah, yes. I have Xcode setup to build everything in one directory - it
makes things like this much easier. The default is to build in each
project in a build directory within the project directory, which will
clearly break running TestMerge this way. I'll have to think a bit on
how to handle this. The obvious thing is to install a test TestMerge
and not build/run it from source, but that just adds one more step to
getting started. Maybe others have thoughts?

Also, it would be nice to alleviate the boringness of TestMerge when
all tests pass. I haven't figured out how to skip the TestMerge run
script build phase if all tests pass, but again, maybe others have
suggestions. At the very least, I should have TestMerge quit if there
are no GTM output files to merge.

Thanks for giving it a try!

Cheers,
Barry

Currently, CPScatterPlot has a mix of different design patterns. It can use 
bindings or data source 
to get data, like NSTableView. But other data related aspects of CPScatterPlot 
are not adhering to 
the standard patterns.

The setSymbol:atIndex: method is a good example. The problem with this method 
is that it 
pushes data from the data source to the plot, rather than having the data be 
pulled into the plot. 
A better approach would be to provide an optional CPScatterPlot data source 
method that 
allowed the user to customize what symbol should be used for each plot point 
(analogous to the 
UITableView on iPhone called tableView:cellForIndexPath:...)

Method could be: 
-(CPSymbol *)scatterPlot:(CPScatterPlot *)plot symbolForIndex:(NSUInteger)index;

When using bindings, the user could either make use of this data source method, 
or just settle 
for a single plot symbol at every point (using setSymbol:)

What steps will reproduce the problem?
When creating a normal graph, the axis label position is not proper. I have 
attached one sample 
screen. I am using the framework in iphone

Purpose of code changes on this branch:

The purpose of this branch was to incorporate unit testing capabilities from 
the Google Toolbox for 
Mac and to establish an automated testing framework for CorePlot. 

To accomplish this task, I added an svn:externals to the top-level CorePlot 
directory to retrieve the 
Google Toolbox for Mac from SVN. I added the GTM sources to the CorePlot 
frameork project (GTM is 
meant to be used source-direct, rather than linking the entire framework, 
especially when developing 
a framework instead of a stand-alone app). I created a CPTestHarness target in 
the framework project. 
This simple app serves as the test host for the unit tests. I finally added a 
CorePlot-UnitTests target. 
Unit test cases should subclass CPTestCase and be added to the UnitTests 
bundle. See 
framework/TestResources/GTM_notes.rst for notes on writing tests.

Building the UnitTests bundle will build CorePlot and run all unit tests. Test 
can be debugged using 
the CPTestHarness executable (run with option-cmd-Y after building the 
UnitTests bundle).

Once this branch is accepted, I will write up a best-practices document for 
testing in CorePlot. Next, I 
intend to write a UI to make managing the state & rendering tests easier.


When reviewing my code changes, please focus on:

Making sure UnitTests bundle builds on your machine and all tests (currently 
only an example in 
CPPlotAreaTests) passes.


After the review, I'll merge this branch into:
/trunk

Stubs have been added to implement animations in Core Plot: CPAnimation, 
CPAnimationKeyFrame, 
and CPAnimationTransition.

The animation classes provide a mechanism to define transitions as subclasses 
of the 
CPAnimationTransition class. These will typically be implemented using Core 
Animation. Transitions 
could include things like fade in plot, fade out plot, explode/collapse graph, 
drop in plot points, 
etc.

The architecture is based on key frames and transitions. You basically create a 
CPAnimation 
instance, and fill it with key frames and transitions that together define a 
graph of objects. The 
graph is like a state machine that dictates the possible transitions and 
intermediate states that can 
arise. This allows for very simple linear animations, but also complex graphs 
with many transitions 
between various states (eg fade in a plot/fade out all others, etc)

For now CPPlotArea as its bounds set to the bounds of the owning CPGraph.
There should however be space for axis and annotations

CPAxis classes should have the ability to draw grid lines at major tick points 
and/or minor tick 
points. Add some properties to the class to support this: majorGridLineStyle, 
minorGridLineStyle. If 
either are non-nil, those grid lines are drawn.

Write documentation describing the CorePlot test harness and providing 
guidelines and sample 
code for writing tests for CorePlot.

At the moment, we are handling fills with a property like 'fillColor', which is 
a CGColor. It would be 
better to create a new class, much like CPLineStyle, that encapsulates all 
possible types of fills.

The class could be called CPFill or CPFillStyle. Possible fills would be a 
solid color, linear gradient, 
or image. This class could also be implemented as a class cluster.

Any use of fill color properties should then be replaced with the new class.

It should be possible to add annotations either to the graph itself, or to its 
plot area. (The difference 
is in how the annotation moves during a resize.)

Annotations are layers that can contain some text, an image, or another layer 
with completely 
general content.

An annotation should offer possibly draw a border, and indicate some feature 
with a pointing line 
or arrow.

A subclass of CAAnnotation is CALegend, which describes the various plots shown 
in the graph.

An event handling mechanism is needed. The CPGraph should accept events, and 
query sublayers as 
to whether they want to handle them. This would happen in an order much the 
same as it does with 
the responder chain in Cocoa. It would begin with plots, followed by axes, then 
plot area etc.

The iPhone does not support NSShadow. A cross platform CPShadow class should be 
written that 
works on both plaforms, and be used to draw shadows. NSShadow can act as an 
example.

A templating component should be added that allows someone to completely define 
the look of a 
graph (not its data). This would probably take the form of a loadable bundle, 
which contains a 
property list describing the graph, and any media that is needed (eg background 
images). A user 
should be able to generate such a bundle with a single call to the CPGraph 
class, and generate a 
new graph from such a bundle with an initializer of CPGraph (factory method).

When you compile CATestApp, you get these run time errors:

2009-02-11 13:49:39.126 CPTestApp[26427:10b] unhandled property type encoding: 
`{_CPPlotRange="location"{?
="_exponent"b8"_length"b4"_isNegative"b1"_isCompact"b1"_reserved"b18"_mantissa"[
8S]}"length
"{?="_exponent"b8"_length"b4"_isNegative"b1"_isCompact"b1"_reserved"b18"_mantiss
a"[8S]}}'
2009-02-11 13:49:39.128 CPTestApp[26427:10b] unhandled property type encoding: 
`{_CPPlotRange="location"{?
="_exponent"b8"_length"b4"_isNegative"b1"_isCompact"b1"_reserved"b18"_mantissa"[
8S]}"length
"{?="_exponent"b8"_length"b4"_isNegative"b1"_isCompact"b1"_reserved"b18"_mantiss
a"[8S]}}'

These seem to relate to properties of the CACartesianPlotSpace. CALayer seems 
to automatically 
scan for properties when it is initialized. If possible, these properties 
should be excluded from 
whatever scan is taking place.

The unit tests changes the color profile during testing. (On my macbook pro, it 
becomes bluish.) 
The problem is that if you kill the tests half way, the profile is permanently 
changed, and you have 
to reset it in the Display prefs.

Is there a way to avoid this? 

Many people run into the issue of forgetting to set wants layer on the hosting 
view, and don't 
know why there is no graph appearing.
This should happen in the hosting layer class, or at the very least be made 
explicit in code in 
the sample apps.

The changing the range of a CPPlotSpace like this:

CPXYPlotSpace *plotSpace = (CPXYPlotSpace *)graph.defaultPlotSpace;
plotSpace.xRange = [CPPlotRange 
plotRangeWithLocation:CPDecimalFromFloat(startTime) 
length:CPDecimalFromFloat(stopTime)];

does not trigger a redraw.

Stress and performance tests currently take the majority of UnitTest run time. 
It would be better if a 
subset of the unit tests could be run without these longer running tests. 
Refactor the stress and 
performance tests to a new target and add an aggregate target to run all unit 
tests if desired.

What steps will reproduce the problem?
1. Run with ppc and i386 in reference folder
2. View modified files

Expected to see native-arch files modified, but PPC ones were instead.

Should use native-arch/version for path when sorting.

CPBorderedLayer should be extended to support border styles besides rounded 
rectangle.

Some suggestions:
- Elliptical frame (will work well with polar plots)
- Fill the border with a gradient instead of a solid or patterned color
- 3D effects such as:
   * Beveled edges
   * Rounded edges
- Add optional shadow to any of the above

At the moment, when resizing a graph, the resize has a slight delay, because it 
is using the default 
layer animation.

The default animation for frame and bounds should probably be changed in 
CPLayer so that it is 
instantaneous. A method could be introduced in CPGraph that makes it easy to 
resize the whole 
graph in an animated fashion (eg setFrame:animated:).

A CPPlotSymbol class should be created that knows how to draw symbols (crosses, 
squares, 
circles etc) on a scatter plot. Symbols can be string based, vector based 
drawings, or even an 
image (CGImageRef).

CPPlotSymbol probably should be an abstract class, with subclasses for each 
mode of symbol (eg 
text, image, etc).

One question is whether it would be worth making each symbol a separate layer. 
This could be 
used to create some cool animation effects, but for large datasets, may be a 
performance 
problem. One option would be to have two different modes, and only use separate 
layers for 
each symbol if requested by the user. Perhaps the first pass should just use a 
layer per symbol. 
(We don't want to preoptimize).

Plot symbol classes should have class methods to easily create standard 
symbols, but offer 
constructors to generate custom symbols. Eg.

+(id)crossPlotSymbol;
+(id)circlePlotSymbol;

Symbols would also have a size property (CGSize), and comply with NSCopying. 
The reason for 
the latter is that the user will probably create a symbol object, and pass this 
as a prototype to 
the plot. The plot will copy the symbol, like an NSCell, to create the various 
points on the plot.

Some README files added at the root of the project, and in subdirectories, 
would help newcomers 
navigate. 

Some of the information from the wiki could also be added to the readmes, such 
as how you 
incorporate Core Plot in a project for both Mac and iPhone.

Text is blurry because sub-pixel antialiasing is disabled on layer-backed 
views. Suggestions from 
around the web are limited to two possibilities: render the text as an image 
first then display it in 
the layer, or (in the case of NSTextField), turn on "draws background". The 
latter isn't feasible for 
Core Plot, but the former may be workable.

The layer hierarchy is not optimal. For example, axes appear drawn on top of 
plots, rather than 
behind them. 

The following changes should be made:

- CPAxisSet should be moved from being a sublayer of CPGraph to being a 
sublayer of CPPlotArea. 
CPPlotArea should not mask its sublayers.
- The CPAxisSet overlay layer should be moved to the CPPlotArea.

Hi,

1. i fetch the source code using the command:
hg clone https://core-plot.googlecode.com/hg/ core-plot

2. Open the xcode project CorePlot.xcodeproj to compile the framework

3. gcc gets 30 errors, all related with the same thing:

    Error: incompatible type for argument 1 of 'initWithFrame:' --> on class CPGraph.m

    self.plotArea = [[CPPlotArea alloc] initWithFrame:self.bounds];
                                                                 xxxxxxxxxxxxxxxxxxxxx

Can you helping on that! Thanks!

When selecting an output group containing only a new image (in the output 
path), the reference 
image from the previously selected group is not cleared.

line 114:  if ( self.drawsAxisLine ) {

there is no drawsAxisLine anymore, it has just lately been removed from
CPAxis.m and CPAxis.h

Please fix, I just commented the if clause but I guess this ain't a good
solution.

This is apparently causing problems with GCC 4.2 (see coreplot-discuss posting 
from Marc 
Hoffman). 

In particular, CPGraph.m:15 (@synthesize defaultPlotSpace) should be (@dynamic 
defaultPlotSpace).

The CPTestApp doesn't draw x values bigger than 2.7 and y values bigger than 
3.6. Probably one of 
the layers is not set to the right frame. The cropping is independent of 
resizing.

Export a graph to PNG or PDF from the File menu in CPTestApp.

The exported graph (either format) has the following problems:
1. Missing axes, ticks, and tick labels
2. Layer content is not being clipped to the layer bounds even when drawing to 
the screen does
3. Layers should be drawn in the same order that they are drawn to the screen, 
i.e., a breadth-first 
traversal of the layer tree, not depth-first

Core Plot is still lagging on the iPhone, though it does compile. The biggest 
problem at this point 
seems to be that Core Animation on the iPhone does not have the automatic 
positioning of 
sublayers that is on the Mac (eg springs and struts). 

To get around this, one or both of two things can be done:

1) The layoutSublayers method of CALayer can be overridden to manually set the 
position and size 
of sublayers. This is already being done, and could be used to replace the 
remaining auto-resizing 
that there is.

2) It may be desirable at some point to have a layer layout system, akin to 
springs and struts or 
something else. This would make it possible to position annotations and other 
graph content.

One problem with supporting both the iPhone and the Mac is that the iPhone does 
not support 
NSAttributedString, and each platform has different classes for fonts. This is 
quite evident in the 
CPTextLayer class.

It would be good to have some abstractions to handle this issue. Quite a bit 
could be gained by 
moving font handling code out, either into functions or maybe even a CPFont or 
CPAttributedString 
class.

It may be possible to use HTML on both platforms to style text, but it is not 
clear how this should 
best be done.

When unit test build succeeds, TestMerge should not be run

It would not be very difficult to add axis titles. This should be done in a 
similar way to tick labels. It 
should be possible for the user to supply their own CPLayer, or just use a text 
layer.

There are already some stub classes in the framework, and a bit of commented 
out code. These 
need to be completed.

The axis set attaches to a particular plot area. Each axis in the axis set can 
be attached to a plot 
space. It is thus possible to have axes with different scales, corresponding to 
scales of different plot 
spaces. 

An axis set draws the 'box' around a plot area (if there is one), and each axis 
draws tick marks, and 
axis labels for graph. To position tick marks, an axis passes coordinates to 
its corresponding plot 
space, and gets back drawing coordinates.

The CPBarPlot class is for plotting bar and histogram plots. It should support 
bindings and the data 
source pattern, and have APIs similar to the CPScatterPlot class.

It should be possible to plot multiple data sets in a single bar graph (eg with 
different colored bars 
for each set). Multiple data sets could probably be handled as multiple 
instances of CPBarPlot, each 
with some drawing offset. 

The data source should only need to supply the height of the bars, not the x 
values. The CPBarPlot 
class should have properties that can be used to determine the location of the 
bars in x (eg location 
of first bar and separation of bars). 

Using the event methods in CPLayer, it should be quite easy to allow basic 
dragging of the plot 
area, as well as zooming. The events should be used to update the plot space 
ranges, thereby 
triggering a redraw. The plot spaces could possible provide methods to simplify 
this, eg,

-(void)updatePlotRangeForViewCoordinateTranslation:(CGPoint)offset;
-(void)updatePlotRangeForZoom:(CGFloat)factor aboutViewPoint:(CGPoint)point;

Test coverage needs to be extended to the CorePlot classes besides CPTextLaye. 
CPTextLayerTests 
can serve as a template for these tests.

Unit test classes should subclass CPTestCase and be added to the Unit Tests 
target.

What steps will reproduce the problem?
create a graph with the stocks theme

What is the expected output? What do you see instead?
see graph with no stocks gradient backgound

What version of the product are you using? On what operating system?
Cocoa Touch, wheres the version number???? downloaded it on 7/29/09

Please provide any additional information below.

What steps will reproduce the problem?
1. compile the new StockPlot example
2. run it on the device (after the very dumb downloading stuff is done; I'm 
changing that)
3. start sampling with Shark
4. push and pop a series of graphs
5. Notice the places where there are high-precision NSDecimalNumber 
calculations 
corresponding to hotspots

There are a few ways I can think of to mitigate this:
1.  We could take note that we're usually pushing this to pixels on a screen 
and remove some of 
the high-precision calculations (positive: faster, negative: possible errors on 
very high resolution 
devices on the desktop... printing...).
2.  remove some of the high-precision calculations only when compiling for 
iPhone.  (positive: 
faster on iPhone, negative: maintenance is difficult, to say the least).
3.  compile the library for the iPhone with ARM instead of THUMB code in tandem 
with some of 
the above.  Im pretty sure we won't get much help by simply going to ARM unless 
we are "doing 
the math" outside of apple's libraries as apple's libraries are compiled 
however it is that they are 
compiled (you can mix ARM and THUMB and I'm pretty sure apple is doing that).  
If we were to 
strip out any slow NSDecimalNumber code and replace it with floats while also 
compiling on ARM 
as needed, we could probably speed things up considerably.

Note:  we can experiment using #pragma arm and #pragma thumb to switch between 
instruction 
sets within each file as well.

Ideas?  

NSColor has a "windowBackgroundColor".
Maybe this could also be added to CPColor?

More work needs to be done on the plot classes. Some aspects include: support 
for dashed lines, 
line thickness, joining/non-joining of points, plot symbols, error bars.