New V9.8 Charting Features for .NET, WPF, MFC, VCL, ActiveX

I. Improvements Overview:

Version 9.8 continues to add to RenderEngine = Direct3D rendering technology to mimic features found in Direct2D. v10 is getting closer to release, and will easily support porting, so we greatly appreciate customers taking advantage of buying 9 now and getting 10 for free. v10 is taking longer than expected as we are also refactoring Direct3D construction onto the gpu. ProEssentials is very fast, but moving to gpu based construction will help with plotting billions of data points. ProEssentials will soon once again be the absolute fastest most professionally and meticulously rendered scientific, engineering, large information system charting engine available. v10 is also adding jagged data (individual subsets will have their own new storage) with inherent per subset circular buffer features which the gpu will also utilize incrementally. So because of these delays, we decided to release v9.8 with a few v10 additions.

• Pe3do 3D Log scales in X Y Z for all plotting methods, annotations, and features, and Direct3D Pesgo 2D Log support. See examples 139, 402 and 404.
  
  
• New Quick Draw Tooling / Annotation feature as part of Pesgo, Pego, and Pepso. See demo project example 110 for a working demonstration. Running this example, left-click + drag, draws a round rect selection tool with data-coordinate-sizing prompts. This feature allows for a fully customized annotation layer to be constructed and displayed and hidden without overhead of reconstructing the underlying image.
  
  
• New colored Cursor and line styled Cursor are also available as part of the new quick drawing feature. See example 105.
  
  
• The WPF interfaces have been improved to use the new colored and styled cursors by default. The CursorMode feature was problematic with the older WPF interfaces as they attempted to rely on ROP2 drawing logic that was highly efficient at drawing a cursor without any additional memory or processing requirements; however, WPF is too non-Windows to get this to work in all scenarios. The new approach draws the cursor to a prepared bitmap and the composite scene is then refreshed and solves all CursorMode concerns.
  
  
• Among new features, v9.8 adds fixes and polish, such as... 1) fixing the cursor flicker issue when combining CursorMode feature with tooltip CursorPromptTracking feature. 2) fixing the CursorMode repeat keyboard processing when holding arrow keys within the WPF interface. 3) fixing z order issues with RenderEngine=Direct3D 2D rendering to honor subset order similar to Direct2D and SubsetsToShow and RandomSubsetsToGraph features.
  
  

II. Functional Improvements:

v9.8 Improvements:

New property to control 3D grid patching:

#define PEP_bGRIDBANDSPATCHING

Scope: Pe3do

.Net: Pe3do.PeColor.GridBandsPatching
OCX, VCL: GridBandsPatching

DLL: set with PEnset to FALSE (0) to show grid bands as strips instead of patches.

Default True, GridBands color will be alternated between major grid lines forming a patching effect. Set False to form strips of GridBands color. The new Log scale will patch on ticks so the patching may be considered too complex when viewing many cycles. Developers may also prefer strips on normal linear scales.

New properties to support 3D Log scales:

#define PEP_bXAXISSCALECONTROL

Scope: Pe3do

.Net: Pe3do.PeGrid.Configure.XAxisScaleControl
OCX, VCL: XAxisScaleControl

DLL: set with PEnset to constants PEAC_NORMAL = 1, PEAC_LOG= 2

Default is Normal, Set this property to designate the x axis to use a log scale. PlottingMethods and annotations will plot x data coordinates in log10. The axis labels will show as scientific notation unless LogScaleExpLabels is set to false to show labels as normal numeric labels.

Similar properties are PEP_bZAXISSCALECONTROL and PEP_bYAXISSCALECONTROL. See demo examples 402 and 404.

#define PEP_bLOGSCALEEXPLABELS

Scope: Pe3do

.NET: Pe3do.PeGrid.Configure.LogScaleExpLabels
OCX, VCL: LogScaleExpLabels

DLL: set with PEnset to FALSE, 0 to show labels as numeric instead of scientific notation.

New properties to support Quick Annotations:

#define PEP_bCACHEBMP2
Scope: Pesgo, Pego, Pepso

OCX/VCL: CacheBmp2

Default = 0, False

Set to True to enable a secondary layer used for the new Quick Annotations feature and new DrawCursorToCache feature.

#define PEP_bSHOWINGQUICKANNOTATIONS and PEP_bHIDINGQUICKANNOTATIONS
Scope: Pesgo, Pego, Pepso

OCX/VCL: ShowingQuickAnnotations

Default = 0, False

Study demo example 110 within form 3 and portions in form 1 or mainwindow. See the charts MouseDown, MoveMove, and MouseUp events searching for 110.

Setting True calls an internal function to prepare the chart to show quick annotations. Quick Annotations are normal GraphAnnotations, HorzLineAnnotations, and VertLineAnnotations where the type is offset by +1 and negative. For example, the demo code MouseMove event uses Pesgo1.PeAnnotation.Graph.Type(n) = (GraphAnnotationType.NoSymbol + 1) * -1 When the chart paints while ShowingQuickAnnotations is True, the chart will show the primary underlying chart combined with the quick annotation layer on top.

Set to False and set HidingQuickAnnotations to True to revert the chart to only show the primary image, without needs to reconstuct the primary image.

New properties related to CursorMode:

#define PEP_dwCURSORCOLOR
Scope: Pesgo, Pego, Pepso

OCX/VCL: CursorColor

Default = 1, Disabled by default with vaue of 1.

Set to any ARGB color to control color of CursorMode feature. Also set DrawCursorToCache and CacheBmp2 to True. The cursor will be drawn with GDI unless ImprovedCursor is set to True and then the cursor will be drawn with Direct2D allowing thick dash CursorVLineType and translucent colors. See demo example 105 that uses a dashed cursor and CursorMoved event changes the cursor color to match the subset.

#define PEP_nCURSORVLINETYPE and PEP_nCURSORHLINETYPE
Scope: Pesgo, Pego

OCX/VCL: CursorVLineType

Default = 0, Thin Line.

Set to values from enumerations for VertLineAnnotationType. Also set DrawCursorToCache and CacheBmp2 to True. Set ImprovedCursor to True to enable thick dash dot styles. VLineType controls vertical cursor line, and HLineType controls horizontal cursor line.

#define PEP_bIMPROVEDCURSOR
Scope: Pesgo, Pego

OCX/VCL: ImprovedCursor

Default = False

Setting True causes Direct2D to draw the CursorMode cursor which allows for thick dashes and translucent CursorColor.

v9.5 Improvements:

New property to help with multiple thread implementations:

#define PEP_bFREEZE

Scope: all control types, Pego, Pesgo, Pe3do, Pepso, Pepco.

.Net, OCX, VCL: use control.Freeze = true / false

DLL: set with PEnset

This feature along with Painting helps with stability issues when implementing data update functionality within a secondary worker thread. One can set Freeze = true, process your update logic, call PEreinitializeresetimage() and then set Freeze = false. Then optionally call Invalidate to invalidate the control. This is not the best approach to handling threading issues but the easiest and usable in many scenarios where total data points is less than approximately 100,000. Our WPF interfaces have always had this feature and it has been useful, v9.5 implements a similar concept within the Winform, DLL, OCX, and VCL interfaces. The feature disables the message pump except for WM_DESTROY, WM_NCDESTROY, and WM_PAINT; and the WM_PAINT handler only marks the window as validated and returns. When the control is in a frozen state it avoids doing any real work, and thus avoids any potential threading issue.

The worker thread's process of updating the chart should look similar to this...

while (Pesgo1.PeSpecial.Painting)  { // loop till false, doing nothing but waiting, it generally won't take long}
// once Painting goes false, do something right away
while (!Pesgo1.Special.Painting)
{
Pesgo1.Freeze = true;

// do your update logic

Pesgo1.Freeze = false;
}

Without the above technique, it will take two timer mechanisms. The developer should have one timer that only gathers data (no ProEssentials calls or any calls which would trigger a WM_PAINT, OnRender, etc), and a second timer within the same thread as chart to update the chart with the gathered data.

The process for 2 timers, the timer within the chart's thread should ...

a) tell the worker thread that the current data is being consumed, the worker thread should start gathering data in a new secondary block/object but don't tell us about it (reset the new data flag and also don't set the new data flag.)
b) process the chart's data update logic with the prepared block from the worker thread
c) call ReinitializeResetImage, UpdateLayout etc.
d) tell the worker thread that its ok to now set the new data flag if data exists and optionally free the memory for the first block, or simply reuse the fixed size block.

e) and the process repeats switching between 2 memory blocks that gather data.

This two timer approach has the advantages that 1) the cpu is never forced to loop and wait, and 2) the developer can more easily control the overall data bandwidth capability for the chart's update logic by adjusting the chart update frequency without affecting the data gathering frequency.

New Data Reduction and shared Data features:

New properties to help reduce the demand for stored data:

enumerations:

