Repository navigation
Expand file tree
/
Copy pathPLStreamGenerated.cs
More file actions
2713 lines (2523 loc) · 231 KB
/
Copy pathPLStreamGenerated.cs
File metadata and controls
2713 lines (2523 loc) · 231 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
using System;
using System.Text;
using System.Runtime.InteropServices;
namespace PLplot
{
// type aliases
using PLBOOL = Boolean;
using PLCHAR = Char;
using PLUTF8 = Byte;
using PLINT = Int32;
using PLFLT = Double;
using PLUNICODE = UInt32;
using PLPointer = IntPtr;
using FILE = IntPtr;
using PLUTF8_STRING = String; // 8-bit string in UTF8 encoding
using PLCHAR_STRING = String; // 8-bit string in ANSI encoding
using PLFLT_MATRIX = IntPtr; // input matrix
using PLFLT_NC_MATRIX = IntPtr; // output matrix
public partial class PLStream
{
/// <summary>pl_setcontlabelformat: Set format of numerical label for contours</summary>
/// <param name="lexp">If the contour numerical label is greater than 10^(lexp) or less than 10^(-lexp), then the exponential format is used. Default value of lexp is 4.</param>
/// <param name="sigdig">Number of significant digits. Default value is 2.</param>
/// <remarks>Set format of numerical label for contours.</remarks>
public void setcontlabelformat(PLINT lexp, PLINT sigdig)
{
lock (libLock)
{
ActivateStream();
Native.setcontlabelformat(lexp, sigdig);
}
}
/// <summary>pl_setcontlabelparam: Set parameters of contour labelling other than format of numerical label</summary>
/// <param name="active">Activate labels. Set to 1 if you want contour labels on. Default is off (0).</param>
/// <param name="offset">Offset of label from contour line (if set to 0.0, labels are printed on the lines). Default value is 0.006.</param>
/// <param name="size">Font height for contour labels (normalized). Default value is 0.3.</param>
/// <param name="spacing">Spacing parameter for contour labels. Default value is 0.1.</param>
/// <remarks>Set parameters of contour labelling other than those handled by pl_setcontlabelformat.</remarks>
public void setcontlabelparam(PLFLT offset, PLFLT size, PLFLT spacing, PLINT active)
{
lock (libLock)
{
ActivateStream();
Native.setcontlabelparam(offset, size, spacing, active);
}
}
/// <summary>pladv: Advance the (sub-)page</summary>
/// <param name="page">Specifies the subpage number (starting from 1 in the top left corner and increasing along the rows) to which to advance. Set to zero to advance to the next subpage (or to the next page if subpages are not being used).</param>
/// <remarks>Advances to the next subpage if sub=0, performing a page advance if there are no remaining subpages on the current page. If subpages aren't being used, pladv(0) will always advance the page. If pagegt0, PLplot switches to the specified subpage. Note that this allows you to overwrite a plot on the specified subpage; if this is not what you intended, use pleop followed by plbop to first advance the page. This routine is called automatically (with page=0) by plenv, but if plenv is not used, pladv must be called after initializing PLplot but before defining the viewport.</remarks>
public void adv(PLINT page)
{
lock (libLock)
{
ActivateStream();
Native.adv(page);
}
}
/// <summary>plarc: Draw a circular or elliptical arc</summary>
/// <param name="a">Length of the semimajor axis of the arc.</param>
/// <param name="angle1">Starting angle of the arc relative to the semimajor axis.</param>
/// <param name="angle2">Ending angle of the arc relative to the semimajor axis.</param>
/// <param name="b">Length of the semiminor axis of the arc.</param>
/// <param name="fill">Draw a filled arc.</param>
/// <param name="rotate">Angle of the semimajor axis relative to the X-axis.</param>
/// <param name="x">X coordinate of arc center.</param>
/// <param name="y">Y coordinate of arc center.</param>
/// <remarks>Draw a possibly filled arc centered at x, y with semimajor axis a and semiminor axis b, starting at angle1 and ending at angle2.</remarks>
public void arc(PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2, PLFLT rotate, PLBOOL fill)
{
lock (libLock)
{
ActivateStream();
Native.arc(x, y, a, b, angle1, angle2, rotate, fill);
}
}
/// <summary>plaxes: Draw a box with axes, etc. with arbitrary origin</summary>
/// <param name="nxsub">Number of subintervals between major x axis ticks for minor ticks. If it is set to zero, PLplot automatically generates a suitable minor tick interval.</param>
/// <param name="nysub">Number of subintervals between major y axis ticks for minor ticks. If it is set to zero, PLplot automatically generates a suitable minor tick interval.</param>
/// <param name="x0">World X coordinate of origin.</param>
/// <param name="xopt">One or more string concatenated from <see cref="XYAxisOpt"/>.</param>
/// <param name="xtick">World coordinate interval between major ticks on the x axis. If it is set to zero, PLplot automatically generates a suitable tick interval.</param>
/// <param name="y0">World Y coordinate of origin.</param>
/// <param name="yopt">One or more string concatenated from <see cref="XYAxisOpt"/>.</param>
/// <param name="ytick">World coordinate interval between major ticks on the y axis. If it is set to zero, PLplot automatically generates a suitable tick interval.</param>
/// <remarks>Draws a box around the currently defined viewport with arbitrary world-coordinate origin specified by x0 and y0 and labels it with world coordinate values appropriate to the window. Thus plaxes should only be called after defining both viewport and window. The ascii character strings xopt and yopt specify how the box should be drawn as described below. If ticks and/or subticks are to be drawn for a particular axis, the tick intervals and number of subintervals may be specified explicitly, or they may be defaulted by setting the appropriate arguments to zero.</remarks>
public void axes(PLFLT x0, PLFLT y0, string xopt, PLFLT xtick, PLINT nxsub, string yopt, PLFLT ytick, PLINT nysub)
{
lock (libLock)
{
ActivateStream();
Native.axes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub);
}
}
/// <summary>plbin: Plot a histogram from binned data</summary>
/// <param name="opt">Is a combination of several flags: opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the outer bins are expanded to fill up the entire x-axis and bins of zero height are simply drawn. opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway between the x values. If the values in x are equally spaced, the values are the center values of the bins. opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal size as the ones inside. opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn (there is a gap for such bins).</param>
/// <param name="x">A vector containing values associated with bins. These must form a strictly increasing sequence.</param>
/// <param name="y">A vector containing a number which is proportional to the number of points in each bin. This is a PLFLT (instead of PLINT) vector so as to allow histograms of probabilities, etc.</param>
/// <remarks>Plots a histogram consisting of nbin bins. The value associated with the i'th bin is placed in x[i], and the number of points in the bin is placed in y[i]. For proper operation, the values in x[i] must form a strictly increasing sequence. By default, x[i] is the left-hand edge of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are placed midway between the values in the x vector. Also see plhist for drawing histograms from unbinned data.</remarks>
public void bin(PLFLT[] x, PLFLT[] y, Bin opt)
{
lock (libLock)
{
ActivateStream();
Native.bin(x, y, opt);
}
}
/// <summary>plbtime: Calculate broken-down time from continuous time for the current stream</summary>
/// <param name="ctime">Continuous time from which the broken-down time is calculated.</param>
/// <param name="day">Returned value of day within the month in the range from 1 to 31.</param>
/// <param name="hour">Returned value of hour within the day in the range from 0 to 23.</param>
/// <param name="min">Returned value of minute within the hour in the range from 0 to 59</param>
/// <param name="month">Returned value of month within the year in the range from 0 (January) to 11 (December).</param>
/// <param name="sec">Returned value of second within the minute in range from 0. to 60.</param>
/// <param name="year">Returned value of years with positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2 BCE, etc.)</param>
/// <remarks>Calculate broken-down time; year, month, day, hour, min, sec; from continuous time, ctime for the current stream. This function is the inverse of plctime.</remarks>
public void btime(out PLINT year, out PLINT month, out PLINT day, out PLINT hour, out PLINT min, out PLFLT sec, PLFLT ctime)
{
lock (libLock)
{
ActivateStream();
Native.btime(out year, out month, out day, out hour, out min, out sec, ctime);
}
}
/// <summary>plbop: Begin a new page</summary>
/// <remarks>Begins a new page. For a file driver, the output file is opened if necessary. Advancing the page via pleop and plbop is useful when a page break is desired at a particular point when plotting to subpages. Another use for pleop and plbop is when plotting pages to different files, since you can manually set the file name by calling plsfnam after the call to pleop. (In fact some drivers may only support a single page per file, making this a necessity.) One way to handle this case automatically is to page advance via pladv, but enable familying (see plsfam) with a small limit on the file size so that a new family member file will be created on each page break.</remarks>
public void bop()
{
lock (libLock)
{
ActivateStream();
Native.bop();
}
}
/// <summary>plbox: Draw a box with axes, etc</summary>
/// <param name="nxsub">Number of subintervals between major x axis ticks for minor ticks. If it is set to zero, PLplot automatically generates a suitable minor tick interval.</param>
/// <param name="nysub">Number of subintervals between major y axis ticks for minor ticks. If it is set to zero, PLplot automatically generates a suitable minor tick interval.</param>
/// <param name="xopt">One or more string concatenated from <see cref="XYAxisOpt"/>.</param>
/// <param name="xtick">World coordinate interval between major ticks on the x axis. If it is set to zero, PLplot automatically generates a suitable tick interval.</param>
/// <param name="yopt">One or more string concatenated from <see cref="XYAxisOpt"/>.</param>
/// <param name="ytick">World coordinate interval between major ticks on the y axis. If it is set to zero, PLplot automatically generates a suitable tick interval.</param>
/// <remarks>Draws a box around the currently defined viewport, and labels it with world coordinate values appropriate to the window. Thus plbox should only be called after defining both viewport and window. The ascii character strings xopt and yopt specify how the box should be drawn as described below. If ticks and/or subticks are to be drawn for a particular axis, the tick intervals and number of subintervals may be specified explicitly, or they may be defaulted by setting the appropriate arguments to zero.</remarks>
public void box(string xopt, PLFLT xtick, PLINT nxsub, string yopt, PLFLT ytick, PLINT nysub)
{
lock (libLock)
{
ActivateStream();
Native.box(xopt, xtick, nxsub, yopt, ytick, nysub);
}
}
/// <summary>plbox3: Draw a box with axes, etc, in 3-d</summary>
/// <param name="nxsub">Number of subintervals between major x axis ticks for minor ticks. If it is set to zero, PLplot automatically generates a suitable minor tick interval.</param>
/// <param name="nysub">Number of subintervals between major y axis ticks for minor ticks. If it is set to zero, PLplot automatically generates a suitable minor tick interval.</param>
/// <param name="nzsub">Number of subintervals between major z axis ticks for minor ticks. If it is set to zero, PLplot automatically generates a suitable minor tick interval.</param>
/// <param name="xlabel">A UTF-8 character string specifying the text label for the x axis. It is only drawn if u is in the xopt string.</param>
/// <param name="xopt">One or more string concatenated from <see cref="XYAxisOpt"/>.</param>
/// <param name="xtick">World coordinate interval between major ticks on the x axis. If it is set to zero, PLplot automatically generates a suitable tick interval.</param>
/// <param name="ylabel">A UTF-8 character string specifying the text label for the y axis. It is only drawn if u is in the yopt string.</param>
/// <param name="yopt">One or more string concatenated from <see cref="XYAxisOpt"/>.</param>
/// <param name="ytick">World coordinate interval between major ticks on the y axis. If it is set to zero, PLplot automatically generates a suitable tick interval.</param>
/// <param name="zlabel">A UTF-8 character string specifying the text label for the z axis. It is only drawn if u or v are in the zopt string.</param>
/// <param name="zopt">One or more string concatenated from <see cref="ZAxisOpt"/>.</param>
/// <param name="ztick">World coordinate interval between major ticks on the z axis. If it is set to zero, PLplot automatically generates a suitable tick interval.</param>
/// <remarks>Draws axes, numeric and text labels for a three-dimensional surface plot. For a more complete description of three-dimensional plotting see .</remarks>
public void box3(string xopt, string xlabel, PLFLT xtick, PLINT nxsub, string yopt, string ylabel, PLFLT ytick, PLINT nysub, string zopt, string zlabel, PLFLT ztick, PLINT nzsub)
{
lock (libLock)
{
ActivateStream();
Native.box3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub);
}
}
/// <summary>plcalc_world: Calculate world coordinates and corresponding window index from relative device coordinates</summary>
/// <param name="rx">Input relative device coordinate (0.0-1.0) for the x coordinate.</param>
/// <param name="ry">Input relative device coordinate (0.0-1.0) for the y coordinate.</param>
/// <param name="window">Returned value of the last defined window index that corresponds to the input relative device coordinates (and the returned world coordinates). To give some background on the window index, for each page the initial window index is set to zero, and each time plwind is called within the page, world and device coordinates are stored for the window and the window index is incremented. Thus, for a simple page layout with non-overlapping viewports and one window per viewport, window corresponds to the viewport index (in the order which the viewport/windows were created) of the only viewport/window corresponding to rx and ry. However, for more complicated layouts with potentially overlapping viewports and possibly more than one window (set of world coordinates) per viewport, window and the corresponding output world coordinates corresponds to the last window created that fulfills the criterion that the relative device coordinates are inside it. Finally, in all cases where the input relative device coordinates are not inside any viewport/window, then the returned value of the last defined window index is set to -1.</param>
/// <param name="wx">Returned value of the x world coordinate corresponding to the relative device coordinates rx and ry.</param>
/// <param name="wy">Returned value of the y world coordinate corresponding to the relative device coordinates rx and ry.</param>
/// <remarks>Calculate world coordinates, wx and wy, and corresponding window index from relative device coordinates, rx and ry.</remarks>
public void calc_world(PLFLT rx, PLFLT ry, out PLFLT wx, out PLFLT wy, out PLINT window)
{
lock (libLock)
{
ActivateStream();
Native.calc_world(rx, ry, out wx, out wy, out window);
}
}
/// <summary>plclear: Clear current (sub)page</summary>
/// <remarks>Clears the current page, effectively erasing everything that have been drawn. This command only works with interactive drivers; if the driver does not support this, the page is filled with the background color in use. If the current page is divided into subpages, only the current subpage is erased. The nth subpage can be selected with pladv(n).</remarks>
public void clear()
{
lock (libLock)
{
ActivateStream();
Native.clear();
}
}
/// <summary>plcol0: Set color, cmap0</summary>
/// <param name="icol0">Integer representing the color. The defaults at present are (these may change): 0 black (default background) 1 red (default foreground) 2 yellow 3 green 4 aquamarine 5 pink 6 wheat 7 grey 8 brown 9 blue10 BlueViolet11 cyan12 turquoise13 magenta14 salmon15 white Use plscmap0 to change the entire cmap0 color palette and plscol0 to change an individual color in the cmap0 color palette.</param>
/// <remarks>Sets the color index for cmap0 (see ).</remarks>
public void col0(PLINT icol0)
{
lock (libLock)
{
ActivateStream();
Native.col0(icol0);
}
}
/// <summary>plcol1: Set color, cmap1</summary>
/// <param name="col1">This value must be in the range (0.0-1.0) and is mapped to color using the continuous cmap1 palette which by default ranges from blue to the background color to red. The cmap1 palette can also be straightforwardly changed by the user with plscmap1 or plscmap1l.</param>
/// <remarks>Sets the color for cmap1 (see ).</remarks>
public void col1(PLFLT col1)
{
lock (libLock)
{
ActivateStream();
Native.col1(col1);
}
}
/// <summary>plconfigtime: Configure the transformation between continuous and broken-down time for the current stream</summary>
/// <param name="ccontrol">ccontrol contains bits controlling the transformation. If the 0x1 bit is set, then the proleptic Julian calendar is used for broken-down time rather than the proleptic Gregorian calendar. If the 0x2 bit is set, then leap seconds that have been historically used to define UTC are inserted into the broken-down time. Other possibilities for additional control bits for ccontrol exist such as making the historical time corrections in the broken-down time corresponding to ET (ephemeris time) or making the (slightly non-constant) corrections from international atomic time (TAI) to what astronomers define as terrestrial time (TT). But those additional possibilities have not been implemented yet in the qsastime library (one of the PLplot utility libraries).</param>
/// <param name="day">Day of epoch in range from 1 to 31.</param>
/// <param name="hour">Hour of epoch in range from 0 to 23</param>
/// <param name="ifbtime_offset">ifbtime_offset controls how the epoch of the continuous time scale is specified by the user. If ifbtime_offset is false, then offset1 and offset2 are used to specify the epoch, and the following broken-down time parameters are completely ignored. If ifbtime_offset is true, then offset1 and offset2 are completely ignored, and the following broken-down time parameters are used to specify the epoch.</param>
/// <param name="min">Minute of epoch in range from 0 to 59.</param>
/// <param name="month">Month of epoch in range from 0 (January) to 11 (December).</param>
/// <param name="offset1">If ifbtime_offset is true, the parameters offset1 and offset2 are completely ignored. Otherwise, the sum of these parameters (with units in days) specify the epoch of the continuous time relative to the MJD epoch corresponding to the Gregorian calendar date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers are used to specify the origin to allow users (by specifying offset1 as an integer that can be exactly represented by a floating-point variable and specifying offset2 as a number in the range from 0. to 1) the chance to minimize the numerical errors of the continuous time representation.</param>
/// <param name="offset2">See documentation of offset1.</param>
/// <param name="scale">The number of days per continuous time unit. As a special case, if scale is 0., then all other arguments are ignored, and the result (the default used by PLplot) is the equivalent of a call to plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.). That is, for this special case broken-down time is calculated with the proleptic Gregorian calendar with no leap seconds inserted, and the continuous time is defined as the number of seconds since the Unix epoch of 1970-01-01T00:00:00Z.</param>
/// <param name="sec">Second of epoch in range from 0. to 60.</param>
/// <param name="year">Year of epoch.</param>
/// <remarks>Configure the transformation between continuous and broken-down time for the current stream. This transformation is used by both plbtime and plctime.</remarks>
public void configtime(PLFLT scale, PLFLT offset1, PLFLT offset2, PLINT ccontrol, PLBOOL ifbtime_offset, PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec)
{
lock (libLock)
{
ActivateStream();
Native.configtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec);
}
}
/// <summary>plcont: Contour plot</summary>
/// <param name="clevel">A vector specifying the levels at which to draw contours.</param>
/// <param name="f">A matrix containing data to be contoured.</param>
/// <param name="kx">Start of x indices to consider</param>
/// <param name="lx">End (exclusive) of x indices to consider</param>
/// <param name="ky">Start of y indices to consider</param>
/// <param name="ly">End (exclusive) of y indices to consider</param>
/// <param name="pltr">A callback function that defines the transformation between the zero-based indices of the matrix f and the world coordinates.For the C case, transformation functions are provided in the PLplot library: pltr0 for the identity mapping, and pltr1 and pltr2 for arbitrary mappings respectively defined by vectors and matrices. In addition, C callback routines for the transformation can be supplied by the user such as the mypltr function in examples/c/x09c.c which provides a general linear transformation between index coordinates and world coordinates.For languages other than C you should consult for the details concerning how PLTRANSFORM_callback arguments are interfaced. However, in general, a particular pattern of callback-associated arguments such as a tr vector with 6 elements; xg and yg vectors; or xg and yg matrices are respectively interfaced to a linear-transformation routine similar to the above mypltr function; pltr1; and pltr2. Furthermore, some of our more sophisticated bindings (see, e.g., ) support native language callbacks for handling index to world-coordinate transformations. Examples of these various approaches are given in examples/ltlanguagegtx09*, examples/ltlanguagegtx16*, examples/ltlanguagegtx20*, examples/ltlanguagegtx21*, and examples/ltlanguagegtx22*, for all our supported languages.</param>
/// <remarks>Draws a contour plot of the data in f[nx][ny], using the nlevel contour levels specified by clevel. Only the region of the matrix from kx to lx and from ky to ly is plotted out where all these index ranges are interpreted as one-based for historical reasons. A transformation routine pointed to by pltr with a generic pointer pltr_data for additional data required by the transformation routine is used to map indices within the matrix to the world coordinates.</remarks>
public void cont(PLFLT[,] f, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT[] clevel, TransformFunc pltr)
{
lock (libLock)
{
ActivateStream();
Native.cont(f, kx, lx, ky, ly, clevel, pltr);
}
}
/// <summary>plctime: Calculate continuous time from broken-down time for the current stream</summary>
/// <param name="ctime">Returned value of the continuous time calculated from the broken-down time specified by the previous parameters.</param>
/// <param name="day">Input day in range from 1 to 31.</param>
/// <param name="hour">Input hour in range from 0 to 23</param>
/// <param name="min">Input minute in range from 0 to 59.</param>
/// <param name="month">Input month in range from 0 (January) to 11 (December).</param>
/// <param name="sec">Input second in range from 0. to 60.</param>
/// <param name="year">Input year.</param>
/// <remarks>Calculate continuous time, ctime, from broken-down time for the current stream. The broken-down time is specified by the following parameters: year, month, day, hour, min, and sec. This function is the inverse of plbtime.</remarks>
public void ctime(PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec, out PLFLT ctime)
{
lock (libLock)
{
ActivateStream();
Native.ctime(year, month, day, hour, min, sec, out ctime);
}
}
/// <summary>Converts input values from relative device coordinates to relative plot coordinates.</summary>
public void did2pc(out PLFLT xmin, out PLFLT ymin, out PLFLT xmax, out PLFLT ymax)
{
lock (libLock)
{
ActivateStream();
Native.did2pc(out xmin, out ymin, out xmax, out ymax);
}
}
/// <summary>Converts input values from relative plot coordinates to relative device coordinates.</summary>
public void dip2dc(out PLFLT xmin, out PLFLT ymin, out PLFLT xmax, out PLFLT ymax)
{
lock (libLock)
{
ActivateStream();
Native.dip2dc(out xmin, out ymin, out xmax, out ymax);
}
}
/// <summary>plenv: Set up standard window and draw box</summary>
/// <param name="axis">Controls drawing of the box around the plot: -2: draw no box, no tick marks, no numeric tick labels, no axes. -1: draw box only. 0: draw box, ticks, and numeric tick labels. 1: also draw coordinate axes at x=0 and y=0. 2: also draw a grid at major tick positions in both coordinates. 3: also draw a grid at minor tick positions in both coordinates. 10: same as 0 except logarithmic x tick marks. (The x data have to be converted to logarithms separately.) 11: same as 1 except logarithmic x tick marks. (The x data have to be converted to logarithms separately.) 12: same as 2 except logarithmic x tick marks. (The x data have to be converted to logarithms separately.) 13: same as 3 except logarithmic x tick marks. (The x data have to be converted to logarithms separately.) 20: same as 0 except logarithmic y tick marks. (The y data have to be converted to logarithms separately.) 21: same as 1 except logarithmic y tick marks. (The y data have to be converted to logarithms separately.) 22: same as 2 except logarithmic y tick marks. (The y data have to be converted to logarithms separately.) 23: same as 3 except logarithmic y tick marks. (The y data have to be converted to logarithms separately.) 30: same as 0 except logarithmic x and y tick marks. (The x and y data have to be converted to logarithms separately.) 31: same as 1 except logarithmic x and y tick marks. (The x and y data have to be converted to logarithms separately.) 32: same as 2 except logarithmic x and y tick marks. (The x and y data have to be converted to logarithms separately.) 33: same as 3 except logarithmic x and y tick marks. (The x and y data have to be converted to logarithms separately.) 40: same as 0 except date / time x labels. 41: same as 1 except date / time x labels. 42: same as 2 except date / time x labels. 43: same as 3 except date / time x labels. 50: same as 0 except date / time y labels. 51: same as 1 except date / time y labels. 52: same as 2 except date / time y labels. 53: same as 3 except date / time y labels. 60: same as 0 except date / time x and y labels. 61: same as 1 except date / time x and y labels. 62: same as 2 except date / time x and y labels. 63: same as 3 except date / time x and y labels. 70: same as 0 except custom x and y labels. 71: same as 1 except custom x and y labels. 72: same as 2 except custom x and y labels. 73: same as 3 except custom x and y labels.</param>
/// <param name="just">Controls how the axes will be scaled: -1: the scales will not be set, the user must set up the scale before calling plenv using plsvpa, plvasp or other. 0: the x and y axes are scaled independently to use as much of the screen as possible. 1: the scales of the x and y axes are made equal. 2: the axis of the x and y axes are made equal, and the plot box will be square.</param>
/// <param name="xmax">Value of x at right-hand edge of window (in world coordinates).</param>
/// <param name="xmin">Value of x at left-hand edge of window (in world coordinates).</param>
/// <param name="ymax">Value of y at top edge of window (in world coordinates).</param>
/// <param name="ymin">Value of y at bottom edge of window (in world coordinates).</param>
/// <remarks>Sets up plotter environment for simple graphs by calling pladv and setting up viewport and window to sensible default values. plenv leaves a standard margin (left-hand margin of eight character heights, and a margin around the other three sides of five character heights) around most graphs for axis labels and a title. When these defaults are not suitable, use the individual routines plvpas, plvpor, or plvasp for setting up the viewport, plwind for defining the window, and plbox for drawing the box.</remarks>
public void env(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, AxesScale just, AxisBox axis)
{
lock (libLock)
{
ActivateStream();
Native.env(xmin, xmax, ymin, ymax, just, axis);
}
}
/// <summary>plenv0: Same as plenv but if in multiplot mode does not advance the subpage, instead clears it</summary>
/// <param name="axis">Controls drawing of the box around the plot: -2: draw no box, no tick marks, no numeric tick labels, no axes. -1: draw box only. 0: draw box, ticks, and numeric tick labels. 1: also draw coordinate axes at x=0 and y=0. 2: also draw a grid at major tick positions in both coordinates. 3: also draw a grid at minor tick positions in both coordinates. 10: same as 0 except logarithmic x tick marks. (The x data have to be converted to logarithms separately.) 11: same as 1 except logarithmic x tick marks. (The x data have to be converted to logarithms separately.) 12: same as 2 except logarithmic x tick marks. (The x data have to be converted to logarithms separately.) 13: same as 3 except logarithmic x tick marks. (The x data have to be converted to logarithms separately.) 20: same as 0 except logarithmic y tick marks. (The y data have to be converted to logarithms separately.) 21: same as 1 except logarithmic y tick marks. (The y data have to be converted to logarithms separately.) 22: same as 2 except logarithmic y tick marks. (The y data have to be converted to logarithms separately.) 23: same as 3 except logarithmic y tick marks. (The y data have to be converted to logarithms separately.) 30: same as 0 except logarithmic x and y tick marks. (The x and y data have to be converted to logarithms separately.) 31: same as 1 except logarithmic x and y tick marks. (The x and y data have to be converted to logarithms separately.) 32: same as 2 except logarithmic x and y tick marks. (The x and y data have to be converted to logarithms separately.) 33: same as 3 except logarithmic x and y tick marks. (The x and y data have to be converted to logarithms separately.) 40: same as 0 except date / time x labels. 41: same as 1 except date / time x labels. 42: same as 2 except date / time x labels. 43: same as 3 except date / time x labels. 50: same as 0 except date / time y labels. 51: same as 1 except date / time y labels. 52: same as 2 except date / time y labels. 53: same as 3 except date / time y labels. 60: same as 0 except date / time x and y labels. 61: same as 1 except date / time x and y labels. 62: same as 2 except date / time x and y labels. 63: same as 3 except date / time x and y labels. 70: same as 0 except custom x and y labels. 71: same as 1 except custom x and y labels. 72: same as 2 except custom x and y labels. 73: same as 3 except custom x and y labels.</param>
/// <param name="just">Controls how the axes will be scaled: -1: the scales will not be set, the user must set up the scale before calling plenv0 using plsvpa, plvasp or other. 0: the x and y axes are scaled independently to use as much of the screen as possible. 1: the scales of the x and y axes are made equal. 2: the axis of the x and y axes are made equal, and the plot box will be square.</param>
/// <param name="xmax">Value of x at right-hand edge of window (in world coordinates).</param>
/// <param name="xmin">Value of x at left-hand edge of window (in world coordinates).</param>
/// <param name="ymax">Value of y at top edge of window (in world coordinates).</param>
/// <param name="ymin">Value of y at bottom edge of window (in world coordinates).</param>
/// <remarks>Sets up plotter environment for simple graphs by calling pladv and setting up viewport and window to sensible default values. plenv0 leaves a standard margin (left-hand margin of eight character heights, and a margin around the other three sides of five character heights) around most graphs for axis labels and a title. When these defaults are not suitable, use the individual routines plvpas, plvpor, or plvasp for setting up the viewport, plwind for defining the window, and plbox for drawing the box.</remarks>
public void env0(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, AxesScale just, AxisBox axis)
{
lock (libLock)
{
ActivateStream();
Native.env0(xmin, xmax, ymin, ymax, just, axis);
}
}
/// <summary>pleop: Eject current page</summary>
/// <remarks>Clears the graphics screen of an interactive device, or ejects a page on a plotter. See plbop for more information.</remarks>
public void eop()
{
lock (libLock)
{
ActivateStream();
Native.eop();
}
}
/// <summary>plerrx: Draw error bars in x direction</summary>
/// <param name="xmax">A vector containing the x coordinates of the right-hand endpoints of the error bars.</param>
/// <param name="xmin">A vector containing the x coordinates of the left-hand endpoints of the error bars.</param>
/// <param name="y">A vector containing the y coordinates of the error bars.</param>
/// <remarks>Draws a set of n error bars in x direction, the i'th error bar extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the error bars are of length equal to the minor tick length (settable using plsmin).</remarks>
public void errx(PLFLT[] xmin, PLFLT[] xmax, PLFLT[] y)
{
lock (libLock)
{
ActivateStream();
Native.errx(xmin, xmax, y);
}
}
/// <summary>plerry: Draw error bars in the y direction</summary>
/// <param name="x">A vector containing the x coordinates of the error bars.</param>
/// <param name="ymax">A vector containing the y coordinates of the upper endpoints of the error bars.</param>
/// <param name="ymin">A vector containing the y coordinates of the lower endpoints of the error bars.</param>
/// <remarks>Draws a set of n error bars in the y direction, the i'th error bar extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the error bars are of length equal to the minor tick length (settable using plsmin).</remarks>
public void erry(PLFLT[] x, PLFLT[] ymin, PLFLT[] ymax)
{
lock (libLock)
{
ActivateStream();
Native.erry(x, ymin, ymax);
}
}
/// <summary>plfamadv: Advance to the next family file on the next new page</summary>
/// <remarks>Advance to the next family file on the next new page.</remarks>
public void famadv()
{
lock (libLock)
{
ActivateStream();
Native.famadv();
}
}
/// <summary>plfill: Draw filled polygon</summary>
/// <param name="x">A vector containing the x coordinates of vertices.</param>
/// <param name="y">A vector containing the y coordinates of vertices.</param>
/// <remarks>Fills the polygon defined by the n points (x[i], y[i]) using the pattern defined by plpsty or plpat. The default fill style is a solid fill. The routine will automatically close the polygon between the last and first vertices. If multiple closed polygons are passed in x and y then plfill will fill in between them.</remarks>
public void fill(PLFLT[] x, PLFLT[] y)
{
lock (libLock)
{
ActivateStream();
Native.fill(x, y);
}
}
/// <summary>plfill3: Draw filled polygon in 3D</summary>
/// <param name="x">A vector containing the x coordinates of vertices.</param>
/// <param name="y">A vector containing the y coordinates of vertices.</param>
/// <param name="z">A vector containing the z coordinates of vertices.</param>
/// <remarks>Fills the 3D polygon defined by the n points in the x, y, and z vectors using the pattern defined by plpsty or plpat. The routine will automatically close the polygon between the last and first vertices. If multiple closed polygons are passed in x, y, and z then plfill3 will fill in between them.</remarks>
public void fill3(PLFLT[] x, PLFLT[] y, PLFLT[] z)
{
lock (libLock)
{
ActivateStream();
Native.fill3(x, y, z);
}
}
/// <summary>plflush: Flushes the output stream</summary>
/// <remarks>Flushes the output stream. Use sparingly, if at all.</remarks>
public void flush()
{
lock (libLock)
{
ActivateStream();
Native.flush();
}
}
/// <summary>plfont: Set font</summary>
/// <param name="ifont">Specifies the font: 1: Sans serif font (simplest and fastest) 2: Serif font 3: Italic font 4: Script font</param>
/// <remarks>Sets the font used for subsequent text and symbols. For devices that still use Hershey fonts this routine has no effect unless the Hershey fonts with extended character set are loaded (see plfontld). For unicode-aware devices that use system fonts instead of Hershey fonts, this routine calls the plsfci routine with argument set up appropriately for the various cases below. However, this method of specifying the font for unicode-aware devices is deprecated, and the much more flexible method of calling plsfont directly is recommended instead (where plsfont provides a user-friendly interface to plsfci),</remarks>
public void font(FontFlag ifont)
{
lock (libLock)
{
ActivateStream();
Native.font(ifont);
}
}
/// <summary>plfontld: Load Hershey fonts</summary>
/// <param name="fnt">Specifies the type of Hershey fonts to load. A zero value specifies Hershey fonts with the standard character set and a non-zero value (the default assumed if plfontld is never called) specifies Hershey fonts with the extended character set.</param>
/// <remarks>Loads the Hershey fonts used for text and symbols. This routine may be called before or after initializing PLplot. If not explicitly called before PLplot initialization, then by default that initialization loads Hershey fonts with the extended character set. This routine only has a practical effect for devices that still use Hershey fonts (as opposed to modern devices that use unicode-aware system fonts instead of Hershey fonts).</remarks>
public void fontld(PLINT fnt)
{
lock (libLock)
{
ActivateStream();
Native.fontld(fnt);
}
}
/// <summary>plgchr: Get character default height and current (scaled) height</summary>
/// <param name="p_def">Returned value of the default character height (mm).</param>
/// <param name="p_ht">Returned value of the scaled character height (mm).</param>
/// <remarks>Get character default height and current (scaled) height.</remarks>
public void gchr(out PLFLT p_def, out PLFLT p_ht)
{
lock (libLock)
{
ActivateStream();
Native.gchr(out p_def, out p_ht);
}
}
/// <summary>plgcol0: Returns 8-bit RGB values for given color index from cmap0</summary>
/// <param name="b">Returned value of the 8-bit blue value.</param>
/// <param name="g">Returned value of the 8-bit green value.</param>
/// <param name="icol0">Index of desired cmap0 color.</param>
/// <param name="r">Returned value of the 8-bit red value.</param>
/// <remarks>Returns 8-bit RGB values (0-255) for given color from cmap0 (see ). Values are negative if an invalid color id is given.</remarks>
public void gcol0(PLINT icol0, out PLINT r, out PLINT g, out PLINT b)
{
lock (libLock)
{
ActivateStream();
Native.gcol0(icol0, out r, out g, out b);
}
}
/// <summary>plgcol0a: Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0</summary>
/// <param name="alpha">Returned value of the alpha transparency in the range from (0.0-1.0).</param>
/// <param name="b">Returned value of the blue intensity in the range from 0 to 255.</param>
/// <param name="g">Returned value of the green intensity in the range from 0 to 255.</param>
/// <param name="icol0">Index of desired cmap0 color.</param>
/// <param name="r">Returned value of the red intensity in the range from 0 to 255.</param>
/// <remarks>Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value (0.0-1.0) for given color from cmap0 (see ). Values are negative if an invalid color id is given.</remarks>
public void gcol0a(PLINT icol0, out PLINT r, out PLINT g, out PLINT b, out PLFLT alpha)
{
lock (libLock)
{
ActivateStream();
Native.gcol0a(icol0, out r, out g, out b, out alpha);
}
}
/// <summary>plgcolbg: Returns the background color (cmap0[0]) by 8-bit RGB value</summary>
/// <param name="b">Returned value of the blue intensity in the range from 0 to 255.</param>
/// <param name="g">Returned value of the green intensity in the range from 0 to 255.</param>
/// <param name="r">Returned value of the red intensity in the range from 0 to 255.</param>
/// <remarks>Returns the background color (cmap0[0]) by 8-bit RGB value.</remarks>
public void gcolbg(out PLINT r, out PLINT g, out PLINT b)
{
lock (libLock)
{
ActivateStream();
Native.gcolbg(out r, out g, out b);
}
}
/// <summary>plgcolbga: Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value</summary>
/// <param name="alpha">Returned value of the alpha transparency in the range (0.0-1.0).</param>
/// <param name="b">Returned value of the blue intensity in the range from 0 to 255.</param>
/// <param name="g">Returned value of the green intensity in the range from 0 to 255.</param>
/// <param name="r">Returned value of the red intensity in the range from 0 to 255.</param>
/// <remarks>Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value.</remarks>
public void gcolbga(out PLINT r, out PLINT g, out PLINT b, out PLFLT alpha)
{
lock (libLock)
{
ActivateStream();
Native.gcolbga(out r, out g, out b, out alpha);
}
}
/// <summary>plgcompression: Get the current device-compression setting</summary>
/// <param name="compression">Returned value of the compression setting for the current device.</param>
/// <remarks>Get the current device-compression setting. This parameter is only used for drivers that provide compression.</remarks>
public void gcompression(out PLINT compression)
{
lock (libLock)
{
ActivateStream();
Native.gcompression(out compression);
}
}
/// <summary>plgdev: Get the current device (keyword) name</summary>
/// <param name="p_dev">Returned ascii character string (with preallocated length of 80 characters or more) containing the device (keyword) name.</param>
/// <remarks>Get the current device (keyword) name. Note: you must have allocated space for this (80 characters is safe).</remarks>
public void gdev(out string p_dev)
{
lock (libLock)
{
ActivateStream();
Native.gdev(out p_dev);
}
}
/// <summary>plgdidev: Get parameters that define current device-space window</summary>
/// <param name="p_aspect">Returned value of the aspect ratio.</param>
/// <param name="p_jx">Returned value of the relative justification in x.</param>
/// <param name="p_jy">Returned value of the relative justification in y.</param>
/// <param name="p_mar">Returned value of the relative margin width.</param>
/// <remarks>Get relative margin width, aspect ratio, and relative justification that define current device-space window. If plsdidev has not been called the default values pointed to by p_mar, p_aspect, p_jx, and p_jy will all be 0.</remarks>
public void gdidev(out PLFLT p_mar, out PLFLT p_aspect, out PLFLT p_jx, out PLFLT p_jy)
{
lock (libLock)
{
ActivateStream();
Native.gdidev(out p_mar, out p_aspect, out p_jx, out p_jy);
}
}
/// <summary>plgdiori: Get plot orientation</summary>
/// <param name="p_rot">Returned value of the orientation parameter.</param>
/// <remarks>Get plot orientation parameter which is multiplied by 90deg to obtain the angle of rotation. Note, arbitrary rotation parameters such as 0.2 (corresponding to 18deg) are possible, but the usual values for the rotation parameter are 0., 1., 2., and 3. corresponding to 0deg (landscape mode), 90deg (portrait mode), 180deg (seascape mode), and 270deg (upside-down mode). If plsdiori has not been called the default value pointed to by p_rot will be 0.</remarks>
public void gdiori(out PLFLT p_rot)
{
lock (libLock)
{
ActivateStream();
Native.gdiori(out p_rot);
}
}
/// <summary>plgdiplt: Get parameters that define current plot-space window</summary>
/// <param name="p_xmax">Returned value of the relative maximum in x.</param>
/// <param name="p_xmin">Returned value of the relative minimum in x.</param>
/// <param name="p_ymax">Returned value of the relative maximum in y.</param>
/// <param name="p_ymin">Returned value of the relative minimum in y.</param>
/// <remarks>Get relative minima and maxima that define current plot-space window. If plsdiplt has not been called the default values pointed to by p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.</remarks>
public void gdiplt(out PLFLT p_xmin, out PLFLT p_ymin, out PLFLT p_xmax, out PLFLT p_ymax)
{
lock (libLock)
{
ActivateStream();
Native.gdiplt(out p_xmin, out p_ymin, out p_xmax, out p_ymax);
}
}
/// <summary>plgdrawmode: Get drawing mode (depends on device support!)</summary>
/// <remarks>Get drawing mode. Note only one device driver (cairo) currently supports this at the moment, and for that case the PLINT value returned by this function is one of PL_DRAWMODE_DEFAULT, PL_DRAWMODE_REPLACE, PL_DRAWMODE_XOR, or PL_DRAWMODE_UNKNOWN. This function returns PL_DRAWMODE_UNKNOWN for the rest of the device drivers. See also plsdrawmode.</remarks>
public DrawMode gdrawmode()
{
lock (libLock)
{
ActivateStream();
return Native.gdrawmode();
}
}
/// <summary>plgfci: Get FCI (font characterization integer)</summary>
/// <param name="p_fci">Returned value of the current FCI value.</param>
/// <remarks>Gets information about the current font using the FCI approach. See for more information.</remarks>
public void gfci(out FCI p_fci)
{
lock (libLock)
{
ActivateStream();
Native.gfci(out p_fci);
}
}
/// <summary>plgfam: Get family file parameters</summary>
/// <param name="p_bmax">Returned value of the maximum file size (in bytes) for a family file.</param>
/// <param name="p_fam">Returned value of the current family flag value. If nonzero, familying is enabled for the current device.</param>
/// <param name="p_num">Returned value of the current family file number.</param>
/// <remarks>Gets information about current family file, if familying is enabled. See for more information.</remarks>
public void gfam(out PLINT p_fam, out PLINT p_num, out PLINT p_bmax)
{
lock (libLock)
{
ActivateStream();
Native.gfam(out p_fam, out p_num, out p_bmax);
}
}
/// <summary>plgfnam: Get output file name</summary>
/// <param name="fnam">Returned ascii character string (with preallocated length of 80 characters or more) containing the file name.</param>
/// <remarks>Gets the current output file name, if applicable.</remarks>
public void gfnam(out string fnam)
{
lock (libLock)
{
ActivateStream();
Native.gfnam(out fnam);
}
}
/// <summary>plgfont: Get family, style and weight of the current font</summary>
/// <param name="p_family">Returned value of the current font family. The available values are given by the PL_FCI_* constants in plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If p_family is NULL then the font family is not returned.</param>
/// <param name="p_style">Returned value of the current font style. The available values are given by the PL_FCI_* constants in plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font style is not returned.</param>
/// <param name="p_weight">Returned value of the current font weight. The available values are given by the PL_FCI_* constants in plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. If p_weight is NULL then the font weight is not returned.</param>
/// <remarks>Gets information about current font. See for more information on font selection.</remarks>
public void gfont(out FontFamily p_family, out FontStyle p_style, out FontWeight p_weight)
{
lock (libLock)
{
ActivateStream();
Native.gfont(out p_family, out p_style, out p_weight);
}
}
/// <summary>plglevel: Get the (current) run level</summary>
/// <param name="p_level">Returned value of the run level.</param>
/// <remarks>Get the (current) run level. Valid settings are: 0, uninitialized 1, initialized 2, viewport defined 3, world coordinates defined</remarks>
public void glevel(out RunLevel p_level)
{
lock (libLock)
{
ActivateStream();
Native.glevel(out p_level);
}
}
/// <summary>plgpage: Get page parameters</summary>
/// <param name="p_xleng">Returned value of the x page length.</param>
/// <param name="p_xoff">Returned value of the x page offset.</param>
/// <param name="p_xp">Returned value of the number of pixels/inch (DPI) in x.</param>
/// <param name="p_yleng">Returned value of the y page length.</param>
/// <param name="p_yoff">Returned value of the y page offset.</param>
/// <param name="p_yp">Returned value of the number of pixels/inch (DPI) in y.</param>
/// <remarks>Gets the current page configuration. The length and offset values are expressed in units that are specific to the current driver. For instance: screen drivers will usually interpret them as number of pixels, whereas printer drivers will usually use mm.</remarks>
public void gpage(out PLFLT p_xp, out PLFLT p_yp, out PLINT p_xleng, out PLINT p_yleng, out PLINT p_xoff, out PLINT p_yoff)
{
lock (libLock)
{
ActivateStream();
Native.gpage(out p_xp, out p_yp, out p_xleng, out p_yleng, out p_xoff, out p_yoff);
}
}
/// <summary>plgra: Switch to graphics screen</summary>
/// <remarks>Sets an interactive device to graphics mode, used in conjunction with pltext to allow graphics and text to be interspersed. On a device which supports separate text and graphics windows, this command causes control to be switched to the graphics window. If already in graphics mode, this command is ignored. It is also ignored on devices which only support a single window or use a different method for shifting focus. See also pltext.</remarks>
public void gra()
{
lock (libLock)
{
ActivateStream();
Native.gra();
}
}
/// <summary>plgradient: Draw linear gradient inside polygon</summary>
/// <param name="angle">Angle (degrees) of gradient vector from x axis.</param>
/// <param name="x">A vector containing the x coordinates of vertices.</param>
/// <param name="y">A vector containing the y coordinates of vertices.</param>
/// <remarks>Draw a linear gradient using cmap1 inside the polygon defined by the n points (x[i], y[i]). Interpretation of the polygon is the same as for plfill. The polygon coordinates and the gradient angle are all expressed in world coordinates. The angle from the x axis for both the rotated coordinate system and the gradient vector is specified by angle. The magnitude of the gradient vector is the difference between the maximum and minimum values of x for the vertices in the rotated coordinate system. The origin of the gradient vector can be interpreted as being anywhere on the line corresponding to the minimum x value for the vertices in the rotated coordinate system. The distance along the gradient vector is linearly transformed to the independent variable of color map 1 which ranges from 0. at the tail of the gradient vector to 1. at the head of the gradient vector. What is drawn is the RGBA color corresponding to the independent variable of cmap1. For more information about cmap1 (see ).</remarks>
public void gradient(PLFLT[] x, PLFLT[] y, PLFLT angle)
{
lock (libLock)
{
ActivateStream();
Native.gradient(x, y, angle);
}
}
/// <summary>plgriddata: Grid data from irregularly sampled data</summary>
/// <param name="data">Some gridding algorithms require extra data, which can be specified through this argument. Currently, for algorithm: GRID_NNIDW, data specifies the number of neighbors to use, the lower the value, the noisier (more local) the approximation is. GRID_NNLI, data specifies what a thin triangle is, in the range [1. .. 2.]. High values enable the usage of very thin triangles for interpolation, possibly resulting in error in the approximation. GRID_NNI, only weights greater than data will be accepted. If 0, all weights will be accepted.</param>
/// <param name="type">The type of grid interpolation algorithm to use, which can be: GRID_CSA: Bivariate Cubic Spline approximation GRID_DTLI: Delaunay Triangulation Linear Interpolation GRID_NNI: Natural Neighbors Interpolation GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted GRID_NNLI: Nearest Neighbors Linear Interpolation GRID_NNAIDW: Nearest Neighbors Around Inverse Distance Weighted For details of the algorithms read the source file plgridd.c.</param>
/// <param name="x">The input x vector.</param>
/// <param name="xg">A vector that specifies the grid spacing in the x direction. Usually xg has nptsx equally spaced values from the minimum to the maximum values of the x input vector.</param>
/// <param name="y">The input y vector.</param>
/// <param name="yg">A vector that specifies the grid spacing in the y direction. Similar to the xg parameter.</param>
/// <param name="z">The input z vector. Each triple x[i], y[i], z[i] represents one data sample coordinate.</param>
/// <param name="zg">The matrix of interpolated results where data lies in the grid specified by xg and yg. Therefore the zg matrix must be dimensioned nptsx by nptsy.</param>
/// <remarks>Real world data is frequently irregularly sampled, but PLplot 3D plots require data organized as a grid, i.e., with x sample point values independent of y coordinate and vice versa. This function takes irregularly sampled data from the x[npts], y[npts], and z[npts] vectors; reads the desired grid location from the input vectors xg[nptsx] and yg[nptsy]; and returns the interpolated result on that grid using the output matrix zg[nptsx][nptsy]. The algorithm used to interpolate the data to the grid is specified with the argument type which can have one parameter specified in argument data.</remarks>
public void griddata(PLFLT[] x, PLFLT[] y, PLFLT[] z, PLFLT[] xg, PLFLT[] yg, PLFLT[,] zg, Grid type, PLFLT data)
{
lock (libLock)
{
ActivateStream();
Native.griddata(x, y, z, xg, yg, zg, type, data);
}
}
/// <summary>plgspa: Get current subpage parameters</summary>
/// <param name="xmax">Returned value of the position of the right hand edge of the subpage in millimeters.</param>
/// <param name="xmin">Returned value of the position of the left hand edge of the subpage in millimeters.</param>
/// <param name="ymax">Returned value of the position of the top edge of the subpage in millimeters.</param>
/// <param name="ymin">Returned value of the position of the bottom edge of the subpage in millimeters.</param>
/// <remarks>Gets the size of the current subpage in millimeters measured from the bottom left hand corner of the output device page or screen. Can be used in conjunction with plsvpa for setting the size of a viewport in absolute coordinates (millimeters).</remarks>
public void gspa(out PLFLT xmin, out PLFLT xmax, out PLFLT ymin, out PLFLT ymax)
{
lock (libLock)
{
ActivateStream();
Native.gspa(out xmin, out xmax, out ymin, out ymax);
}
}
/// <summary>plgstrm: Get current stream number</summary>
/// <param name="p_strm">Returned value of the current stream value.</param>
/// <remarks>Gets the number of the current output stream. See also plsstrm.</remarks>
public void gstrm(out PLINT p_strm)
{
lock (libLock)
{
ActivateStream();
Native.gstrm(out p_strm);
}
}
/// <summary>plgver: Get the current library version number</summary>
/// <param name="p_ver">Returned ascii character string (with preallocated length of 80 characters or more) containing the PLplot version number.</param>
/// <remarks>Get the current library version number. Note: you must have allocated space for this (80 characters is safe).</remarks>
public void gver(out string p_ver)
{
lock (libLock)
{
ActivateStream();
Native.gver(out p_ver);
}
}
/// <summary>plgvpd: Get viewport limits in normalized device coordinates</summary>
/// <param name="p_xmax">Returned value of the upper viewport limit of the normalized device coordinate in x.</param>
/// <param name="p_xmin">Returned value of the lower viewport limit of the normalized device coordinate in x.</param>
/// <param name="p_ymax">Returned value of the upper viewport limit of the normalized device coordinate in y.</param>
/// <param name="p_ymin">Returned value of the lower viewport limit of the normalized device coordinate in y.</param>
/// <remarks>Get viewport limits in normalized device coordinates.</remarks>
public void gvpd(out PLFLT p_xmin, out PLFLT p_xmax, out PLFLT p_ymin, out PLFLT p_ymax)
{
lock (libLock)
{
ActivateStream();
Native.gvpd(out p_xmin, out p_xmax, out p_ymin, out p_ymax);
}
}
/// <summary>plgvpw: Get viewport limits in world coordinates</summary>
/// <param name="p_xmax">Returned value of the upper viewport limit of the world coordinate in x.</param>
/// <param name="p_xmin">Returned value of the lower viewport limit of the world coordinate in x.</param>
/// <param name="p_ymax">Returned value of the upper viewport limit of the world coordinate in y.</param>
/// <param name="p_ymin">Returned value of the lower viewport limit of the world coordinate in y.</param>
/// <remarks>Get viewport limits in world coordinates.</remarks>
public void gvpw(out PLFLT p_xmin, out PLFLT p_xmax, out PLFLT p_ymin, out PLFLT p_ymax)
{
lock (libLock)
{
ActivateStream();
Native.gvpw(out p_xmin, out p_xmax, out p_ymin, out p_ymax);
}
}
/// <summary>plgxax: Get x axis parameters</summary>
/// <param name="p_digits">Returned value of the actual number of digits for the numeric labels (x axis) from the last plot.</param>
/// <param name="p_digmax">Returned value of the maximum number of digits for the x axis. If nonzero, the printed label has been switched to a floating-point representation when the number of digits exceeds this value.</param>
/// <remarks>Returns current values of the p_digmax and p_digits flags for the x axis. p_digits is updated after the plot is drawn, so this routine should only be called after the call to plbox (or plbox3) is complete. See for more information.</remarks>
public void gxax(out PLINT p_digmax, out PLINT p_digits)
{
lock (libLock)
{
ActivateStream();
Native.gxax(out p_digmax, out p_digits);
}
}
/// <summary>plgyax: Get y axis parameters</summary>
/// <param name="p_digits">Returned value of the actual number of digits for the numeric labels (y axis) from the last plot.</param>
/// <param name="p_digmax">Returned value of the maximum number of digits for the y axis. If nonzero, the printed label has been switched to a floating-point representation when the number of digits exceeds this value.</param>
/// <remarks>Identical to plgxax, except that arguments are flags for y axis. See the description of plgxax for more detail.</remarks>
public void gyax(out PLINT p_digmax, out PLINT p_digits)
{
lock (libLock)
{
ActivateStream();
Native.gyax(out p_digmax, out p_digits);
}
}
/// <summary>plgzax: Get z axis parameters</summary>
/// <param name="p_digits">Returned value of the actual number of digits for the numeric labels (z axis) from the last plot.</param>
/// <param name="p_digmax">Returned value of the maximum number of digits for the z axis. If nonzero, the printed label has been switched to a floating-point representation when the number of digits exceeds this value.</param>
/// <remarks>Identical to plgxax, except that arguments are flags for z axis. See the description of plgxax for more detail.</remarks>
public void gzax(out PLINT p_digmax, out PLINT p_digits)
{
lock (libLock)
{
ActivateStream();
Native.gzax(out p_digmax, out p_digits);
}
}
/// <summary>plhist: Plot a histogram from unbinned data</summary>
/// <param name="data">A vector containing the values of the n data points.</param>
/// <param name="datmax">Right-hand edge of highest-valued bin.</param>
/// <param name="datmin">Left-hand edge of lowest-valued bin.</param>
/// <param name="nbin">Number of (equal-sized) bins into which to divide the interval xmin to xmax.</param>
/// <param name="opt">Is a combination of several flags: opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit the histogram data, the outer bins are expanded to fill up the entire x-axis, data outside the given extremes are assigned to the outer bins and bins of zero height are simply drawn. opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled to fit the histogram data, without this flag, plenv is called to set the world coordinates. opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given extremes are not taken into account. This option should probably be combined with opt=PL_HIST_NOEXPAND|..., so as to properly present the data. opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal size as the ones inside. opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn (there is a gap for such bins).</param>
/// <remarks>Plots a histogram from n data points stored in the data vector. This routine bins the data into nbin bins equally spaced between datmin and datmax, and calls plbin to draw the resulting histogram. Parameter opt allows, among other things, the histogram either to be plotted in an existing window or causes plhist to call plenv with suitable limits before plotting the histogram.</remarks>
public void hist(PLFLT[] data, PLFLT datmin, PLFLT datmax, PLINT nbin, Hist opt)
{
lock (libLock)
{
ActivateStream();
Native.hist(data, datmin, datmax, nbin, opt);
}
}
/// <summary>plhlsrgb: Convert HLS color to RGB</summary>
/// <param name="h">Hue in degrees (0.0-360.0) on the color cylinder.</param>
/// <param name="l">Lightness expressed as a fraction (0.0-1.0) of the axis of the color cylinder.</param>
/// <param name="p_b">Returned value of the blue intensity (0.0-1.0) of the color.</param>
/// <param name="p_g">Returned value of the green intensity (0.0-1.0) of the color.</param>
/// <param name="p_r">Returned value of the red intensity (0.0-1.0) of the color.</param>
/// <param name="s">Saturation expressed as a fraction (0.0-1.0) of the radius of the color cylinder.</param>
/// <remarks>Convert HLS color coordinates to RGB.</remarks>
public void hlsrgb(PLFLT h, PLFLT l, PLFLT s, out PLFLT p_r, out PLFLT p_g, out PLFLT p_b)
{
lock (libLock)
{
ActivateStream();
Native.hlsrgb(h, l, s, out p_r, out p_g, out p_b);
}
}
/// <summary>plinit: Initialize PLplot</summary>
/// <remarks>Initializing the plotting package. The program prompts for the device keyword or number of the desired output device. Hitting a RETURN in response to the prompt is the same as selecting the first device. plinit will issue no prompt if either the device was specified previously (via command line flag, the plsetopt function, or the plsdev function), or if only one device is enabled when PLplot is installed. If subpages have been specified, the output device is divided into nx by ny subpages, each of which may be used independently. If plinit is called again during a program, the previously opened file will be closed. The subroutine pladv is used to advance from one subpage to the next.</remarks>
public void init()
{
lock (libLock)
{
ActivateStream();
Native.init();
}
}
/// <summary>pljoin: Draw a line between two points</summary>
/// <param name="x1">x coordinate of first point.</param>
/// <param name="x2">x coordinate of second point.</param>
/// <param name="y1">y coordinate of first point.</param>
/// <param name="y2">y coordinate of second point.</param>
/// <remarks>Joins the point (x1, y1) to (x2, y2).</remarks>
public void join(PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2)
{
lock (libLock)
{
ActivateStream();
Native.join(x1, y1, x2, y2);
}
}
/// <summary>pllab: Simple routine to write labels</summary>
/// <param name="tlabel">A UTF-8 character string specifying the title of the plot.</param>
/// <param name="xlabel">A UTF-8 character string specifying the label for the x axis.</param>
/// <param name="ylabel">A UTF-8 character string specifying the label for the y axis.</param>
/// <remarks>Routine for writing simple labels. Use plmtex for more complex labels.</remarks>
public void lab(string xlabel, string ylabel, string tlabel)
{
lock (libLock)
{
ActivateStream();
Native.lab(xlabel, ylabel, tlabel);
}
}
/// <summary>pllegend: Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols</summary>
/// <param name="bb_color">The cmap0 color of the bounding-box line for the legend (PL_LEGEND_BOUNDING_BOX).</param>
/// <param name="bb_style">The pllsty style number for the bounding-box line for the legend (PL_LEGEND_BACKGROUND).</param>
/// <param name="bg_color">The cmap0 color of the background for the legend (PL_LEGEND_BACKGROUND).</param>
/// <param name="box_colors">A vector containing nlegend cmap0 colors for the discrete colored boxes (PL_LEGEND_COLOR_BOX).</param>
/// <param name="box_line_widths">A vector containing nlegend line widths for the patterns specified by box_patterns (PL_LEGEND_COLOR_BOX).</param>
/// <param name="box_patterns">A vector containing nlegend patterns (plpsty indices) for the discrete colored boxes (PL_LEGEND_COLOR_BOX).</param>
/// <param name="box_scales">A vector containing nlegend scales (units of fraction of character height) for the height of the discrete colored boxes (PL_LEGEND_COLOR_BOX).</param>
/// <param name="line_colors">A vector containing nlegend cmap0 line colors (PL_LEGEND_LINE).</param>
/// <param name="line_styles">A vector containing nlegend line styles (plsty indices) (PL_LEGEND_LINE).</param>
/// <param name="line_widths">A vector containing nlegend line widths (PL_LEGEND_LINE).</param>
/// <param name="ncolumn">The cmap0 index of the background color for the legend (PL_LEGEND_BACKGROUND).</param>
/// <param name="nrow">The cmap0 index of the background color for the legend (PL_LEGEND_BACKGROUND).</param>
/// <param name="opt">opt contains bits controlling the overall legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area on the left of the legend and the plotted area on the right. Otherwise, put the text area on the right of the legend and the plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set, plot a (semitransparent) background for the legend. If the PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the possibly internally transformed) nrow gt 1 and ncolumn gt 1, then plot the resulting array of legend entries in row-major order. Otherwise, plot the legend entries in column-major order.</param>
/// <param name="opt_array">A vector of nlegend values of options to control each individual plotted area corresponding to a legend entry. If the PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted area. If the PL_LEGEND_COLOR_BOX, PL_LEGEND_LINE, and/or PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend entry is plotted with a colored box; a line; and/or a line of symbols.</param>
/// <param name="p_legend_height">Returned value of the legend height in adopted coordinates. This quantity is calculated from text_scale, text_spacing, and nrow (possibly modified inside the routine depending on nlegend and nrow).</param>
/// <param name="p_legend_width">Returned value of the legend width in adopted coordinates. This quantity is calculated from plot_width, text_offset, ncolumn (possibly modified inside the routine depending on nlegend and nrow), and the length (calculated internally) of the longest text string.</param>
/// <param name="plot_width">Horizontal width in adopted coordinates of the plot area (where the colored boxes, lines, and/or lines of symbols are drawn) of the legend.</param>
/// <param name="position">position contains bits which control the overall position of the legend and the definition of the adopted coordinates used for positions just like what is done for the position argument for plcolorbar. However, note that the defaults for the position bits (see below) are different than the plcolorbar case. The combination of the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM, PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of the 16 possible standard positions (the 4 corners and centers of the 4 sides for both the inside and outside cases) of the legend relative to the adopted coordinate system. The corner positions are specified by the appropriate combination of two of the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and PL_POSITION_BOTTOM bits while the sides are specified by a single value of one of those bits. The adopted coordinates are normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is set or normalized subpage coordinates if the PL_POSITION_SUBPAGE bit is set. Default position bits: If none of PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set, then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP. If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set, use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.</param>
/// <param name="symbol_colors">A vector containing nlegend cmap0 symbol colors (PL_LEGEND_SYMBOL).</param>
/// <param name="symbol_numbers">A vector containing nlegend numbers of symbols to be drawn across the width of the plotted area (PL_LEGEND_SYMBOL).</param>
/// <param name="symbol_scales">A vector containing nlegend scale values for the symbol height (PL_LEGEND_SYMBOL).</param>
/// <param name="symbols">A vector of nlegend UTF-8 character strings containing the legend symbols. (PL_LEGEND_SYMBOL).</param>
/// <param name="text">A vector of nlegend UTF-8 character strings containing the legend annotations.</param>
/// <param name="text_colors">A vector containing nlegend cmap0 text colors.</param>
/// <param name="text_justification">Justification parameter used for text justification. The most common values of text_justification are 0., 0.5, or 1. corresponding to a text that is left justified, centred, or right justified within the text area, but other values are allowed as well.</param>
/// <param name="text_offset">Offset of the text area from the plot area in units of character width. N.B. The total horizontal width of the legend in adopted coordinates is calculated internally from plot_width (see above), text_offset, and length (calculated internally) of the longest text string.</param>
/// <param name="text_scale">Character height scale for text annotations. N.B. The total vertical height of the legend in adopted coordinates is calculated internally from nlegend (see above), text_scale, and text_spacing (see below).</param>
/// <param name="text_spacing">Vertical spacing in units of the character height from one legend entry to the next. N.B. The total vertical height of the legend in adopted coordinates is calculated internally from nlegend (see above), text_scale (see above), and text_spacing.</param>
/// <param name="x">X offset of the legend position in adopted coordinates from the specified standard position of the legend. For positive x, the direction of motion away from the standard position is inward/outward from the standard corner positions or standard left or right positions if the PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For the standard top or bottom positions, the direction of motion is toward positive X.</param>
/// <param name="y">Y offset of the legend position in adopted coordinates from the specified standard position of the legend. For positive y, the direction of motion away from the standard position is inward/outward from the standard corner positions or standard top or bottom positions if the PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For the standard left or right positions, the direction of motion is toward positive Y.</param>
/// <remarks>Routine for creating a discrete plot legend with a plotted filled box, line, and/or line of symbols for each annotated legend entry. (See plcolorbar for similar functionality for creating continuous color bars.) The arguments of pllegend provide control over the location and size of the legend as well as the location and characteristics of the elements (most of which are optional) within that legend. The resulting legend is clipped at the boundaries of the current subpage. (N.B. the adopted coordinate system used for some of the parameters is defined in the documentation of the position parameter.)</remarks>
public void legend(
out PLFLT p_legend_width, out PLFLT p_legend_height, Legend opt, Position position, PLFLT x, PLFLT y, PLFLT plot_width, PLINT bg_color, PLINT bb_color, LineStyle bb_style, PLINT nrow, PLINT ncolumn, LegendEntry[] opt_array, PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing, PLFLT text_justification, PLINT[] text_colors, PLUTF8_STRING[] text, PLINT[] box_colors, Pattern[] box_patterns, PLFLT[] box_scales, PLFLT[] box_line_widths, PLINT[] line_colors, LineStyle[] line_styles, PLFLT[] line_widths, PLINT[] symbol_colors, PLFLT[] symbol_scales, PLINT[] symbol_numbers, PLUTF8_STRING[] symbols)
{
lock (libLock)
{
ActivateStream();
Native.legend(out p_legend_width, out p_legend_height, opt, position, x, y, plot_width, bg_color, bb_color, bb_style, nrow, ncolumn, opt_array, text_offset, text_scale, text_spacing, text_justification, text_colors, text, box_colors, box_patterns, box_scales, box_line_widths, line_colors, line_styles, line_widths, symbol_colors, symbol_scales, symbol_numbers, symbols);
}
}
/// <summary>plcolorbar: Plot color bar for image, shade or gradient plots</summary>
/// <param name="axis_opts">A vector of n_axes ascii character strings containing options (interpreted as for plbox) for the color bar's axis definitions.</param>
/// <param name="bb_color">The cmap0 color of the bounding-box line for the color bar (PL_COLORBAR_BOUNDING_BOX).</param>
/// <param name="bb_style">The pllsty style number for the bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).</param>
/// <param name="bg_color">The cmap0 color of the background for the color bar (PL_COLORBAR_BACKGROUND).</param>
/// <param name="cont_color">The cmap0 contour color for PL_COLORBAR_SHADE plots. This is passed directly to plshades, so it will be interpreted according to the design of plshades.</param>
/// <param name="cont_width">Contour width for PL_COLORBAR_SHADE plots. This is passed directly to plshades, so it will be interpreted according to the design of plshades.</param>
/// <param name="high_cap_color">The cmap1 color of the high-end color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).</param>
/// <param name="label_opts">A vector of options for each of n_labels labels.</param>
/// <param name="labels">A vector of n_labels UTF-8 character strings containing the labels for the color bar. Ignored if no label position is specified with one of the PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP, PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the corresponding label_opts field.</param>
/// <param name="low_cap_color">The cmap1 color of the low-end color bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).</param>
/// <param name="opt">opt contains bits controlling the overall color bar. The orientation (direction of the maximum value) of the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP, PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are specified, the default orientation is toward the top if the colorbar is placed on the left or right of the viewport or toward the right if the colorbar is placed on the top or bottom of the viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a (semitransparent) background for the color bar. If the PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the color bar. The type of color bar must be specified with one of PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If more than one of those bits is set only the first one in the above list is honored. The position of the (optional) label/title can be specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or PL_LABEL_BOTTOM. If no label position bit is set then no label will be drawn. If more than one of this list of bits is specified, only the first one on the list is honored. End-caps for the color bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH. If a particular color bar cap option is not specified then no cap will be drawn for that end. As a special case for PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be specified. If this option is provided then any tick marks and tick labels will be placed at the breaks between shaded segments. TODO: This should be expanded to support custom placement of tick marks and tick labels at custom value locations for any color bar type.</param>
/// <param name="p_colorbar_height">Returned value of the labelled and decorated color bar height in adopted coordinates.</param>
/// <param name="p_colorbar_width">Returned value of the labelled and decorated color bar width in adopted coordinates.</param>
/// <param name="position">position contains bits which control the overall position of the color bar and the definition of the adopted coordinates used for positions just like what is done for the position argument for pllegend. However, note that the defaults for the position bits (see below) are different than the pllegend case. The combination of the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM, PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of the 16 possible standard positions (the 4 corners and centers of the 4 sides for both the inside and outside cases) of the color bar relative to the adopted coordinate system. The corner positions are specified by the appropriate combination of two of the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and PL_POSITION_BOTTOM bits while the sides are specified by a single value of one of those bits. The adopted coordinates are normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is set or normalized subpage coordinates if the PL_POSITION_SUBPAGE bit is set. Default position bits: If none of PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set, then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.</param>
/// <param name="sub_ticks">A vector of n_axes values of the number of subticks (interpreted as for plbox) for the color bar's axis definitions.</param>
/// <param name="ticks">A vector of n_axes values of the spacing of the major tick marks (interpreted as for plbox) for the color bar's axis definitions.</param>
/// <param name="values">A matrix containing the numeric values for the data range represented by the color bar. For a row index of i_axis (where 0 lt i_axis lt n_axes), the number of elements in the row is specified by n_values[i_axis]. For PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements is 2, and the corresponding row elements of the values matrix are the minimum and maximum value represented by the colorbar. For PL_COLORBAR_SHADE, the number and values of the elements of a row of the values matrix is interpreted the same as the nlevel and clevel arguments of plshades.</param>
/// <param name="x">X offset of the color bar position in adopted coordinates from the specified standard position of the color bar. For positive x, the direction of motion away from the standard position is inward/outward from the standard corner positions or standard left or right positions if the PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For the standard top or bottom positions, the direction of motion is toward positive X.</param>
/// <param name="x_length">Length of the body of the color bar in the X direction in adopted coordinates.</param>
/// <param name="y">Y offset of the color bar position in adopted coordinates from the specified standard position of the color bar. For positive y, the direction of motion away from the standard position is inward/outward from the standard corner positions or standard top or bottom positions if the PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For the standard left or right positions, the direction of motion is toward positive Y.</param>
/// <param name="y_length">Length of the body of the color bar in the Y direction in adopted coordinates.</param>
/// <remarks>Routine for creating a continuous color bar for image, shade, or gradient plots. (See pllegend for similar functionality for creating legends with discrete elements). The arguments of plcolorbar provide control over the location and size of the color bar as well as the location and characteristics of the elements (most of which are optional) within that color bar. The resulting color bar is clipped at the boundaries of the current subpage. (N.B. the adopted coordinate system used for some of the parameters is defined in the documentation of the position parameter.)</remarks>
public void colorbar(
out PLFLT p_colorbar_width, out PLFLT p_colorbar_height, Colorbar opt, Position position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, ColorbarLabel[] label_opts, PLUTF8_STRING[] labels, PLCHAR_STRING[] axis_opts, PLFLT[] ticks, PLINT[] sub_ticks, PLFLT[,] values)
{
lock (libLock)
{
ActivateStream();
Native.colorbar(out p_colorbar_width, out p_colorbar_height, opt, position, x, y, x_length, y_length, bg_color, bb_color, bb_style, low_cap_color, high_cap_color, cont_color, cont_width, label_opts, labels, axis_opts, ticks, sub_ticks, values);
}
}
/// <summary>pllightsource: Sets the 3D position of the light source</summary>
/// <param name="x">X-coordinate of the light source.</param>
/// <param name="y">Y-coordinate of the light source.</param>
/// <param name="z">Z-coordinate of the light source.</param>
/// <remarks>Sets the 3D position of the light source for use with plsurf3d and plsurf3dl</remarks>
public void lightsource(PLFLT x, PLFLT y, PLFLT z)
{
lock (libLock)
{
ActivateStream();