#define PEDD_NONE 0
#define PEDD_POINTINCREMENT 1
#define PEDD_SUBSETINCREMENT 2

#define PEP_nDUPLICATEDATAX

Pesgo, Pe3do, Pepso

.NET: PeData.DuplicateDataX

OCX/VCL: DuplicateDataX

Default = 0 None

#define PEP_nDUPLICATEDATAY

Pesgo, Pe3do, Pepso

.NET: PeData.DuplicateDataY

OCX/VCL: DuplicateDataY

#define PEP_nDUPLICATEDATAZ

Pesgo, Pe3do

.NET: PeData.DuplicateDataZ

OCX/VCL: DuplicateDataZ

These features enable the chart to duplicate data for each subset so only one subset's or one point's worth of data is necessary. The most common scenario is likely related to the Pesgo Scientific Graph control where one passes XData and YData for each data point. Setting DuplicateDataX = PointIncrement will mean that each element of data contained within XData will be used/duplicated for each point for subsequent subsets. Another common scenario is a 3D surface or 2D contour where one passes XData, YData, and ZData for each data point. Again one could set DuplicateDataX=PointIncrement and only pass one subset's worth of XData, or PEP_nPOINTS amount of data. You could set DuplicateDataZ = SubsetIncrement and only pass one points's worth of ZData, or PEP_nSUBSETS amount of data. Each element of data contained within ZData will be used for each subset and all points for this subset are set to this same value. This allows a reduction in the amount of data stored to render a chart. See examples 122 123(also uses new XDataPtr) 139(new WaveData example) 401 408 in our demo and example projects. Note that SubsetByPoints needs to be true to use these duplicate data feature.

Improved properties to help with shared data:

#define PEP_faXDATAPTR
#define PEP_faXDATAIIPTR

#define PEP_faYDATAPTR
#define PEP_faYDATAIIPTR

#define PEP_faZDATAPTR
#define PEP_faZDATAIIPTR
#define PEP_dwaPOINTCOLORSPTR

.NET, OCX, VCL: Similar to a MFC/DLL project, call PEvsetW to pass the address of the locally allocated memory block.

These features have been added along with improvements in internal data reduction filtering logic to increase the maximum data quantity that can be rendered within an application, and increase the performance in rendering this image. With these features and the above DuplicateData features, a 32 bit project should be able to generate charts with a much larger maximum data size, approaching 100 million points. 64 bit projects will also use less memory and render faster and have a larger practical maximum amount of chart-able data points, potentially a billion data points (though note our filtering logic still always finds and plots all outliers so finding these outliers within a billion points does take time.) We may be adding a basic skip-n data point type filtering in the future but such filtering can produce a misleading image if there are any outliers.

For example, to use these features for a Pesgo line chart. See example 123 in our demo and example projects. One would allocate your own memory. SubsetByPoint defines how we use and expect data to be arranged. So for XData, one allocates a Single precision float array of values to be a buffer to hold x data for each data point, size should match PEP_nPOINTS if only one Subset (PEP_nSUBSETS), or using DuplicateDataX. If there will be more than one Subset and not using DuplicateDataX, then the size of the array should be Subsets X Points. One calls PEvsetW to tell ProEssentials the address of your memory buffer via the PEP_faXDATAPTR property. A similar process can be used to share YData. Note that for a Pesgo line chart, normally all y data values are unique so there is little need for DuplicateDataY unless building a chart that runs vertically rather than horizontally. The arrays / buffers allocated may be initialized with your own logic/functions to pre-fill them as needed. Or one can still call our functions PEvset, or use our visual interface wrappers like Pesgo1.PeData.X[s,p] to get / set data. Because data access can remain the same, the developer can add this feature to existing projects by simply allocating the memory and setting the above properties. One can also use your own logic to change the data buffer content for real-time scenarios. Note, one should not update the buffer while an image is being generated, so changing data should only be done with the same thread that constructed the chart, or possibly use the feature above to Freeze the chart. When finished with the buffer, one calls PEvsetW again with PEP_faXDATAPTR and address set to Zero and last argument Zero. As you constructed your own memory, you may be responsible for freeing this memory.

C++ / MFC: for example:

float* myXData;

int myXDataSize;

// determine myXDataSize, either equal to (PEP_nPOINTS) property, or (PEP_nSUBSETS X PEP_nPOINTS)

// allocate your local memory

// tell ProEssentials about your memory, setting last argument to the size of your memory buffer

PEvsetW(m_hPE, PEP_faXDATAPTR, myXData, myXDataSize);

PEvsetW(m_hPE, PEP_faXDATAPTR, 0, 0); // last 2 arguments must be zero

.NET, using Gigasoft.ProEssentials: for example: declaring MainWindow variables to be used throughout project on any form within project.
public static float[] myXData;
public static int myXDataSize;

// determine myXDataSize, either equal to (PeData.Points) property, or (PeData.Subsets X PeData.Points)

// allocate your local memory

MainWindow.myXData = new float[MainWindow.myXDataSize];

// tell ProEssentials about your memory, setting last argument to the size of your memory buffer

Api.PEvsetW(Pesgo1.PeSpecial.HObject, DllProperties.XDataPtr, MainWindow.myXData, MainWindow.myXDataSize);

// when done using your local memory, tell ProEssentials to use it's own copy of memory

Api.PEvsetW(Pesgo1.PeSpecial.HObject, DllProperties.XDataPtr,0, 0); // last 2 arguments must be zero

These features along with above features will significantly reduce the memory overhead of your overall project when charting large amounts of data. One copy of the data will be necessary. Sending data to the chart to be copied and stored is avoided.

Our goals are to continue improving data handling by supporting jagged arrays per subset and improving the filtering with cached filtered blocks so that only one slow create is necessary to find all outliers and further zooming and panning at random ranges and levels can be quickly and perfectly rendered.

3D Scientific Graph and 2D Graphs support thick lines/tubes for subset line types and graph annotation line types, Direct3D:

This is a potential issue when porting to v9.5 as 9.0 treated all Direct3D line types as thin. So if your code is setting line types (likely), one might not remember your code was setting a thick line type that was simply being rendered as thin. So double check the property SubsetLineTypes for your Pe3do and Pesgo charts that are using RenderEngine = Direct3D. For example, for a real-time Pesgo chart or charts with large amounts of data (RenderEngine = Direct3D), thick lines might be rendered via a geometric shader and potentially different looking and a bit slower.

#define PEP_nLINESORTUBES

Pe3do

.NET: Pe3do.PePlot.LinesOrTubes

Possibly settings of ...

#define PELOT_ALL_LINES 0
#define PELOT_MEDIUM_THICK_TUBES 1
#define PELOT_MEDIUM_TUBES 2
#define PELOT_MEDIUM_THIN_TUBES 3
#define PELOT_ALL_TUBES 4

This property will allow the SubsetLineTypes setting to control 2 types of geometric shaders and one simple line topology shader involved in drawing lines. By default, Thin, MediumThin, Medium lines will be drawn as a potentially 2d thick line that is facing the screen. No shading will impact its color intensity. These lines will be more visible. The MediumThin setting is nice as it will utilize anti aliasing and produce a smoother line as the line is drawn via triangle topology vs line topology. By default, MediumThick, Thick, and ExtraThick lines will be drawn as a 3D tube and be shaded as other 3D objects in the scene. This property can be adjusted so all line types use the line geometric shader (0) or a setting of (4) will cause all lines to be tubes. The AllTubes setting is nice when you want your thin lines to actually fade into the background if desired. The settings of 2 and 3 change when the threshold happens from line to tube geometric shaders. This feature makes it easy to force or mix both line technologies in the scene either by setting this property and or SubsetLineTypes or various GraphAnnotationTypes that construct lines or 2d ellipses/rects of various line thicknesses. See example 403 404(using popup menu to change plotting method) 405 407 (initial chart shows an annotation line)

Related to above property is TubeThicknessMin and TubeThicknessInc.

#define PEP_fTUBETHICKNESSMIN

Pe3do

.NET: Pe3do.PePlot.Option.TubeThicknessMin

#define PEP_fTUBETHICKNESSINC

Pe3do

.NET: Pe3do.PePlot.Option.TubeThicknessInc

Default values are 1.0. For example, setting TubeThicknessMin = 0.5 will cause the SubsetLineType=ThinLine setting to result in a tube half the default size. This represents the thinnest tube rendered. Setting TubeThicknessInc = 1.5 will cause the incremental size increases (MediumThin to Medium to MediumThick) to be increased by 50% and allows control of the range of tube sizes that will be produced. If you want greater changes between Medium and Thick tube radiuses, set to 1.5 or as needed.

3D Scientific Graph Direct3D support for GraphAnnotations, plus new Direct3D related properties :
GraphAnnotationTypes currently supported are:

• Solid Symbols (NoSymbol to Pointer) supporting optional hot spots.
• Solid LineTypes of ThinSolidLine, MediumSolidLine, ThickSolidLine, MediumThinSolid, MediumThickSolid, ExtraThickSolid
• LineContinue using above types, with optional hot spots for end points.
• StartPoly, AddPolyPoint
• EndPolygon: all points should reside within any 2D plane, optional hot spot example 400 407 use polygons for realtime tooling
• EndPolyLineThin, EndPolylineMedium, EndPolyLineThick, optional hot spots at vertices
• New type MajorMinorRadii: GraphAnnotationX = Major Radius, GraphAnnotationY = MinorRadius (used for ellipse/rect line and fill annotations)
• New type MajorDirection: GraphAnnotationX,Y,Z represent the unit vector for major direction (used for ellipse/rect line and fill annotations)
• New type MinorDirection: GraphAnnotationX,Y,Z represent the unit vector for minor direction (used for ellipse/rect line and fille annotations)
• New type AxisDirection: GraphAnnotationX,Y,Z represent the unit vector direction of center axis (used for circle and square annotations)
• New type AxisAngles: GraphAnnotationX = horizontal angle from x axis, GraphAnnotationY = vertical angle from vertical axis
• New type MajorMinorInsideRadii: GraphAnnotationX = Major inside radius: GraphAnnotationY = Minor inside radius (ellipse fills outer ring)
• New type TextAtPixel: GraphAnnotationX and Y are pixel location to place text
• New type InsideRectThin, InsideRectMedium, InsideRectThick, InsideRectFill: Rect rendered inside major/minor radii vs enclosed by radii.

Remarks related to Graph Annotations:

See examples 400 401 402 403(press the 0,1,2 key) 404 405 407 408

GraphAnnotationText supports all justification codes: Unlike the 2D controls, the justification code will also influence the initial attempted location for Pointer types. Then if dodging is not disabled (GraphAnnotTextDodge non zero), the Pointer text will dodge other text, optionally annotations(new property GraphAnnotationSymbolObstacles), optionally subsets (SubsetObstacles), and optionally axis grid numbers and grid labels.

#define PEP_bGRAPHANNOTATIONALLDODGING;
Pe3do

.NET: Pe3do.PeAnnotation.Graph.AllDodging

OCX / VCL: GraphAnnotationAllDodging

#define PEP_nGRAPHANNOTATIONALLDODGINGOFFSET

Pe3do

.NET: Pe3do.PeAnnotation.Graph.AllDodgingOffset

OCX / VCL: GraphAnnotationAllDodgingOffset

Related to above property, this property controls the pixel offset from the target position to avoid the symbol being annotated. Default is 8 pixels and if one has extra large symbols, one can increase this property to prevent the text from touching symbols.

#define PEP_nGRAPHANNOTATIONPOINTEROFFSET

Pe3do

.NET: Pe3do.PeAnnotation.Graph.PointerOffset

OCX / VCL: GraphAnnotationPointerOffset

Related to PEGAT_POINTER type graph annotations, default 45 pixels, change if you would like shorter or longer Pointer lines attaching annotation location to text location.

#define PEP_bLEFTJUSTIFICATIONOUTSIDE

Pe3do

.NET: Pe3do.PeAnnotation.Graph.LeftJustificationOutside

OCX / VCL: LeftJustificationOutside

Related to GraphAnnotationText justification logic. Setting true will cause any text justified to the right of the annotation location (left justified horizontal text or right positioned vertical text) to always be positioned towards the outside of 3D scene. In other words, if the text is on the right side of the scene and left justified, rotating the scene 180 degrees causes the text to switch to remain outward oriented and thus right justified text. This will keep the center of the 3D scene from getting cluttered. And if one has annotations that are located near the center of the 3D scene, one can right justify these items and their text will always remain towards the center of the scene. This will prevent pointer lines from criss-crossing when annotation text is close to each other by giving them left and right justified codes. One should know the min max of the x and z axes to make an ideal decision on how to justify the text. As always, after passing data, calling PEreinitialize will initialize the ManualMinX ManualMaX ManualMinZ and ManualMaxZ values to learn your axis range.

#define PEP_bXZAXISOBSTACLE

Pe3do

.NET: Pe3do.PeAnnotation.Graph.XZAxisObstacle

OCX/VCL: XZAxisObstacle

#define PEP_bYAXISOBSTACLE

Pe3do

.NET: Pe3do.PeAnnotation.Graph.YAxisObstacle

OCX/VCL: YAxisObstacle

Related to dodging logic. XZAxisObstacle and YAxisObstacle both default to true. Set to false to remove these obstacles and graph annotation text will be allowed to overlap the axis grid line numbers and axis label text.

#define PEP_bGRAPHANNOTATIONSYMBOLOBSTACLES

Pe3do

.NET: Pe3do.PeAnnotation.Graph.SymbolObstacles

OCX / VCL: GraphAnnotationSymbolObstacles

Default is false, false allows graph annotation text to overlap other graph annotation symbols. If one implements many annotations, it may be too difficult to include annotation symbols in the dodging calculations. Set True to enable dodging of annotation symbols.

#define PEP_naGRAPHANNOTTEXTLOCATIONRIGHT

Pe3do

.NET: Pe3do.PeAnnotation.Graph.TextLocationRight

OCX / VCL: GraphAnnotTextLocationRight

#define PEP_naGRAPHANNOTTEXTLOCATIONLEFT

Pe3do

.NET: Pe3do.PeAnnotation.Graph.TextLocationLeft

OCX / VCL: GraphAnnotTextLocationLeft

#define PEP_naGRAPHANNOTTEXTLOCATIONTOP

Pe3do

.NET: Pe3do.PeAnnotation.Graph.TextLocationTop

OCX / VCL: GraphAnnotTextLocationTop

#define PEP_naGRAPHANNOTTEXTLOCATIONBOTTOM

Pe3do

.NET: Pe3do.PeAnnotation.Graph.TextLocationBottom

OCX / VCL: GraphAnnotTextLocationBottom

#define PEP_bGRAPHANNOTATIONTEXTFIXEDSIZE

Pe3do

.NET: Pe3do.PeAnnotation.Graph.TextFixedSize

OCX / VCL: GraphAnnotationTextFixedSize

True, all graph annotation text will be the same size. False, sizes graph annotation text based off depth into the 3D scene.

#define PEP_nANNOTATIONTEXTFIXEDSIZEMENU

Pe3do

.NET: Pe3do.PeUserInterface.Menu.AnnotationTextFixedSize

OCX / VCL: AnnotationTextFixedSizeMenu

Related to above property, setting to PEMC_SHOW will add a menu to the built-in popup menus to allow the user to toggle the state of above GraphAnnotationTextFixedSize. Quickly increasing or decreasing the size of text deep in the scene.

Most of the 40x examples use these features to add popup menu items.

#define PEP_bFORCE3DXANNOTVERTICEREBUILD

Pe3do

.NET Pe3do1.PeFunction.Force3dxAnnotVerticeRebuild

OCX / VCL Force3dxAnnotVerticeRebuild

Set this property to true to tell ProEssentials there is new data related to annotations and the chart should rebuild its internal vertex and index buffers. This allows vertices related to annotations and data to be separately rebuilt. Again, data vertices are rebuilt if Force3dxVerticeRebuild is set true. Demo example 400 and 407 use this feature within a mousemove event for a real-time tooling / feedback implementation.

#define PEP_nHIGHLIGHTGRAPHANNOTATIONINDEX

Pe3do

.NET Pe3do1.PeAnnotation.Graph.HighLightAnnotationIndex

OCX / VCL HighLightGraphAnnotationIndex

Default is -1, and disabled state. Set to 0 or higher to a graph annotation index that is a potential hotspot. When image is rendered, this index will be highlighted as if the mouse is over this annotation. Useful for animation as used in demo example 403 when users presses 0-9, but could be used anytime to quickly highlight an annotation for other reasons.

Related to z order of Graph Annotations. The feature GraphAnnotationInFront is now optionally supported for Direct3D, including its ability to quickly show or hide individual annotations. This also means AnnotationsInFront is also supported. When AnnotationsInFront is true, the graph annotations are rendered after the main surface/scatter type graphics. Setting to false means graph annotations are rendered before the main graphics. This can be important when using transparency for annotations or the main graphics. One should note that if annotations will include transparency, it is best to define these after opaque annotations. In general, render opaque items first and transparency items latter.

Related to Ellipses, Rects: New annotation types MajorMinorRadii, MajorDirection, MinorDirection, AxisDirection, AxisAngles. All these types can construct an ellipse or rect so there is logic that chooses which feature is used. If unit vectors MajorDirection and MinorDirection are anything but all zeros, then these unit vectors will control ellipse/rect construction. If MajorDirection and MinorDirection are all zero, the we next test if AxisDirection is all zero, in which case AxisAngle is used to construct a circle or square. Note that AxisAngles and AxisDirection only represent a direction of axis and there is no way to control the shape (major minor radii orientation.) If AxisDirection is non zero and MajorDirection and MinorDirection are zero, then AxisDirection is used. After setting these annotations to non-zero, it may be best to set these annotations back to zero after the ellipse/rect annotation type.

We will be adding more support for annotation types in the near future. Various vector and arrow types will likely be completed next. The 3d sphere, 3d cylinder, 3d cone, 3d solid rect and new symbol types up-cone, down-cone will be coming in next few months.

In summary, new GraphAnnotationType constants:

#define PEGAT_MAJORMINOR_RADII 219 see example 403 adding ellipses
#define PEGAT_MAJOR_DIRECTION 220
#define PEGAT_MINOR_DIRECTION 221

#define PEGAT_AXIS_DIRECTION 222
#define PEGAT_AXIS_ANGLES 223

#define PEGAT_TEXT_AT_PIXEL 228

#define PEGAT_MAJORMINOR_INSIDERADII 229

#define PEGAT_INSIDERECT_THIN 230
#define PEGAT_INSIDERECT_MEDIUM 231
#define PEGAT_INSIDERECT_THICK 232
#define PEGAT_INSIDERECT_FILL 233

New 3D ViewingMode feature to provide random 3D focal point viewing:

#define PEP_nVIEWINGMODE

Pe3do

PePlot.Option.ViewingMode

Pe3do adds a new property ViewingMode. The default PEVM_CENTER is the legacy view where the user can rotate (DegreeOfRotation, ViewingHeight) and zoom (DxZoom) related to the center of the scene. Translation translates the center of scene. The new functionality adds ViewingMode setting of PEVM_DATA_LOCATION. In this new mode the developer can select a Subset (ViewingSubset), Point(ViewingPoint) as the focal point related to rotation and zooming. There is also an option to focus on a specific X, Y, Z coordinate (PEP_structVIEWINGAT) in case the focal location is a random data coordinate of graph annotation location. When ViewingMode is set to DataLocation, no translation is allowed, the focal point is the fixed focal point. This feature can be used for animation with a timer or key stroke by simply incrementing ViewingPoint to produce the look of flying down a data series. Or a series of ViewingAt locations can be generated to produce a specific data view animation.

As of this writing, DxFitControlShape must be False. see 400 401 402 403 404 408 press 0 - 9 when chart has focus to demo

PEVM_CENTER 0
PEVM_DATA_LOCATION 1

#define PEP_nVIEWINGSUBSET

Pe3do

PePlot.Option.ViewingSubset

When ViewingMode is set to DataLocation, this property along with ViewingPoint will set the focal location of rotation and zooming. If PEP_structVIEWINGAT is non zero then it will take precedence.

#define PEP_nVIEWINGPOINT

Pe3do

PePlot.Option.ViewingPoint

When ViewingMode is set to DataLocation, this property along with ViewingSubset will set the focal location of rotation and zooming. If PEP_structVIEWINGAT is non zero then it will take precedence.

#define PEP_structVIEWINGAT
Pe3do

PeFunction.SetViewingAt

This feature overrides the above ViewingSubset and ViewingPoint properties and allows any X,Y,Z location to be the designated focal point when ViewingMode is set to DataLocation. Most of the demo examples use this as the demo points to graph annotation locations.

For .NET developers, use PeFunction.SetViewingAt and PeFunction.GetViewingAt.

Pe3do.PeFunction.SetViewingAt(float X, float Y, float Z)
ProEssentials.Structs.Point3D Pe3do.PeFunction.GetViewingAt()

For OCX developers, use the methods SetViewingAt and GetViewingAt.

SetViewingAt(float X, float Y, float Z);
GetViewingAt(float* X, float* Y, float* Z);
GetViewingAtEx( [out] VARIANT * pfX, [out] VARIANT * pfY, [out] VARIANT * pfZ );

For DLL/VCL developers, initialize a POINT3D structure with the X, Y, Z location and set with PEvset. To get the light location, call PEvget with destination buffer as address to a POINT3D struct. The POINT3D structure is simply 3 float's.

typedef struct { float X; float Y; float Z; } POINT3D;

Various other 9.5 improvements and fixes:

#define PEP_naSUBSETAXES
Pego, Pesgo

PeGrid.SubsetAxes

Default = Empty, when empty this feature is avoided

This feature allows setting the axis location (0 - 15) for each subset, individually and randomly.

For example modify demo example 012 with...

Pego1.PeGrid.SubsetAxes(0) = 3
Pego1.PeGrid.SubsetAxes(1) = 2
Pego1.PeGrid.SubsetAxes(2) = 1
Pego1.PeGrid.SubsetAxes(3) = 0

This tells the chart that subset 0 is on axis 3, subset 1 is on axis 2, etc. Reversing the order so the first subset is on the bottom, where normally the first subset would be on top. Historically, one would have to alter the order of subsets to achieve having the first subset on bottom.

One must still set MultiAxesSubsets though technically one only needs to make sure that the total subsets allocated within the MultiAxesSubsets items equals or matches the value of Subsets. There is a test within the chart construction that verifies that allocation of MultiAxesSubsets uses all subsets. As long as when setting SubsetAxes, one uses all axes, the chart will alter MultiAxesSubset items for you to reflect the state of SubsetAxes. This allows changing the numbers of subsets per axis without having to change MultiAxesSubsets, as along as the number of total axes stays the same and each axis has at least 1 subset. In the future we may expand this logic to allow SubsetAxes to be the overal controlling factor and it may auto resize MultiAxesSubsets and auto establish RandomSubsetsToGraph / SubsetsToShow and thus has the power to hide subsets with a special axis designation. This feature is very new so we need to tinker with it more to evolve it into a very easy way to handle multi axes.

#define PEP_bSHOWANNOTATIONTEXT

Pe3do Pesgo Pego Pepso

.NET: PeAnnotation.ShowAnnotationText

OCX / VCL: ShowAnnotationText

A new feature to easily hide all annotation text. Setting false will quickly hide the annotation text from the scene. Annotation graphics will still be visible.

#define PEP_nSHOWANNOTATIONTEXTMENU

Pe3do Pesgo Pego Pepso

.NET: PeUserInterface.Menu.ShowAnnotationText

OCX / VCL: ShowAnnotationTextMenu

Related to above ShowAnnotationText. Settting to PEMC_SHOW will add a menu to the built-in popup menus to allow the user to toggle the state of ShowAnnotationText. Quickly hiding or showing annotation text.

#define PEP_fMAXZOOM

Pe3do

.NET PePlot.Option.MaxZoom

OCX / VCL MaxZoom

Sets a maximum zoom and thus prevents the user from zooming too far past the focal point (camera is past the looking-at location.) Set DegreePrompting to true to help determine a best value for your scene as GridAspectX GridAspectZ DxFOV will impact the range of DxZoom.

#define PEP_bSEARCHNONSEQUENTIALDATA

Pesgo

PeData.SearchNonSequentialData

OCX / VCL SearchNonSequentialData

This feature allows the developer to enable PEsearchsubsetandpointindex and PEsearchpointindex (discussed below) to find the closest subset and or point index when the x data is not sequentially ordered. For charts with fewer than 10,000 points, or as desired, the brute force search of searching every data point may be useful and convenient. For charts with many data points, this feature is best left the default value of False, and ordering x data if not inherently ordered.

#define PEP_fLIGHTSTRENGTH

Pe3do

.NET Pe3do1.PePlot.Option.LightStrength

OCX / VCL LightStrength

Default = .3 This is the level or strength of ambient lighting. Set to .4 to .8 to globally brighten the 3D scene.

#define PEP_bDXGEOMETRYSHADER

Pe3do, Pesgo

PeSpecial.DxGeometryShader

This property allows the developer to disable the Geometry Shaders related to thick lines and tubes. The default is True, but if porting to 9.5 and you want to guarantee backward compatibility with v9.0 or v8.0, then setting this property to False will make sure the new v9.5 thick line support will not change your current projects look or performance.

v9.5 Improves Direct3D Pe3do ScatterMode, line chart and line graph annotations, the data highlight feature now draws a sphere to designate the focus point instead of a diamond.

v9.5 fixed Direct3D Pe3do control that was not implementing FontSizeGNCtrl and FontSizeALCntl

v9.5 fixed CursorPromptTracking that was not handling CursorPromptStyle = 4 in all potential cases, 2D contours.

v9.5 fixed WPF interfaces when RenderEngine = Direct3D and control was unloaded and re-loaded, for example via a Content container, there was an instability with D3DImage interop class.

v9.5 fixed an issue with null data handling and bar charts.

v9.5 fixed an issue with PEP_bSHOWWIREFRAME (PePlot.Option.ShowWireframe) causing an instability in some cases of Subsets and Points.

v9.5, now changing the file type in the built in Export Dialog when a filename happens to exist, will change the file extension to reflect the new file type.

v9.5 fixed Disable Stacked Percent Menus was only disabling items in customizing dialog, popup menu items were still mistakenly included.

v9.5 fixed LineSymbolThickness which was not functioning correctly for RenderEngine = Direct2D

v9.5 fixed an issue with RenderEngine = Direct2D and charts that happened to have only 1 item of rotated text, the global translation (.5, .5 ) was not being reset causing a fuzzy looking image (pixels always crossing a pixel boundary).

v9.5 fixes a 2D contour issue where ContourColorProportions was not properly implemented causing too many contour lines.

v9.5 fixed an issue if setting PEP_nSEQUENTIALDATAX from default auto 0 to 1, caused a problem not showing all Subsets.

v9.5 fixed an issue with colors when using feature PlottingMethods() (per subset PlottingMethod setting) and Subsets > 128 and ZoomWindow was set to show all Subsets.

v9.5 fixed as issue with SubsetToShow and PartialResetImage.

v9.5 improves the Pego MouseWheel horizontal zooming which was not keeping focus near mouse when low PointsToGraph are charted.

v9.5 improves combining using scrollbars or dragging Pe3do while AutoRotation is activated.

v9.5 fixed ContourColorSet setting of 1. Now setting to 1 properly allows one to Clear and redefine ContourColors that will be used for custom colors.

v9.5 improves the Pe3do scatter mode, area plottingmethod (waterfall) which was drawing border line before slice causing anti-aliasing artifacts. And also fixes Monochrome ViewingAs setting.

v9.5 fixes Pesgo 2D contour which was not exporting xyz data in Text Export dialog.

v9.5 fixes Pesgo 2D contour RenderEngine = Direct3D which was not supporting ViewingAs Monochrome setting.

NOTE: v9.5 had to switch the normal position calculation of how Pe3do PolyMode = Bar, Bar charts are lighted to better match lighting of Graph Annotations. This will generally make current 3D bar charts look too dark and you will need to change the light positions.

v9.0 Improvements:

Graph and Scientific Graph can now zoom a background image with the data:

One of the Pesgo and Pego improvements is the ability for a background image GraphBmpFilename to zoom with the chart. See example 120. Both 2D contours and normal charts can benefit from this improvement. One enables this feature by setting a new Bitmap Style PEBS_BITBLT_ZOOMING (10) via the GraphBmpStyle property.

When intending a graph background bitmap to zoom with the data, one can define the relationship of the bitmap to the data units with the properties below: Note these are optional and one can possibly only define the extents of the axes with ManualScaleControlY and ManualScaleControlX in cases where the background image happens to match your data or fixed range. Using the below properties will allow the developer to zoom the background image with respect to the manually set range of the axes.

#define PEP_fGRAPHBMPMINX

Pego, Pesgo

PeGrid.Configure.GraphBmpMinX
Gets and Sets the minimum X data value associated with extent of the GraphBmpFilename when GraphBmpStyle is set to BitBltZooming, enabling background bitmap zooming. See example 120.

#define PEP_fGRAPHBMPMAXX

Pego, Pesgo

PeGrid.Configure.GraphBmpMaxX
Sets the maximum X data value associated with extent of the GraphBmpFile.

#define PEP_fGRAPHBMPMINY
Pego, Pesgo

PeGrid.Configure.GraphBmpMinY
Sets the minimum Y data value associated with extent of the GraphBmpFile.

Pego, Pesgo

PeGrid.Configure.GraphBmpMaxY
Sets the maximum Y data value associated with extent of the GraphBmpFile.

Pego, Pesgo, Pepso, Pepco, Pe3do

PeColor.GraphBmpAlways

This feature is useful when you want a background bitmap to zoom with the chart. When set True, the custom file defined by GraphBmpFilename will always be the background bitmap even though the user might change the ViewingStyle setting via the customization dialog or popup menu if end user adjustments are enabled via AllowColorPage.See example 120

#define PEP_bDESKBMPALWAYS

Pego, Pesgo, Pepso, Pepco, Pe3do

PeColor.DeskBmpAlways

When set True, the custom file defined by DeskBmpFilename will always be the background bitmap even though the user might change the ViewingStyle setting via the customization dialog or popup menu if end user adjustments are enabled via AllowColorPage. See example 120

2D and 3D Contour improvements:

The Pesgo 2D contours have been re-written and implemented with Direct3D (RenderEngine = Direct3D). This greatly improves the speed and quality.

Translucency and zoomable background images are now supported. See example 120

Improved null data handling for contour charts in 2D and 3D. New features to cull/hide the contours and or force a plateau/constant-color when manually scaling the contour's axis. See example 120 and compare to example 402 as it configures the data similarly so one can compare the contour plateau and contour null data handling between 2D and 3D. Example 403 also shows plateaus and potential null data, try the popup menu and change PlottingMethod.

Improved legend construction and labeling.

Improvements allowing full control defining the color-to-data value relationship. Colors are no longer limited to an equally spaced/sized distribution. See example 402.

Moving the mouse over the 2D contour now allows for the developer and/or user to be accurately prompted with the interpolated 3rd dimension data value.

Pe3do Direct3D RenderEngine adds support for top and bottom 2D contours and overlaid wire frames.

The properties used to control the color separation has also been rewritten and improved. And new pre defined colors were added. Both Pesgo and Pe3do use the newly rewritten color designation logic.

#define PEP_nCONTOURCOLORSET

Pesgo, Pe3do

PeColor.ContourColorSet

Default is Zero.

Set this property to enable an automatic set of colors to be generated in the SubsetColors property. This automatic color generation mechanism uses the optional features of PEP_nCONTOURCOLORBLENDS, PEP_faCONTOURCOLORPROPORTIONS, and PEP_nCONTOURCOLORALPHA,

#define PECCS_NONE 0 // no color set is used, SubsetColors or ContourColors controls colors
#define PECCS_CONTOURCOLORS 1 // use PEP_dwaCONTOURCOLORS feature below
#define PECCS_BLUE_GREEN_GREY 2
#define PECCS_BLUE_GREEN_RED 3
#define PECCS_GREEN_YELLOW_RED 4
#define PECCS_BLUE_GREEN_YELLOW_RED 5
#define PECCS_BLUE_GREEN_YELLOW_ORANGE_RED 6
#define PECCS_VIOLET_BLUE_GREEN_YELLOW_ORANGE_RED 7
#define PECCS_BLUE_CYAN_GREEN_LIME_TAN_BROWN_DARKBROWN 8
#define PECCS_BLUE_CYAN_GREEN_YELLOW_BROWN_WHITE 9
#define PECCS_DARKBLUE_BLUECYAN_MEDCYAN_CYANGREEN_DARKGREEN_GREENLIME_DARKLIME_TAN_BROWN_DARKBROWN 10

#define PEP_nCONTOURCOLORBLENDS

Pesgo, Pe3do

PeColor.ContourColorBlends

Default is Zero, disabled.

Set before ContourColorSet or ContourColors. This property creates more gradual color changes between the major colors defined by ContourColorSet or ContourColors. For example, setting to a value of 3 will produce a blending of 3 colors between those defined. Best to set between 3 and 10.

Though there is maximum of 100 contour colors so do not set this property to a value as to exceed 100 contour colors. Blends X Number Of Colors

#define PEP_faCONTOURCOLORPROPORTIONS

Pesgo, Pe3do

PeColor.ContourColorProportions

Default is empty, no items of this property array defined.

This property controls the proportion (weighting or size) of the respective color section. Given the number of contour colors, adding up all proportions defined by this property array should equate to 1. For example if 4 colors are defined or generated by ContourColorSet, and this property array is set to [ 0.25, 0.50, 0.125, 0.125 ], the 2nd color would be twice as wide as the first color and 4 times as wide as the 3rd and 4th colors. Using this property in combination with manually controlling the extents of the contour dimension allows full control of color to data-value relationship.

#define PEP_dwaCONTOURCOLORS
Pesgo, Pe3do

PeColor.ContourColors

Default is empty.

Set the property array elements to take full control of the colors used within the contour color plotting method. An easier method of assigning colors to your contour is through the PEP_nCONTOURCOLORSET property. The developer may optionally set PEP_nCONTOURCOLORBLENDS to automatically create blends between the colors defined.

#define PEP_nCONTOURCOLORALPHA

Pesgo, Pe3do

PeColor.ContourColorAlpha

Default is 1 meaning not used.

Set before setting ContourColorSet. This property controls the alpha (translucency) of the colors generated via ContourColorSet.

#define PEP_bALLOWCONTOURCOLORSSHADOWS

Pesgo

PePlot.Allow.ContourColorsShadows

Default = False

Version 9 has a new plotting method for 2D color contours. This new plotting method will shade or produce a shadow effect ideal for top-view 2D perspectives of geographic information systems (GIS.) Set to True to enable this new potential plotting method. The new plotting method will show in the Popup menu and Customization dialog allowing the end-user to switch from showing a shadow effect or not.

The new plotting method constant is PEGPM_CONTOURCOLORSSHADOWS 37 when setting PlottingMethod in your code.

#define PEP_bCONTOURLOCATIONSQUANTIZE

Pesgo, Pe3do

PePlot.Option.ContourLocationsQuantize

Default = False

Set True to enable a faster pixel shader for coloring contours using ContourColorProportions. When True the shader uses the smallest ContourColorProportion that is then the common denominator of other proportions. This allows the color choice by shader to be one multiplication. Use for large contours with many colors on slower machines with poor graphics hardware, real-time purposes, or as desired in cases where your ContourColorProportions happen to be divisible by a least common denominator.

3D Pe3do Control improvements:

#define PEP_bSHOWWIREFRAME

Pe3do, RenderEngine = Direct3D

PePlot.Option.ShowWireframe

Default = False

This is a potential breaking change for 3D charts using SurfacePolygonBorders.

Version 9 renames the feature of showing iso subset point lines to ShowWireframe. Older versions used SurfacePolygonBorders to control the inclusion of iso subset point lines. Used to quickly show / hide iso subset and point lines for surface type charts. See demo example 402.

#define PEP_nSHOWWIREFRAMEMAXLINES
Pe3do, RenderEngine = Direct3D

PePlot.Option.ShowWireframeMaxLines

Default = 50

When ShowWireFrame is True, and the number of Subsets and or Points is larger than the default 50, or as defined, the control will reduce the frequency of wireframe lines so no more than this max lines is rendered. See demo example 408.

#define PEP_bWATERFALLBORDERS

Pe3do, RenderEngine = Direct3D

PePlot.Option.WaterfallBorders

Default = False

This is a potential breaking change for 3D charts showing a border on waterfall charts with the SurfacePolygonBorders property.

For PolyMode = ScatterMode - PlottingMethod set to Area (WaterFall plot), set this property to True to draw borders on area sections.
Optionally set color of border with BarBorderColor. This creates another potential breaking change as older versions use the first SubsetColor as the border color for waterfall type charts. See demo examples 407 and 411.

#define PEP_bWATERFALLCONTOURS

Pe3do, RenderEngine = Direct3D

PePlot.Option.WaterfallContours

Default = False

Set to True when you want the waterfall area slices to be multi-colored similar to a surface contour chart. The new properties related contour coloring such as ContourColorSet, ContourColorProportions, ContourBlends, ContourColors apply and help create SubsetColors. Else manually setting SubsetColors will apply.

This property is for PolyMode = ScatterMode - PlottingMethod set to Area (WaterFall plot). Optionally set WaterfallBorders and color of border with BarBorderColorSee demo example 411.

#define PEP_nSHOWWIREFRAMEMENU

Pe3do, RenderEngine = Direct3D

PeUserInterface.Menu.ShowWireframeMenu

Default = True

This property shows / hides the popup menu item allowing end-user to control the ShowWireFrame property when AllowPopup enables the popup. See example 402 right click popup menu. .
PEMC_HIDE (0)

PEMC_SHOW (1)

PEMC_GRAYED (2)

#define PEP_dw3DHIGHLIGHTCOLOR

Pe3do

PeUserInterface.Cursor.HighlightColor

DWORD / Color

Gets or Sets a color used to highlight the polygon or subset/point related polygons under mouse when RenderEngine = Direct3D. See example 400.

#define PEP_bDXPSMANUALCULLY

Pe3do

BOOLEAN Default = False

PeGrid.Configure.DxPsManualCullY

Set to True when manually scaling a 3D chart and want the highest quality culling to your manual extents. This culls both the ManualMinY and ManualMaxY settings. ManualScaleCullMinY and ManualScaleCullMaxY are also recommended as these will cull at the vertex shader level and reduce the overhead of the pixel shader. See example 402.

#define PEP_bDXPSMANUALCULLXZ

Pe3do

BOOLEAN Default = False

PeGrid.Configure.DxPsManualCullXZ

#define PEP_bDXPSANTIALIASCONTOUREDGES
Pe3do

BOOLEAN Default = True

PePlot.Option.DxPsAntiAliasContourEdges

Likely only needed and set False in demanding real-time scenarios or when designing systems which will not support discreet graphics. The Direct3D contour will by default blend the colors between the contour color changes. This helps prevent jagged edges along contour color transitions and also provides additional visual contour information along the edges. If you zoom in on a contour edge in example 401 or 402, you will see the effect as its enabled by default.

#define PEP_n3DXFOV

Pe3do, RenderEngine = Direct3D

PePlot.Option.DxFOV

Isometric/Pictoral Perspective support. Default value of 1 which defaults to 45 degree FOV and a fair amount of perspective distortion. We recommend setting to 10 for a more isometric perspective. We calcuate FOV= Pi/(4 * PEP_n3DXFOV). When setting this property, we automatically modify the camera by increasing distance setting DxZoom, though the developer will likely want to use DegreePromping = TRUE while developing and choose a more optimal DxZoom, DxViewportX, DxViewportY to be set after changing DxFOV from the default. See example 404.

#define PEP_nDXTRANSPARENCYMODE

Pe3do, RenderEngine = Direct3D

PeColor.DxTransparencyMode

Default = 0, no special handling of z distance as relates to data. Set to OIT (order independent transparency) if you define colors within a Pe3do Direct3D rendering with alpha channel less than 255 or 1.0F. This feature is optional, if you happen to render the scene with translucent data at a specific DegreeOfRotation that inherently causes the tris to render back to front, then the image will look correct. However; rotating the image will show the translucent data not correctly handled for all rotation angles. Setting DxTransparencyMode to OIT will impact the performance/speed in rendering a scene(graphic cards or lack of a graphics card will impact performance the most), however, the performance is still much faster that sorting the tris with a painters algorithm each time the rotation angle is changed. The OIT feature has an optional setting DxOitDepth that you might want to set if you know the scene's complexity is limited. See example 403 and 404..

#define PETM_NONE 0
#define PETM_OIT 1

#define PEP_nDXOITDEPTH

Pe3do, RenderEngine = Direct3D

PeColor.DxOitDepth

When using DxTransparencyMode OIT, this feature defines the quantity of overlapping triangles the OIT shader can handle before causing artifacts. Set to 32 for your more simple charts if you want to optimize resource use. Currently only settings of 0, 32, and 64 are supported. Default setting of 0 uses depth of 64.

#define PEP_nDXMSAA

Pe3do, Pego, Pesgo, RenderEngine = Direct3D

PeSpecial.DxMSAA

When RenderEngine is set to Direct3D, Set to reduce or disable the default setting of 8 multi samples. In rare cases one may want to reduce to 4 or 0 for performance or graphic system reasons.

#define PEMSAA_8 0
#define PEMSAA_1 1
#define PEMSAA_4 2

#define PEP_structGRAPHANNOTPOLYDATA

Pe3do, RenderEngine = Direct3D

Similarly implemented to PEP_nPLOTTINGMETHOD = PolygonData and demo example 406. This property allows for GraphAnnotations to be polygondata for Direct3D rendered images. This feature allows for your own surface, plane, or any 3D polygon render to be combined with any PlottingMethod rendering such as scatter or surface. See example 404.

#define PEP_nDXSPHERECOMPLEXITY

Pe3do, RenderEngine = Direct3D

PePlot.Option.DxSphereComplexity

Default = 6. Range is 2 to 20. Generally one does not need to set this property. It will reduce from 6 to 2 if large data sets are rendered. At a setting of 2, the dot/sphere point type will equate to a small diamond. One may increase from 6 to 10 or more if needing a highly accurate sphere (for example for extra large point symbol sizes.)

#define PEP_nDXSCATTEROCTREESIZE

Pe3do, RenderEngine = Direct3D

PeUserInterface.HotSpot.DxScatterOctreeSize

Default 10000. When 3D scatter hot spots are enabled, this property defines the size of the largest octree grouping before the octree is again subdivided into 8 sub octrees. The more sub divisions of octrees (smaller value of ScatterOctreeTreeSize) then the longer delay in creating rendering/image but faster the real-time searching for the data point under the mouse. Some possible values may be 5000 or 100000 depending on your preference in delay in rendering vs real-time cpu needed to find the hot spot.

#define PEP_nDXSCATTEROCTREEGROWBY

Pe3do, RenderEngine = Direct3D

PeUserInterface.HotSpot.DxOxtreeGrowBy

Default is 150000. Likely not needing changing, but when the hot spot feature's oct tree memory needs to grow, it grows by this amount. Larger values reduce memory thrashing. Smaller values use less memory.

New ToolTip and Floating Text CursorPromptLocation settings:

Version 9 adds new ToolTip features allowing for data coordinate prompting and custom prompting near the mouse's cursor.

All RenderEngine settings support a bounded box floating tool tip. This is the new default style of CursorPromptLocation as set to PECPL_TRACKING_TOOLTIP 2.

RenderEngine = Direct3D supports a borderless floating text tool tip when CursorPromptLocation is set to PECPL_TRACKING_TEXT 3

See example 007, 030, 105,123, 400, 402. These examples not only use the new cursor prompt location, but implement dynamically changing tool tip content.

#define PEP_fFONTSIZETRACKINGCNTL

Pego, Pesgo, Pepso, Pe3do

PeUserInterface.Cursor.FontSizeTrackingCntl

Default = 0.0 and disabled, type float

Set to .5 to 2.0 to decrease or increase the size of the text of the ToolTip or FloatingText styles of CursorPromptLocation.

#define PEP_nTRACKINGTOOLTIPMAXWIDTH

Pego, Pesgo, Pepso, Pe3do

PeUserInterface.Cursor.TrackingTooltipMaxWidth

Default = 0.0 Disabled, tool tip width will grow as needed.

This property is used to set a maximum tool tip width. If string content will not fit, the text will be forced to line-feed. Set to a value from 50 to 2000 pixels. Setting this property will cause x, y and z data prompting (CursorPromptStyle), to place each item on a new line.

Pego, Pesgo, Pepso, Pe3do

PeUserInterface.Cursor.TrackingCustomDataText

Default = False and disabled

Set to True and also implement a message handler (PEWN_CUSTOMTRACKINGDATATEXT) or CustomTrackingDataText event handler. When True, the tool tip, floating text, or standard top-left, top-right cursor prompt will request text via this message/event handler. Within the TrackingCustomDataText handler, one will set the property PEP_szTRACKINGTEXT which provides the requested text. The tracking events for this feature are limited to within the charting grid area. To change the tool tip text for areas outside the charting area (Title, Legend, or TableAnnotation, etc) then use the PEP_bTRACKINGCUSTOMOTHERTEXT feature.

See example 007, 030, 105, 123, 400, 402.

#define PEP_nTRACKINGPROMPTTRIGGER
Pego, Pesgo, Pepso

PeUserInterface.Cursor.TrackingPromptTrigger

Default = NA

Read this property when implementing the CustomTrackingDataText event/message.

0 = PETPT_MOUSEMOVE = Mouse Move triggered the CUSTOMTRACKINGDATATEXT event/message.

1 = PETPT_CURSORMOVE = Cursor Move triggered the CUSTOMTRACKINGDATATEXT event/message.

When both CursorMode and CursorPromptTracking are used together, then one may need to read this property to learn if a mousemove or cursormove triggered the event.

#define PEP_szTRACKINGTEXT

Pego, Pesgo, Pepso, Pe3do

.Net, see TrackingText argument as part of PeCustomTrackingDataText and PeCustomTrackingOtherText events

Default = NA

Set this property within your implementation of the CustomTrackingDataText message/event handler. PEP_bCUSTOMTRACKINGDATATEXT should be set to True to trigger the CustomTrackingDataText messages/events.

PeUserInterface.Cursor.TrackingTooltipTitle

Default = empty, no title

Sets a bold title string as the first line of the ToolTip cursor prompt when CursorPromptTracking is True and CursorPromptLocation is set to ToolTip or Text. The title string can be static, or set dynamically if TrackingCustomDataText is True and handling the CustomTrackingDataText message/event.

PeUserInterface.Cursor.TrackingTooltipTipBkColor

Default = 1, empty, standard tool tip color defined by operating system

Sets the tool tip background color when CursorPromptTracking is True and CursorPromptLocation is set to ToolTip. The color can be static, or set dynamically if TrackingCustomDataText is True and handling the CustomTrackingataText message/event.

See example 105.

PeUserInterface.Cursor.TrackingTooltipTipBkColor

Default = 1, empty, standard tool tip color defined by operating system

Sets the tool tip text color when CursorPromptTracking is True and CursorPromptLocation is set to ToolTip. The color can be static, or set dynamically if TrackingCustomDataText is True and handling the CustomTrackingDataText message/event.

PeUserInterface.Cursor.TrackingCustomOtherText

Default = False and disabled

Similar to TrackingCustomDataText, this feature is for dynamically updating the tooltip text when outside the charting area. For example when over a title or legend, or tableannotation hotspot area.

Set to True and also implement a message handler (PEWN_CUSTOMTRACKINGOTHERTEXT) or CustomTrackingOtherText event handler. When True, the tool tip, floating text, or standard top-left, top-right cursor prompt will request text via this message/event handler. Within the CustomTrackingOtherText handler, one will set the property PEP_szTRACKINGTEXT which provides the requested text. See example 105, moving the mouse over the axis labels.

.Net, call Api.PEnget to read as necessary

This feature might be useful for a low level need where the developer can call SendMessage with messages similar to TTM_TRACKPOSITION, TTM_TRACKACTIVATE, and other tool tip useful low level features.

General Charting Improvements:

#define PEP_bMOUSECURSORCONTROLCLOSESTPOINT
Pego, Pesgo

PeUserInterface.Cursor.MouseCursorControlClosestPoint

Default = False

When set to True the end-user does not need to click on a data hotspot to move the cursor ( when CursorMode is set to a mode giving a subset and point index focus.) When True, the control will search for the closest data point to the mouse when the chart is clicked. For Pesgo controls, the XData must be sequentially increasing. This property internally uses a new function that provides data searching capabilities. This feature allows for data hot spot functionality without the overhead of hit testing normally used with AllowDataHotSpots. Thus AllowDataHotSpots is not required.

See examples 007, 105, 110.

Function int PEsearchsubsetpointindex(HWND hObject, int nX, int nY)

Pego Pesgo

.Net uses PeFunction.SearchSubsetPointIndex

Version 9 adds a new function to return both Subset and Point index closest to nX and nY pixel location. If the return value is True (non zero), read the PEP_nCLOSESTSUBSETINDEX and PEP_nCLOSESTPOINTINDEX properties to learn the function's search results. PEP_nCLOSESTSUBET will also

be set to -1 if an error happens during this function call.

.Net interfaces, use PeFunction.SearchSubsetPointIndex

This feature allows for data hot spot functionality without the overhead of hit testing normally used with AllowDataHotSpots. Thus AllowDataHotSpots is not required.

See the demo code, for MouseMove event, example 014

#define PEP_nCLOSESTSUBSETINDEX

Pego, Pesgo

Used with PEsearchsubsetpointindex function to read function results.

#define PEP_nCLOSESTPOINTINDEX

Pego, Pesgo

Used with PEsearchsubsetpointindex function to read function results.

Function int PEsearchpointindex(HWND hObject, double dX, int nSubset, int nLocation)

Pesgo

.Net uses PeFunction.SearchPointIndex

Version 9 adds a new function to return closest Point index based on search criteria of XData value, Subsets index, and a location.

The function returns -1 if an error occurs, else the return value is the point index.

nLocation = 0, MainChartingArea, test for visibility
nLocation = 1, MainChartingArea, no test for visibility
nLocation = 2, ZoomWindow
.Net interfaces, use PeFunction.SearchPointIndex

#define PEP_bMOUSEWHEELZOOMEVENTS

Pego, Pesgo, Pe3do

PeUserInterface.ScrollBar.MouseWheelZoomEvents

Set to True/non-zero to enable the PEWN_ZOOMIN notification message and ZoomIn events (.Net, ActiveX, VCL visual interfaces) to be generated upon zooming inward and outward via MouseWheel as enabled by MouseWheelFunction

#define PEP_fFONTSIZESUBTITLECNTL

Pego, Pesgo, Pepso, Pepco, Pe3do

PeFont.SizeSubtitleCntl

Default = 0, disabled, FontSizeTitleCntl controls both MainTitle and SubTitle sizes where SubTitles are smaller.

This property allows control of both the MainTitle font size and SubTitle font size. If you want sub title text enlarged, increase to 1.25 or a maximum of 1.5. If you want sub title text reduced, decrease from 1.0 to any value greater than 0.5.

#define PEP_bIMPROVEDCURSOR

Pego, Pesgo WPF only

PeUserInterface.Cursor.ImprovedCursor

Currently only supported for wpf interfaces as the WPF interface ( not being a true Window with window Handle ) was not idea for our current cursor logic used across the other interface types. We may add for all interfaces in future.

Set to True/non-zero to enable an alternate cursor enabled with CursorMode that draws in a more normal WPF drawing technology rather than the R2_NOT pen approach. This means the cursor does not draw as fast as it takes an image redraw to move the cursor, however, the cursor color can be controlled and the cursor behaves better in complex projects with multiple charts in the same window.

#define PEP_dwCURSORCOLOR

Pego, Pesgo, WPF only

PeUserInterface.Cursor.CursorColor
Controls the color of the cursor when using CursorMode and PEP_bIMPROVEDCURSOR. Default is value or 1, meaning the control attempts to auto configure the color to match the GraphBackground color. Else define a 32 bit color. Where the alpha channel value of 100 or as desired makes the cursor translucent so one can see the graphics behind the cursor.

#define PEP_bCURSORPROMPTSHORTEN

Pego, Pesgo, Pepso, Pe3do

PeUserInterface.Cursor.PromptShorten
When set to True/non-zero, if the cursor prompt strings contains a numeric value over 9 digits, then the format is switched to exponential form so the string never exceeds 9 digits.

#define PEP_bAUTOSCALEHORZLINEANNOTATIONS

Pego, Pesgo, Pe3do

PeGrid.Configure.AutoScaleHorzLineAnnotations

Set to True/non-zero when you want the chart's y axis range to auto scale (ManualScaleControlY = Auto) by also considering the horizontal y axis line annotation data, HorzLineAnnotation.

#define PEP_bAUTOSCALEVERTLINEANNOTATIONS

Pego, Pesgo, Pe3do

PeGrid.Configure.AutoScaleVertLineAnnotations

Set to True/non-zero when you want the chart's x axis range to auto scale (ManualScaleControlX = Auto) by also considering the vertical x axis line annotation data. VertLineAnnotation. For Pe3do controls, this feature relates to both the XAxis line annotations and ZAxis line annotations.

#define PEP_bAUTOSCALEGRAPHANNOTATIONS

Pego, Pesgo, Pepso, Pe3do

PeGrid.Configure.AutoScaleGraphAnnotations
Set to True/non-zero when you want the chart's x and y axis ranges to auto scale (ManualScaleControlY, ManualScaleControlX = Auto) by also considering the GraphAnnotatonX and GraphAnnotationY data.

 #define PEP_naSUBSETFORHOTSPOTS

Pego, Pesgo, Pepso, Pe3do

PeUserInterface.HotSpot.SubsetForHotSpots

Empty by default, if you define elements of this property array, then only those subset indices defined will generate hot spot locations and events. For example if AllowDataHots is enabled, hotspots can be limited to 1st and 4th subsets with...

Pesgo1.PeUserInterface.HotSpot.SubsetForHotSpots[0] = 0; // 1st subset

Pesgo1.PeUserInterface.HotSpot.SubsetForHotSpots[1] = 3; // 4th subset

later to enable all subsets, empty like PeUserInterface.HotSpot.SubsetForHotSpots.Clear();

When the chart is initialized with this setting, the mousemove event based logic to search hotspots can potentially execute faster.

#define PEP_naSUBSETFORGETHOTSPOT

Pego, Pesgo, Pepso, Pe3do

PeUserInterface.HotSpot.SubsetForGetHotSpot
Empty by default, if you define elements of this property array, then only those subset indices defined will be enabled to work with the PEgethotspot hot spot search mechanism. This enables a quick way to enable/disable potential hot spot events without rebuilding the image and resulting hot spot underlying memory demands.

#define PEP_bFLOATINGSTICKS

Pego, Pesgo

PePlot.Option.FloatingSticks

Similar to floating bars, as in demo example 025. This feature enables the Stick Plotting method to function as a floating stick plotting method. Using ZData to control lower stick value and ZData being considered in auto scaling logic. SubsetLineTypes can be used to control thickness of sticks.

#define PEP_fSGRAPH_DAY_DENSITY

#define PEP_fSGRAPH_HOUR_DENSITY

#define PEP_fSGRAPH_MINUTE_DENSITY

#define PEP_fSGRAPH_SECOND_DENSITY

Pesgo

PeGrid.Option.DateTimeDayDensity

PeGrid.Option.DateTimeHourDensity

The above properties default to zero and disabled by default. When the Pesgo controls DateTimeMode x axis date time scale is less or more dense than needed, one can set these properties to influence the potential density of grid line/grid labels. Setting to a value of 2.0 means you need labels twice as dense. Setting to a value of .5 means you need labels half as dense. Generally not needed, but when creating static reports with the Pesgo and DateTimeMode, this feature can be useful forcing more grid lines as our default logic is conservative in attempting to prevent too dense a grid and overlapping text.

#define PEP_fCURSORVALUEX

Pego, Pesgo, Pepso, Pe3do

double

PeUserInterface.Cursor.CursorValueX

Read only, after calling GetHotSpotData and CursorPromptTracking and or HighlightColor is non zero. Reads the X value under mouse position.

Search the various example code for CursorValueX to see examples.

#define PEP_fCURSORVALUEY

Pego, Pesgo, Pepso, Pe3do

double

PeUserInterface.Cursor.CursorValueY

Read only, after calling GetHotSpotData and CursorPromptTracking and or HighlightColor is non zero. Reads the Y value under mouse position.

Search the various example code for CursorValueX to see examples.

Pesgo, Pe3do

double

PeUserInterface.Cursor.CursorValueZ

Read only, after calling GetHotSpotData and CursorPromptTracking and or HighlightColor is non zero. Reads the Z value under mouse position.

New properties used to implement realtime implementations that revolve the subset data. One common scenario for this feature is realtime 3D waterfall charts where a new subset represents a new slice of the waterfall. Note that SubsetByPoint must be true to use these features.

Pe3do, Pesgo, Pepso, Pego

#define PEP_faAPPENDYSUBSET

#define PEP_faAPPENDXSUBSET

#define PEP_faAPPENDZSUBSET

#define PEP_faAPPENDYIISUBSET
#define PEP_faAPPENDXIISUBSET
#define PEP_faAPPENDZIISUBSET
Above properties are only used with PEvset where lpvData is a pointer to the new data, and nItems is set to the number of Subsets being updated. To update/revolve 1 new subset, nItems will be set to 1, and lpvData will point to a buffer holding Points worth of data. Or to updated/revolve 2 new subsets, nItems will be set to 2, and lpvData will point to a buffer holding 2 x Points worth of data. APPENDYSUBSET is for 4 byte float data and APPENDYIISUBSET is for double data when UsingYDataII is true. AppendToEnd will control direction of shifting subset data. See example 411's realtime Timer event code.

#define PEP_bCUSTOMIZEDLGCANCELMSG

Pego, Pesgo, Pepso, Pepco, Pe3do

BOOLEAN Default = True

PeUserInterface.Dialog.CustomizeDlgCancelMsg

Controls if the customization dialog sends the PEWN_CUSTOMIZEDLG message and .Net interfaces invoke the PeCustomizeDlg event when the dialog closes. Older versions only sent this message/event when the OK button was pressed. Now if the users closes the dialog or the dialog closes because of ModelessAutoClose, the developer can test for this case by reading the property DialogResult. Adding PeUserInterface.Dialog.DialogResult

#define PEP_bEXPORTPNGASDIBTOCLIP

Pego, Pesgo, Pepso, Pepco, Pe3do

BOOLEAN Default = True

PeUserInterface.Dialog.ExportPngAsDibToClip

When exporting a PNG to the clipboard via the built in export dialog, this property controls if the actual export is sent as a DIB rather than PNG. The PNG clipboard format is not commonly supported by containers and a DIB format often makes more sense.

#define PEP_bDXPIXELSHADER

Pesgo, Pe3do

BOOLEAN Default = True

PeSpecial.DxPixelShader

Likely not needed but included incase one wants to limit the use of the pixel shader on graphics hardware.

New Items related to expanding existing features into the Direct3D domain.

Pesgo RenderEngine = Direct3D now supports point plotting methods. Symbols are limited to diamond, square, triangles or simple types associated with high speed scatter rendering via geometry shader. Version 9.8.0.10 adds hollow (non-solid line type symbols)

New CursorPromptStyle options.

#define PECPS_XYZVALUES 4

Pesgo improves 2D contours with interpolated data value prompting under the mouse, and adds the option to prompt x, y and z data values.

Pe3do adds x, y, and z data value prompting.
#define PECPS_ZVALUES 5

Pe3do, adds feature to only prompt z data value.

Pe3do, adds hot spot support for MainTitle, SubTitle, MultiSubTitles, MultiBottomTitles, SubsetLabels, and PointLabels (for 3d bars). Along with x, y, and z axis grid numbers.

Pe3do, adds small, medium, large arrow and vector 3D graph annotations. All solid lines thicknesses, including options for tubes is supported.

New 3D Line Annotations, support for creating custom axes in Direct3D.

v9.8.0.10 adds hot spots for the 3d line annotation text.

Pe3do RenderEngine = Direct3D now support line annotations. As the Pe3do's grid contains a patching effect, be sure to define any annotations of type 7,8,14,15 first, and in magnitude order from least magnitude to highest magnitude. This feature allows for using line annotations to construct a custom grid similar to example 005, but for Pe3do and Direct3D and supporting the grid patch look. For other non-grid type annotations (not 7,8,14,15) only ThinSolidLines are supported as of this writing.

Improved Dynamic Buffer feature 

The Dynamic Buffers feature shown in demo example 138 has been improved related to performance and use-ability.