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
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
|
<html>
<head>
<meta http-equiv="Content-Type" content="text/html"; charset=utf-8" >
<title>giza - API Reference Manual</title>
<link rel="stylesheet" href="../style.css" type="text/css" >
</head>
<div class="header">
<a href="/giza"><img alt="giza" src="../title.png"></a>
</div>
<div id="menucontainer">
<ul id="menulist">
<li><a href="../news/">news</a></li>
<li><a href="../download/">download</a></li>
<li><a href="../documentation/">documentation</a></li>
<li><a href="../contact/">contact</a></li>
<li><a href="../samples/">samples</a></li>
</ul>
</div>
<div id="content">
<h1>API Reference Manual</h1>
<p>Here we provided a function by function reference for the low-level C API to giza.
<br/>The giza API is <strong>stable</strong>.
From version 1.0 we aim to keep backwards compatibility, although new functionality may be added</p>
<h1>Index</h1>
<dl class="toc"><dt><a href="#Device_management">Device Management</a></dt>
<dd><a href="#giza_device_has_cursor">giza_device_has_cursor</a></dd>
<dd><a href="#giza_open_device">giza_open_device</a></dd>
<dd><a href="#giza_open_device_size">giza_open_device_size</a></dd>
<dd><a href="#giza_open_device_size_float">giza_open_device_size_float</a></dd>
<dd><a href="#giza_get_device_id">giza_get_device_id</a></dd>
<dd><a href="#giza_select_device">giza_select_device</a></dd>
<dd><a href="#giza_flush_device">giza_flush_device</a></dd>
<dd><a href="#giza_change_page">giza_change_page</a></dd>
<dd><a href="#giza_close_devices">giza_close_devices</a></dd>
<dd><a href="#giza_close_device">giza_close_device</a></dd>
<dd><a href="#giza_query_device">giza_query_device</a></dd>
<dd><a href="#giza_set_motion_callback">giza_set_motion_callback</a></dd>
<dd><a href="#giza_end_motion_callback">giza_end_motion_callback</a></dd>
<dd><a href="#giza_get_surface_size">giza_get_surface_size</a></dd>
<dd><a href="#giza_get_surface_size_float">giza_get_surface_size_float</a></dd>
<dd><a href="#giza_histogram">giza_histogram</a></dd>
<dd><a href="#giza_histogram_float">giza_histogram_float</a></dd>
<dd><a href="#giza_histogram_binned">giza_histogram_binned</a></dd>
<dd><a href="#giza_histogram_binned_float">giza_histogram_binned_float</a></dd>
<dd><a href="#giza_subpanel">giza_subpanel</a></dd>
<dd><a href="#giza_set_panel">giza_set_panel</a></dd>
<dd><a href="#giza_get_panel">giza_get_panel</a></dd>
<dd><a href="#giza_init_subpanel">giza_init_subpanel</a></dd>
<dd><a href="#giza_advance_panel">giza_advance_panel</a></dd>
<dt><a href="#Drawing">Drawing</a></dt>
<dd><a href="#giza_arrow">giza_arrow</a></dd>
<dd><a href="#giza_arrow_float">giza_arrow_float</a></dd>
<dd><a href="#giza_axis">giza_axis</a></dd>
<dd><a href="#giza_axis_float">giza_axis_float</a></dd>
<dd><a href="#giza_box_time">giza_box_time</a></dd>
<dd><a href="#giza_box_time_float">giza_box_time_float</a></dd>
<dd><a href="#giza_box">giza_box</a></dd>
<dd><a href="#giza_box_float">giza_box_float</a></dd>
<dd><a href="#giza_circle">giza_circle</a></dd>
<dd><a href="#giza_circle_float">giza_circle_float</a></dd>
<dd><a href="#giza_clip">giza_clip</a></dd>
<dd><a href="#giza_get_clipping">giza_get_clipping</a></dd>
<dd><a href="#giza_colour_bar">giza_colour_bar</a></dd>
<dd><a href="#giza_colour_bar_float">giza_colour_bar_float</a></dd>
<dd><a href="#giza_draw_background">giza_draw_background</a></dd>
<dd><a href="#giza_draw">giza_draw</a></dd>
<dd><a href="#giza_draw_float">giza_draw_float</a></dd>
<dd><a href="#giza_error_bars">giza_error_bars</a></dd>
<dd><a href="#giza_error_bars_float">giza_error_bars_float</a></dd>
<dd><a href="#giza_error_bars_vert">giza_error_bars_vert</a></dd>
<dd><a href="#giza_error_bars_vert_float">giza_error_bars_vert_float</a></dd>
<dd><a href="#giza_function_t">giza_function_t</a></dd>
<dd><a href="#giza_function_t_float">giza_function_t_float</a></dd>
<dd><a href="#giza_function_x">giza_function_x</a></dd>
<dd><a href="#giza_function_x_float">giza_function_x_float</a></dd>
<dd><a href="#giza_line">giza_line</a></dd>
<dd><a href="#giza_line_float">giza_line_float</a></dd>
<dd><a href="#giza_move">giza_move</a></dd>
<dd><a href="#giza_move_float">giza_move_float</a></dd>
<dd><a href="#giza_get_current_point">giza_get_current_point</a></dd>
<dd><a href="#giza_get_current_point_float">giza_get_current_point_float</a></dd>
<dd><a href="#giza_points">giza_points</a></dd>
<dd><a href="#giza_points_float">giza_points_float</a></dd>
<dd><a href="#giza_single_point">giza_single_point</a></dd>
<dd><a href="#giza_single_point_float">giza_single_point_float</a></dd>
<dd><a href="#giza_polygon">giza_polygon</a></dd>
<dd><a href="#giza_polygon_float">giza_polygon_float</a></dd>
<dd><a href="#giza_rectangle">giza_rectangle</a></dd>
<dd><a href="#giza_rectangle_float">giza_rectangle_float</a></dd>
<dd><a href="#giza_rectangle_rounded">giza_rectangle_rounded</a></dd>
<dd><a href="#giza_rectangle_rounded_float">giza_rectangle_rounded_float</a></dd>
<dd><a href="#giza_render">giza_render</a></dd>
<dd><a href="#giza_render_transparent">giza_render_transparent</a></dd>
<dd><a href="#giza_render_alpha">giza_render_alpha</a></dd>
<dd><a href="#giza_render_float">giza_render_float</a></dd>
<dd><a href="#giza_render_transparent_float">giza_render_transparent_float</a></dd>
<dd><a href="#giza_render_alpha_float">giza_render_alpha_float</a></dd>
<dd><a href="#giza_render_gray">giza_render_gray</a></dd>
<dd><a href="#giza_render_gray_float">giza_render_gray_float</a></dd>
<dd><a href="#giza_draw_pixels">giza_draw_pixels</a></dd>
<dd><a href="#giza_draw_pixels_float">giza_draw_pixels_float</a></dd>
<dd><a href="#giza_tick">giza_tick</a></dd>
<dd><a href="#giza_tick_float">giza_tick_float</a></dd>
<dd><a href="#giza_vector">giza_vector</a></dd>
<dd><a href="#giza_vector_float">giza_vector_float</a></dd>
<dt><a href="#Text">Text</a></dt>
<dd><a href="#giza_annotate">giza_annotate</a></dd>
<dd><a href="#giza_annotate_float">giza_annotate_float</a></dd>
<dd><a href="#giza_label">giza_label</a></dd>
<dd><a href="#giza_print_id">giza_print_id</a></dd>
<dd><a href="#giza_ptext">giza_ptext</a></dd>
<dd><a href="#giza_ptext_float">giza_ptext_float</a></dd>
<dd><a href="#giza_text">giza_text</a></dd>
<dd><a href="#giza_text_float">giza_text_float</a></dd>
<dd><a href="#giza_qtext">giza_qtext</a></dd>
<dd><a href="#giza_qtext_float">giza_qtext_float</a></dd>
<dd><a href="#giza_qtextlen">giza_qtextlen</a></dd>
<dd><a href="#giza_qtextlen_float">giza_qtextlen_float</a></dd>
<dt><a href="#Settings">Settings</a></dt>
<dd><a href="#giza_set_arrow_style">giza_set_arrow_style</a></dd>
<dd><a href="#giza_set_arrow_style_float">giza_set_arrow_style_float</a></dd>
<dd><a href="#giza_get_arrow_style">giza_get_arrow_style</a></dd>
<dd><a href="#giza_get_arrow_style_float">giza_get_arrow_style_float</a></dd>
<dd><a href="#giza_set_band_style">giza_set_band_style</a></dd>
<dd><a href="#giza_get_band_style">giza_get_band_style</a></dd>
<dd><a href="#giza_begin_buffer">giza_begin_buffer</a></dd>
<dd><a href="#giza_end_buffer">giza_end_buffer</a></dd>
<dd><a href="#giza_get_buffering">giza_get_buffering</a></dd>
<dd><a href="#giza_flush_buffer">giza_flush_buffer</a></dd>
<dd><a href="#giza_set_character_height">giza_set_character_height</a></dd>
<dd><a href="#giza_set_character_height_float">giza_set_character_height_float</a></dd>
<dd><a href="#giza_get_character_height">giza_get_character_height</a></dd>
<dd><a href="#giza_get_character_height_float">giza_get_character_height_float</a></dd>
<dd><a href="#giza_get_character_size">giza_get_character_size</a></dd>
<dd><a href="#giza_get_character_size_float">giza_get_character_size_float</a></dd>
<dd><a href="#giza_set_colour_index">giza_set_colour_index</a></dd>
<dd><a href="#giza_get_colour_index">giza_get_colour_index</a></dd>
<dd><a href="#giza_set_colour_representation">giza_set_colour_representation</a></dd>
<dd><a href="#giza_set_colour_representation_float">giza_set_colour_representation_float</a></dd>
<dd><a href="#giza_set_colour_representation_alpha">giza_set_colour_representation_alpha</a></dd>
<dd><a href="#giza_set_colour_representation_alpha_float">giza_set_colour_representation_alpha_float</a></dd>
<dd><a href="#giza_set_colour_representation_hls">giza_set_colour_representation_hls</a></dd>
<dd><a href="#giza_set_colour_representation_hls_float">giza_set_colour_representation_hls_float</a></dd>
<dd><a href="#giza_set_colour_representation_rgb">giza_set_colour_representation_rgb</a></dd>
<dd><a href="#giza_set_colour_representation_rgba">giza_set_colour_representation_rgba</a></dd>
<dd><a href="#giza_set_colour_representation_rgba_float">giza_set_colour_representation_rgba_float</a></dd>
<dd><a href="#giza_get_colour_representation">giza_get_colour_representation</a></dd>
<dd><a href="#giza_get_colour_representation_alpha">giza_get_colour_representation_alpha</a></dd>
<dd><a href="#giza_set_colour_index_range">giza_set_colour_index_range</a></dd>
<dd><a href="#giza_get_colour_index_range">giza_get_colour_index_range</a></dd>
<dd><a href="#giza_set_range_as_colour_table">giza_set_range_as_colour_table</a></dd>
<dd><a href="#giza_set_colour_palette">giza_set_colour_palette</a></dd>
<dd><a href="#giza_set_colour_table">giza_set_colour_table</a></dd>
<dd><a href="#giza_set_colour_table_float">giza_set_colour_table_float</a></dd>
<dd><a href="#giza_rgb_from_table">giza_rgb_from_table</a></dd>
<dd><a href="#giza_rgb_from_table_float">giza_rgb_from_table_float</a></dd>
<dd><a href="#giza_save_colour_table">giza_save_colour_table</a></dd>
<dd><a href="#giza_restore_colour_table">giza_restore_colour_table</a></dd>
<dd><a href="#giza_set_environment">giza_set_environment</a></dd>
<dd><a href="#giza_set_environment_float">giza_set_environment_float</a></dd>
<dd><a href="#giza_set_fill">giza_set_fill</a></dd>
<dd><a href="#giza_get_fill">giza_get_fill</a></dd>
<dd><a href="#giza_set_hatching_style">giza_set_hatching_style</a></dd>
<dd><a href="#giza_set_hatching_style_float">giza_set_hatching_style_float</a></dd>
<dd><a href="#giza_get_hatching_style">giza_get_hatching_style</a></dd>
<dd><a href="#giza_get_hatching_style_float">giza_get_hatching_style_float</a></dd>
<dd><a href="#giza_begin_autolog">giza_begin_autolog</a></dd>
<dd><a href="#giza_end_autolog">giza_end_autolog</a></dd>
<dd><a href="#giza_set_line_cap">giza_set_line_cap</a></dd>
<dd><a href="#giza_get_line_cap">giza_get_line_cap</a></dd>
<dd><a href="#giza_set_line_style">giza_set_line_style</a></dd>
<dd><a href="#giza_get_line_style">giza_get_line_style</a></dd>
<dd><a href="#giza_set_line_width">giza_set_line_width</a></dd>
<dd><a href="#giza_set_line_width_float">giza_set_line_width_float</a></dd>
<dd><a href="#giza_get_line_width">giza_get_line_width</a></dd>
<dd><a href="#giza_start_prompting">giza_start_prompting</a></dd>
<dd><a href="#giza_stop_prompting">giza_stop_prompting</a></dd>
<dd><a href="#giza_save">giza_save</a></dd>
<dd><a href="#giza_restore">giza_restore</a></dd>
<dd><a href="#giza_set_font">giza_set_font</a></dd>
<dd><a href="#giza_set_font_bold">giza_set_font_bold</a></dd>
<dd><a href="#giza_set_font_italic">giza_set_font_italic</a></dd>
<dd><a href="#giza_set_font_bold_italic">giza_set_font_bold_italic</a></dd>
<dd><a href="#giza_get_font">giza_get_font</a></dd>
<dd><a href="#giza_set_text_background">giza_set_text_background</a></dd>
<dd><a href="#giza_get_text_background">giza_get_text_background</a></dd>
<dd><a href="#giza_version">giza_version</a></dd>
<dd><a href="#giza_set_viewport">giza_set_viewport</a></dd>
<dd><a href="#giza_set_viewport_float">giza_set_viewport_float</a></dd>
<dd><a href="#giza_get_viewport">giza_get_viewport</a></dd>
<dd><a href="#giza_get_viewport_float">giza_get_viewport_float</a></dd>
<dd><a href="#giza_set_viewport_default">giza_set_viewport_default</a></dd>
<dd><a href="#giza_set_viewport_inches">giza_set_viewport_inches</a></dd>
<dd><a href="#giza_set_viewport_inches_float">giza_set_viewport_inches_float</a></dd>
<dd><a href="#giza_start_warnings">giza_start_warnings</a></dd>
<dd><a href="#giza_stop_warnings">giza_stop_warnings</a></dd>
<dd><a href="#giza_set_window">giza_set_window</a></dd>
<dd><a href="#giza_set_window_float">giza_set_window_float</a></dd>
<dd><a href="#giza_set_window_equal_scale">giza_set_window_equal_scale</a></dd>
<dd><a href="#giza_set_window_equal_scale_float">giza_set_window_equal_scale_float</a></dd>
<dd><a href="#giza_get_window">giza_get_window</a></dd>
<dd><a href="#giza_get_window_float">giza_get_window_float</a></dd>
<dt><a href="#Interactive">Interactive</a></dt>
<dd><a href="#giza_band">giza_band</a></dd>
<dd><a href="#giza_band_float">giza_band_float</a></dd>
<dd><a href="#giza_mark_points">giza_mark_points</a></dd>
<dd><a href="#giza_mark_points_float">giza_mark_points_float</a></dd>
<dd><a href="#giza_mark_points_ordered">giza_mark_points_ordered</a></dd>
<dd><a href="#giza_mark_points_ordered_float">giza_mark_points_ordered_float</a></dd>
<dd><a href="#giza_mark_line">giza_mark_line</a></dd>
<dd><a href="#giza_mark_points_float">giza_mark_points_float</a></dd>
<dd><a href="#giza_mark_line_ordered">giza_mark_line_ordered</a></dd>
<dd><a href="#giza_mark_line_ordered_float">giza_mark_line_ordered_float</a></dd>
<dd><a href="#giza_mark_line_char">giza_mark_line_char</a></dd>
<dd><a href="#giza_mark_points_float">giza_mark_points_float</a></dd>
<dd><a href="#giza_get_key_press">giza_get_key_press</a></dd>
</dl><a name="Device_managment"></a><h1>Device Managment</h1>
<h3><a name="giza_device_has_cursor">giza_device_has_cursor</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_device_has_cursor</td><td> (void) ;</tr></table><p>Query the interactivity of the device.</p>
<h4>Return:</h4>
<table class="api"><tr>
<td>0 :</td><td>If the device is not interactive.</td>
</tr><tr>
<td>1 :</td><td>If the device is interactive.</td>
</tr></table><h3><a name="giza_open_device">giza_open_device</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_open_device</td><td> (const char *newDeviceName, const char *newPrefix) ;</tr></table><p>Opens a new device to be drawn to. Must be called before any drawing can take place.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>newDeviceName :</td><td>Specifies the name and type of device to be opened. See below for details.</td>
</tr><tr>
<td>newPrefix :</td><td>Specifies the default prefix to be used for file names.</td>
</tr></table><h4>Return value:</h4>
<table class="api"><tr>
<td><=0 :</td><td>an error has occurred</td>
</tr><tr>
<td>1 :</td><td>id of current device Note: this is the EXTERNAL device number, running from 1..Ndev The internal device numbers are array indices into the Dev[...] array and run from 0..Ndev-1</td>
</tr></table><h4>Available devices:</h4>
<table class="api"><tr>
<td>? :</td><td>User selects device</td>
</tr><tr>
<td>/xw :</td><td>X-window</td>
</tr><tr>
<td>/eps :</td><td>Encapsulated Postscript</td>
</tr><tr>
<td>/png :</td><td>Portable Network Graphics file</td>
</tr><tr>
<td>/mp4 :</td><td>Mpeg4 movie [requires ffmpeg support]</td>
</tr><tr>
<td>/svg :</td><td>Scalable Vector Graphics file</td>
</tr><tr>
<td>/pdf :</td><td>Portable Document Format</td>
</tr><tr>
<td>/vpdf :</td><td>Landscape Portable Document Format</td>
</tr><tr>
<td>/ps :</td><td>PostScript</td>
</tr><tr>
<td>/vps :</td><td>Landscape Postscript</td>
</tr></table><h4>e.g:</h4>
<table class="api"></table><h4>See Also:</h4><p><a href="#giza_select_device">giza_select_device</a> <a href="#giza_get_device_id">giza_get_device_id</a> <a href="#giza_close_device">giza_close_device</a> <a href="#giza_query_device">giza_query_device</a> </p><h3><a name="giza_open_device_size">giza_open_device_size</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_open_device_size</td><td> (const char *newDeviceName, const char *newPrefix, double width, double height, int units) ;</tr></table><p>Similar to giza_open_device, but allows one to specify the size of the device</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>newDeviceName :</td><td>Specifies the type of device to be opened. See below for details.</td>
</tr><tr>
<td>newPrefix :</td><td>Specifies the default prefix to be used for file names.</td>
</tr><tr>
<td>width :</td><td>Width for the newly opened device</td>
</tr><tr>
<td>height :</td><td>Height for the newly opened device</td>
</tr><tr>
<td>units :</td><td>Units in which the width/height of the device are specified</td>
</tr></table><h4>Units:</h4>
<table class="api"><tr>
<td>GIZA_UNITS_DEVICE :</td><td>device coords (i.e. pixels on bitmap devices, points on vector devices)</td>
</tr><tr>
<td>GIZA_UNITS_PIXELS :</td><td>pixels</td>
</tr><tr>
<td>GIZA_UNITS_MM :</td><td>mm</td>
</tr><tr>
<td>GIZA_UNITS_INCHES :</td><td>inches Other values cause an error message and are treated as GIZA_UNITS_DEVICE</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_open_device">giza_open_device</a> </p><h3><a name="giza_open_device_size_float">giza_open_device_size_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_open_device_size_float</td><td> (const char *newDeviceName, const char *newPrefix, float width, float height, int units) ;</tr></table><p>Same functionality as giza_open_device_size but takes floats</p>
<h3><a name="giza_get_device_id">giza_get_device_id</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_device_id</td><td> (int *devid) ;</tr></table><p>Returns the (external) id of the currently selected device</p>
<h4>Output:</h4>
<table class="api"></table><h4>See Also:</h4><p><a href="#giza_open_device">giza_open_device</a> <a href="#giza_get_device_id">giza_get_device_id</a> </p><h3><a name="giza_select_device">giza_select_device</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_select_device</td><td> (int devid) ;</tr></table><p>Select between the currently open devices</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>devid :</td><td>device id, as returned by giza_open_device</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_get_device_id">giza_get_device_id</a> <a href="#giza_open_device">giza_open_device</a> </p><h3><a name="giza_flush_device">giza_flush_device</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_flush_device</td><td> (void) ;</tr></table><p>Flushes the currently open device.</p>
<h3><a name="giza_change_page">giza_change_page</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_change_page</td><td> (void) ;</tr></table><p>Advances the currently open device to the next page, and redraws the background. If no other actions have been performed since the device was opened or the last call to giza_change_page the call is ignored.</p>
<h4>See Also:</h4><p><a href="#giza_subpanel">giza_subpanel</a> <a href="#giza_set_panel">giza_set_panel</a> </p><h3><a name="giza_close_devices">giza_close_devices</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_close_devices</td><td> (void) ;</tr></table><p>Close all open devices (to be called from PGEND())</p>
<h3><a name="giza_close_device">giza_close_device</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_close_device</td><td> (void) ;</tr></table><p>Closes the currently open device. Should always be called before exiting your program as it frees associated memory.</p>
<h3><a name="giza_query_device">giza_query_device</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_query_device</td><td> (const char *querytype, char *returnval, int* rlen) ;</tr></table><p>Queries various things about the current device.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>querytype :</td><td>a string containing the query type</td>
</tr><tr>
<td>rlen :</td><td>integer containing the length of the return buffer</td>
</tr></table><h4>Output:</h4>
<table class="api"><tr>
<td>returnval :</td><td>string with result of query</td>
</tr></table><h4>The following query types are possible:</h4>
<table class="api"></table><h4>"state" :</h4>
<table class="api"></table><h4>"device" :</h4>
<table class="api"></table><h4>"type" :</h4>
<table class="api"></table><h4>"dev/type" :</h4>
<table class="api"></table><h4>"file" :</h4>
<table class="api"></table><h4>"user" :</h4>
<table class="api"></table><h4>"cursor" :</h4>
<table class="api"></table><h4>"hardcopy" :</h4>
<table class="api"></table><h3><a name="giza_set_motion_callback">giza_set_motion_callback</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_set_motion_callback</td><td> (void (*func)(double *x, double *y, int *mode)) ;</tr></table><p>set a callback function to be called during cursor movement (e.g. to print things). Function should be of the form void func(double *x, double *y)</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>func :</td><td>The subroutine to be called</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_end_motion_callback">giza_end_motion_callback</a> </p><h3><a name="giza_end_motion_callback">giza_end_motion_callback</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_end_motion_callback</td><td> (void) ;</tr></table><p>Free the motion callback pointer</p>
<h4>See Also:</h4><p><a href="#giza_set_motion_callback">giza_set_motion_callback</a> </p><h3><a name="giza_get_surface_size">giza_get_surface_size</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_surface_size</td><td> (double *x1, double *x2, double *y1, double *y2) ;</tr></table><p>Gets the size of the current surface that can be drawn to in device units (pixels or points).</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x1 :</td><td>Always gets set to 0.0</td>
</tr><tr>
<td>x2 :</td><td>Gets set to the width of the current surface</td>
</tr><tr>
<td>y1 :</td><td>Always gets set to 0.0</td>
</tr><tr>
<td>y2 :</td><td>Gets set to the width of the surface</td>
</tr></table><h3><a name="giza_get_surface_size_float">giza_get_surface_size_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_surface_size_float</td><td> (float *x1, float *x2, float *y1, float *y2) ;</tr></table><p>Same functionality as giza_get_surface_size, but uses floats.</p>
<h4>See Also:</h4><p><a href="#giza_get_surface_size">giza_get_surface_size</a> </p><h3><a name="giza_histogram">giza_histogram</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_histogram</td><td> (int n, const double *dat, double min, double max, int nbin, int flag) ;</tr></table><p>Plot a histogram (unbinned)</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>n :</td><td>number of data values</td>
</tr><tr>
<td>dat :</td><td>data (n values)</td>
</tr><tr>
<td>min :</td><td>minimum data value to use in histogram</td>
</tr><tr>
<td>max :</td><td>maximum data value to use in histogram</td>
</tr><tr>
<td>nbin :</td><td>number of bins</td>
</tr><tr>
<td>flag :</td><td>flag to indicate page changes, see below</td>
</tr></table><h4>Flag:</h4>
<table class="api"><tr>
<td>0 :</td><td>giza_histogram calls giza_environment to set up new plotting page</td>
</tr><tr>
<td>1 :</td><td>plot in current window and viewport</td>
</tr><tr>
<td>2 :</td><td>with filled area style, calls giza_environment</td>
</tr><tr>
<td>3 :</td><td>with filled area style, in current window and viewport</td>
</tr><tr>
<td>4 :</td><td>bins drawn as simple outlines, as in giza_histogram_binned, calls giza_environment</td>
</tr><tr>
<td>5 :</td><td>bins drawn as simple outlines, but in current window and viewport Other values treated as 1</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_histogram_binned">giza_histogram_binned</a> <a href="#giza_histogram_float">giza_histogram_float</a> </p><h3><a name="giza_histogram_float">giza_histogram_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_histogram_float</td><td> (int n, const float *dat, float min, float max, int nbin, int flag) ;</tr></table><p>Same as giza_histogram but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_histogram">giza_histogram</a> <a href="#giza_histogram_binned_float">giza_histogram_binned_float</a> </p><h3><a name="giza_histogram_binned">giza_histogram_binned</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_histogram_binned</td><td> (int n, const double *x, const double *dat, int centre) ;</tr></table><p>Plot a histogram of already binned data</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>n :</td><td>number of bins</td>
</tr><tr>
<td>x :</td><td>x values of bins</td>
</tr><tr>
<td>dat :</td><td>data values for each bin</td>
</tr><tr>
<td>center :</td><td>if true (1) x values correspond to centre of each bin</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_histogram">giza_histogram</a> <a href="#giza_histogram_binned_float">giza_histogram_binned_float</a> </p><h3><a name="giza_histogram_binned_float">giza_histogram_binned_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_histogram_binned_float</td><td> (int n, const float *x, const float *dat, int centre) ;</tr></table><p>Same as giza_histogram_binned but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_histogram">giza_histogram</a> <a href="#giza_histogram_binned_float">giza_histogram_binned_float</a> </p><h3><a name="giza_subpanel">giza_subpanel</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_subpanel</td><td> (int nx, int ny) ;</tr></table><p>Set the number of sub panels</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>nx :</td><td>number of sub-panels in x direction</td>
</tr><tr>
<td>ny :</td><td>number of sub panels in y direction</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_select_panel">giza_select_panel</a> <a href="#giza_get_panel">giza_get_panel</a> </p><h3><a name="giza_set_panel">giza_set_panel</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_panel</td><td> (int ix, int iy) ;</tr></table><p>Select the panel we are currently plotting in</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ix :</td><td>panel index in x direction</td>
</tr><tr>
<td>iy :</td><td>panel index in y direction</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_subpanel">giza_subpanel</a> <a href="#giza_get_panel">giza_get_panel</a> </p><h3><a name="giza_get_panel">giza_get_panel</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_panel</td><td> (int *ix, int *iy) ;</tr></table><p>Select the panel we are currently plotting in</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ix :</td><td>panel index in x direction</td>
</tr><tr>
<td>iy :</td><td>panel index in y direction</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_subpanel">giza_subpanel</a> <a href="#giza_set_panel">giza_set_panel</a> </p><h3><a name="giza_init_subpanel">giza_init_subpanel</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>_giza_init_subpanel</td><td> () ;</tr></table><p>initialises subpanel settings for device</p>
<h3><a name="giza_advance_panel">giza_advance_panel</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>_giza_advance_panel</td><td> (int *newpage) ;</tr></table><p>Moves to next panel</p>
<a name="Drawing"></a><h1>Drawing</h1>
<h3><a name="giza_arrow">giza_arrow</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_arrow</td><td> (double x1, double y1, double x2, double y2) ;</tr></table><p>Draws an arrow. The style of the head of the arrow is set by giza_set_arrow_style.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x1 :</td><td>The world x-coord of the tail of the arrow</td>
</tr><tr>
<td>y1 :</td><td>The world y-coord of the tail of the arrow</td>
</tr><tr>
<td>x2 :</td><td>The world x-coord of the head of the arrow</td>
</tr><tr>
<td>y2 :</td><td>The world y-coord of the head of the arrow</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_set_arrow_style">giza_set_arrow_style</a> <a href="#giza_arrow_float">giza_arrow_float</a> </p><h3><a name="giza_arrow_float">giza_arrow_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_arrow_float</td><td> (float x1, float y1, float x2, float y2) ;</tr></table><p>Same functionality as giza_arrow.</p>
<h4>See Also:</h4><p><a href="#giza_arrow">giza_arrow</a> <a href="#giza_set_arrow_style">giza_set_arrow_style</a> </p><h3><a name="giza_axis">giza_axis</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_axis</td><td> (const char *opt, double x1, double y1, double x2, double y2, double v1, double v2, double tick, int nsub, double dmajl, double dmajr, double fmin, double disp, double angle) ;</tr></table><p>Draw a labelled axis from (x1,y1) to (x2,y2)</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>opt :</td><td>String of options for the axis. The options may be in any order. See below for details</td>
</tr><tr>
<td>x1 :</td><td>starting x position in world coordinates</td>
</tr><tr>
<td>y1 :</td><td>starting y position in world coordinates</td>
</tr><tr>
<td>x2 :</td><td>finishing x position in world coordinates</td>
</tr><tr>
<td>y2 :</td><td>finishing y position in world coordinates</td>
</tr><tr>
<td>v1 :</td><td>axis value at starting position</td>
</tr><tr>
<td>v2 :</td><td>axis value at finishing position</td>
</tr><tr>
<td>tick :</td><td>The distance, in world coordinates, between major ticks on the axis. If 0.0 the interval is chosen automatically.</td>
</tr><tr>
<td>nsub :</td><td>The number of minor ticks to be placed between each major tick. If 0 the number is chosen automatically. Ignored if log axis.</td>
</tr><tr>
<td>dmajl :</td><td>Length of major tick marks drawn to "left/bottom" of axis in units of character height</td>
</tr><tr>
<td>dmajr :</td><td>Length of major tick marks drawn to "right/top" of axis in units of character height</td>
</tr><tr>
<td>fmin :</td><td>Length of minor tick marks as fraction of major</td>
</tr><tr>
<td>disp :</td><td>Displacement of labels from axis in units of character height</td>
</tr><tr>
<td>angle :</td><td>Label orientation; angle between text and direction of axis; in degrees</td>
</tr></table><h4>Options:</h4>
<table class="api"><tr>
<td>T :</td><td>Draw major ticks.</td>
</tr><tr>
<td>S :</td><td>Draw minor ticks.</td>
</tr><tr>
<td>N :</td><td>Label the axis</td>
</tr><tr>
<td>L :</td><td>Label axis logarithmically</td>
</tr><tr>
<td>H :</td><td>Hide the axis (draw ticks only)</td>
</tr><tr>
<td>I :</td><td>'Invert' tick marks, draw them on opposite side</td>
</tr><tr>
<td>1 :</td><td>Force decimal labelling instead of automatic choice (see giza_format_number)</td>
</tr><tr>
<td>2 :</td><td>Force exponential labelling instead of automatic choice (see giza_format_number)</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_axis_float">giza_axis_float</a> <a href="#giza_box">giza_box</a> <a href="#giza_tick">giza_tick</a> <a href="#giza_box_time">giza_box_time</a> </p><h3><a name="giza_axis_float">giza_axis_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_axis_float</td><td> (const char *opt, float x1, float y1, float x2, float y2, float v1, float v2, float step, int nsub, float dmajl, float dmajr, float fmin, float disp, float angle) ;</tr></table><p>Same functionality as giza_axis but takes floats instead of doubles.</p>
<h4>See Also:</h4><p><a href="#giza_axis">giza_axis</a> </p><h3><a name="giza_box_time">giza_box_time</a><hr></h3>
<table class="proto">
<tr><td width=10%> void</td><td width=20%></td><td> giza_box_time (const char *xopt, double xtick, int nxsub, const char *yopt, double ytick, int nysub) ;</tr></table><p>Same as giza_box, but labels axes with time-style labels i.e. DD HH MM SS as used in RA - DEC plots for Astronomy. If this option is used then giza_set_window should have been called with min/max given in seconds of time.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>xopt :</td><td>As for giza_box, plus additional options below</td>
</tr><tr>
<td>xtick :</td><td>The distance, in world coordinates, between major ticks on the x-axis. If 0.0 the interval is chosen by giza_box_time.</td>
</tr><tr>
<td>nxsub :</td><td>The number of minor ticks to be placed between each major tick. If 0 the number is chosen by giza_box.</td>
</tr><tr>
<td>yopt :</td><td>Similar to xdraw_minticks but for the y-axis.</td>
</tr><tr>
<td>ytick :</td><td>Similar to xtick but for the y-axis.</td>
</tr><tr>
<td>nysub :</td><td>Similar to nxsub but for the y-axis.</td>
</tr></table><h4>Options for xopt and yopt (same as for giza_box, plus those below):</h4>
<table class="api"><tr>
<td>Z :</td><td>for time-style labelling: (DD) HH MM SS.S</td>
</tr><tr>
<td>Y :</td><td>exclude the day field so labels are just HH MM SS.S (hours can be >24)</td>
</tr><tr>
<td>X :</td><td>keep HH field in range (0..24)</td>
</tr><tr>
<td>H :</td><td>use d,h,m,s superscripts to label numbers</td>
</tr><tr>
<td>D :</td><td>use degree o, minute ' and second '' superscripts to label numbers</td>
</tr><tr>
<td>F :</td><td>do not draw the first label (left- or bottom-most)</td>
</tr><tr>
<td>O :</td><td>omit leading zeros in numbers < 10, i.e. 3 instead of 03</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_box">giza_box</a> <a href="#giza_box_float">giza_box_float</a> <a href="#giza_box_time_float">giza_box_time_float</a> </p><h3><a name="giza_box_time_float">giza_box_time_float</a><hr></h3>
<table class="proto">
<tr><td width=10%> void</td><td width=20%>giza_box_time_float</td><td> (const char *xopt, float xtick, int nxsub, const char *yopt, float ytick, int nysub) ;</tr></table><p>Same functionality as giza_box_time but takes floats instead of doubles.</p>
<h4>See Also:</h4><p><a href="#giza_box_time">giza_box_time</a> <a href="#giza_box">giza_box</a> </p><h3><a name="giza_box">giza_box</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_box</td><td> (const char *xopt, double xtick, int nxsub, const char *yopt, double ytick, int nysub) ;</tr></table><p>Annotates the viewport with labelled axis/frame</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>xopt :</td><td>String of options for the x-axis. The options may be in any order. See below for details</td>
</tr><tr>
<td>xtick :</td><td>The distance, in world coordinates, between major ticks on the x-axis. If 0.0 the interval is chosen by giza_box.</td>
</tr><tr>
<td>nxsub :</td><td>The number of minor ticks to be placed between each major tick. If 0 the number is chosen by giza_box.</td>
</tr><tr>
<td>yopt :</td><td>Similar to xopt but for the y-axis.</td>
</tr><tr>
<td>ytick :</td><td>Similar to xtick but for the y-axis.</td>
</tr><tr>
<td>nysub :</td><td>Similar to nxsub but for the y-axis.</td>
</tr></table><h4>Options:</h4>
<table class="api"><tr>
<td>A :</td><td>Draw the axis.</td>
</tr><tr>
<td>B :</td><td>Draw the bottom or left edge of the frame.</td>
</tr><tr>
<td>C :</td><td>Draw the top or right edge of the frame.</td>
</tr><tr>
<td>T :</td><td>Draw major ticks.</td>
</tr><tr>
<td>S :</td><td>Draw minor ticks.</td>
</tr><tr>
<td>N :</td><td>Label the axis (conventional, below/left viewport)</td>
</tr><tr>
<td>M :</td><td>Put labels in the unconvential location (above/right viewport)</td>
</tr><tr>
<td>V :</td><td>Orient numeric y labels vertically (only applies to left and right axis).</td>
</tr><tr>
<td>G :</td><td>Draw grid lines at major intervals</td>
</tr><tr>
<td>M :</td><td>Write numeric labels above x-axis or to right of y-axis instead of usual position</td>
</tr><tr>
<td>L :</td><td>Label axis logarithmically</td>
</tr><tr>
<td>I :</td><td>'Invert' tick marks, draw them outside the viewport</td>
</tr><tr>
<td>P :</td><td>extend ("Project") major tick marks outside the box (ignored if option I is specified).</td>
</tr></table><h3><a name="giza_box_float">giza_box_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_box_float</td><td> (const char *xopt, float xtick, int nxsub, const char *yopt, float ytick, int nysub) ;</tr></table><p>Same functionality as giza_box but takes floats instead of doubles.</p>
<h4>See Also:</h4><p><a href="#giza_box">giza_box</a> </p><h3><a name="giza_circle">giza_circle</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_circle</td><td> (double x, double y, double r) ;</tr></table><p>Draws a circle at x, y with radius r (in world coords), using the current fill set by giza_set_fill.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x :</td><td>the world x-coord of the centre of the circle</td>
</tr><tr>
<td>y :</td><td>the world y-coord of the centre of the circle</td>
</tr><tr>
<td>r :</td><td>the radius of the circle in world coords</td>
</tr></table><h3><a name="giza_circle_float">giza_circle_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_circle_float</td><td> (float x, float y, float r) ;</tr></table><p>Same functionality as giza_circle, but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_circle">giza_circle</a> </p><h3><a name="giza_clip">giza_clip</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_clipping</td><td> (int clip) ;</tr></table><p>Set whether or not to clip at the edge of the viewport</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>clip :</td><td>Use 0 to disable clipping, 1 to enable clipping</td>
</tr></table><h3><a name="giza_get_clipping">giza_get_clipping</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_clipping</td><td> (int *clip) ;</tr></table><p>Query whether or not clipping at edge of viewport is enabled or disabled</p>
<h4>See Also:</h4><p><a href="#giza_move">giza_move</a> </p><h3><a name="giza_colour_bar">giza_colour_bar</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_colour_bar</td><td> (const char *side, double disp, double width, double valMin, double valMax, const char *label) ;</tr></table><p>Draws a colour bar (wedge) using the current colour ramp</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>side :</td><td>edge of viewport to draw colour bar relative to, either 'B' (bottom), 'T' (top), 'L' (left) or 'R' (right)</td>
</tr><tr>
<td>disp :</td><td>displacement of the bar in character heights from the specified edge</td>
</tr><tr>
<td>width :</td><td>width of the colour bar in character heights</td>
</tr><tr>
<td>valMin :</td><td>The value in data that gets assigned the colour corresponding to zero on the colour ramp (The ramp is set by giza_set_colour_table)</td>
</tr><tr>
<td>valMax :</td><td>The value in data that gets assigned the colour corresponding to one on the colour ramp</td>
</tr><tr>
<td>label :</td><td>Text label to annotate colour bar with</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_render">giza_render</a> <a href="#giza_colour_bar_float">giza_colour_bar_float</a> <a href="#giza_set_colour_table">giza_set_colour_table</a> </p><h3><a name="giza_colour_bar_float">giza_colour_bar_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_colour_bar_float</td><td> (const char *side, float disp, float width, float valMin, float valMax, const char *label) ;</tr></table><p>Same functionality as giza_colour_bar, but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_colour_bar">giza_colour_bar</a> </p><h3><a name="giza_draw_background">giza_draw_background</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_draw_background</td><td> (void) ;</tr></table><p>Redraws the background of the currently open device (erase)</p>
<h3><a name="giza_draw">giza_draw</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_draw</td><td> (double xpt, double ypt) ;</tr></table><p>Plots a line from current pen position to a point</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>xpt :</td><td>The world x-coordinates of the point</td>
</tr><tr>
<td>ypt :</td><td>The world y-coordinates of the point</td>
</tr></table><h3><a name="giza_draw_float">giza_draw_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_draw_float</td><td> (float xpt, float ypt) ;</tr></table><p>The same functionality as giza_draw, except it uses floats</p>
<h3><a name="giza_error_bars">giza_error_bars</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_error_bars</td><td> (int dir, int n, const double *xpts, const double *ypts, const double *error, double term) ;</tr></table><p>Draws error bars.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>dir :</td><td>the direction of the error bar, see below</td>
</tr><tr>
<td>n :</td><td>the number of points</td>
</tr><tr>
<td>xpts :</td><td>the x world coords of the points</td>
</tr><tr>
<td>ypts :</td><td>the y world coords of the points</td>
</tr><tr>
<td>error:</td><td>the length of the bar to be drawn in world coords</td>
</tr><tr>
<td>term :</td><td>the length of the terminals as a multiple of the default length</td>
</tr></table><h4>Directions:</h4>
<table class="api"><tr>
<td>1 :</td><td>+x</td>
</tr><tr>
<td>2 :</td><td>+y</td>
</tr><tr>
<td>3 :</td><td>-x</td>
</tr><tr>
<td>4 :</td><td>-y</td>
</tr><tr>
<td>5 :</td><td>+x and -x</td>
</tr><tr>
<td>6 :</td><td>+y and -y</td>
</tr><tr>
<td>7 :</td><td>-y but instead of drawing bars use a semi-transparent shaded region</td>
</tr><tr>
<td>8 :</td><td>+y using a semi-transparent shaded region</td>
</tr><tr>
<td>9 :</td><td>+y and -y using a semi-transparent shaded region</td>
</tr></table><h3><a name="giza_error_bars_float">giza_error_bars_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_error_bars_float</td><td> (int dir, int n, const float *xpts, const float *ypts, const float *error, float term) ;</tr></table><p>Same as giza_error_bars but takes floats.</p>
<h3><a name="giza_error_bars_vert">giza_error_bars_vert</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_error_bars_vert</td><td> (int n, const double *xpts, const double *ypts1, const double *ypts2, double term) ;</tr></table><p>Draws n vertical error bars. A call to giza_points must be made to draw the actual points.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>n :</td><td>the number of bars to draw</td>
</tr><tr>
<td>xpts :</td><td>the x world coords of the points</td>
</tr><tr>
<td>ypts1 :</td><td>the y world coords of the lower part of the error bar</td>
</tr><tr>
<td>ypts2 :</td><td>the y world coords of the upper part of the error bar</td>
</tr><tr>
<td>term :</td><td>length of the terminals, as a multiple of default length (T <= 0.0 means no terminals drawn)</td>
</tr></table><h3><a name="giza_error_bars_vert_float">giza_error_bars_vert_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_error_bars_vert_float</td><td> (int n, const float *xpts, const float *ypts1, const float *ypts2, float term) ;</tr></table><p>Same functionality as giza_error_bars_vert but takes floats.</p>
<h3><a name="giza_function_t">giza_function_t</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_function_t</td><td> (double (*funcx)(double *t), double (*funcy)(double *t), int n, double tmin, double tmax, int flag) ;</tr></table><p>Draw a curve defined by x = func(t), y = func(t), where funcx(t) and funcy(t) are user-supplied routines with a single double argument passed by reference, e.g. double myfuncx(double* t) double myfuncy(double* t)</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>funcx :</td><td>The parametrisation of the x value.</td>
</tr><tr>
<td>funcy :</td><td>The parametrisation of the y value.</td>
</tr><tr>
<td>n :</td><td>The number of segments to use to approximate the curve.</td>
</tr><tr>
<td>tmin :</td><td>The lower bound on the domain of t.</td>
</tr><tr>
<td>tmax :</td><td>The upper bound on the domain of t.</td>
</tr></table><h3><a name="giza_function_t_float">giza_function_t_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_function_t_float</td><td> (float (*funcx)(float *t), float (*funcy)(float *t), int n, float tmin, float tmax, int flag) ;</tr></table><p>The same functionality as giza_function_t but uses floats. Draw a curve defined by x = func(y), where func(y) is a user-supplied routine with a single float argument passed by reference, e.g. float myfuncx(float* t) float myfuncy(float* t)</p>
<h4>See Also:</h4><p><a href="#giza_function_t">giza_function_t</a> </p><h3><a name="giza_function_x">giza_function_x</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_function_x</td><td> (double (*func)(double *x), int n, double xmin, double xmax, int flag) ;</tr></table><p>Draw a curve defined by y = func(x), where func(x) is a user-supplied routine with a single double argument, e.g. double myfunc(double* x)</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>func :</td><td>The function describing y's dependence on x.</td>
</tr><tr>
<td>n :</td><td>The number of segments with whichh to approximate the curve</td>
</tr><tr>
<td>xmin :</td><td>The lower bound on the domain of x.</td>
</tr><tr>
<td>xmax :</td><td>The upper bound on the domain of x.</td>
</tr></table><h3><a name="giza_function_x_float">giza_function_x_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_function_x_float</td><td> (float (*func)(float *x), int n, float xmin, float xmax, int flag) ;</tr></table><p>Same functionality as giza_function_x but takes floats. Draw a curve defined by y = func(x), where func(x) is a user-supplied routine with a single double argument, e.g. float myfunc(float* x)</p>
<h4>See Also:</h4><p><a href="#giza_function_x">giza_function_x</a> </p><h3><a name="giza_line">giza_line</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_line</td><td> (int n, const double *xpts, const double *ypts) ;</tr></table><p>Plots a line made up of n-1 straight segments.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>n :</td><td>The number of points that define the line. The line will be made up of n - 1 straight segments. If n is less than 2 nothing is done.</td>
</tr><tr>
<td>xpts :</td><td>The world x-coordinates of the points to be joined.</td>
</tr><tr>
<td>ypts :</td><td>The world y-coordinates of the points to be joined.</td>
</tr></table><h3><a name="giza_line_float">giza_line_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_line_float</td><td> (int n, const float *xpts, const float *ypts) ;</tr></table><p>The same functionality as giza_line, except it uses arrays of floats</p>
<h4>See Also:</h4><p><a href="#giza_line">giza_line</a> </p><h3><a name="giza_move">giza_move</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_move</td><td> (double xpt, double ypt) ;</tr></table><p>Move current pen position to a point</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>xpt :</td><td>The world x-coordinates of the point</td>
</tr><tr>
<td>ypt :</td><td>The world y-coordinates of the point</td>
</tr></table><h3><a name="giza_move_float">giza_move_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_move_float</td><td> (float xpt, float ypt) ;</tr></table><p>The same functionality as giza_move, except it uses floats</p>
<h4>See Also:</h4><p><a href="#giza_move">giza_move</a> </p><h3><a name="giza_get_current_point">giza_get_current_point</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_current_point</td><td> (double *xpt, double *ypt) ;</tr></table><p>Query current pen position</p>
<h4>Output:</h4>
<table class="api"><tr>
<td>xpt :</td><td>The world x-coordinates of the point</td>
</tr><tr>
<td>ypt :</td><td>The world y-coordinates of the point</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_get_current_point_float">giza_get_current_point_float</a> </p><h3><a name="giza_get_current_point_float">giza_get_current_point_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_current_point_float</td><td> (float *xpt, float *ypt) ;</tr></table><p>The same functionality as giza_get_current_point, but uses floats</p>
<h4>See Also:</h4><p><a href="#giza_get_current_point">giza_get_current_point</a> </p><h3><a name="giza_points">giza_points</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_points</td><td> (int n, const double* x, const double* y, int symbol) ;</tr></table><p>Plot n points at x[n], y[n] in world coords.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>n :</td><td>the number of points</td>
</tr><tr>
<td>x :</td><td>the x-coordinates of the points in world coords</td>
</tr><tr>
<td>y :</td><td>the y-coordinates of the points in world coords</td>
</tr><tr>
<td>symbol :</td><td>the type of marker to use</td>
</tr></table><h4>Symbols:</h4>
<table class="api"><tr>
<td>default :</td><td>small point (same as 1)</td>
</tr><tr>
<td>0 :</td><td>square</td>
</tr><tr>
<td>1 :</td><td>.</td>
</tr><tr>
<td>2 :</td><td>+</td>
</tr><tr>
<td>3 :</td><td>*</td>
</tr><tr>
<td>4 :</td><td>o</td>
</tr><tr>
<td>5 :</td><td>x</td>
</tr><tr>
<td>>31 :</td><td>from the Unicode table</td>
</tr></table><h3><a name="giza_points_float">giza_points_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_points_float</td><td> (int n, const float* x, const float* y, int symbol) ;</tr></table><p>Same functionality as giza_points but takes floats.</p>
<h4>See Also:</h4><p><a href="#giza_points">giza_points</a> </p><h3><a name="giza_single_point">giza_single_point</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_single_point</td><td> (double x, double y, int symbol) ;</tr></table><p>Plots a single point at x, y in world coords.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x :</td><td>the x-coordinate of the point in world coords</td>
</tr><tr>
<td>y :</td><td>the y-coordinate of the point in world coords</td>
</tr><tr>
<td>symbol :</td><td>the type of marker to use</td>
</tr></table><h3><a name="giza_single_point_float">giza_single_point_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_single_point_float</td><td> (float x, float y, int symbol) ;</tr></table><p>Same functionality as giza_single_point, but uses floats.</p>
<h4>See Also:</h4><p><a href="#giza_single_point">giza_single_point</a> </p><h3><a name="giza_polygon">giza_polygon</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_polygon</td><td> (int n, const double *xpts, const double *ypts) ;</tr></table><p>Draws a polygon, using the current fill set by giza_set_fill.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>n :</td><td>number of vertices</td>
</tr><tr>
<td>xpts :</td><td>x positions of vertices</td>
</tr><tr>
<td>ypts :</td><td>y positions of vertices</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_set_fill">giza_set_fill</a> </p><h3><a name="giza_polygon_float">giza_polygon_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_polygon_float</td><td> (int n, const float *xpts, const float *ypts) ;</tr></table><p>Same functionality as giza_polygon, but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_polygon">giza_polygon</a> </p><h3><a name="giza_rectangle">giza_rectangle</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_rectangle</td><td> (double x1, double x2, double y1, double y2) ;</tr></table><p>Draws a rectangle with corners ((x1, y1) (x2, y1) (x2, y2) (x1, y2)), using the current fill set by giza_set_fill.</p>
<h4>Inputs:</h4>
<table class="api"><tr>
<td>x1 :</td><td>the x-coordinate of two of the points</td>
</tr><tr>
<td>x2 :</td><td>the x-coordinate of the other two points</td>
</tr><tr>
<td>y1 :</td><td>the y-coordinate of two of the points</td>
</tr><tr>
<td>y2 :</td><td>the y-coordinate of the other two points</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_set_fill">giza_set_fill</a> <a href="#giza_polygon">giza_polygon</a> </p><h3><a name="giza_rectangle_float">giza_rectangle_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_rectangle_float</td><td> (float x1, float x2, float y1, float y2) ;</tr></table><p>Same functionality as giza_rectangle but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_rectangle">giza_rectangle</a> </p><h3><a name="giza_rectangle_rounded">giza_rectangle_rounded</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_rectangle_rounded</td><td> (double x1, double x2, double y1, double y2, double radius) ;</tr></table><p>Draws a rectangle with rounded corners ((x1, y1) (x2, y1) (x2, y2) (x1, y2)), using the current fill set by giza_set_fill.</p>
<h4>Inputs:</h4>
<table class="api"><tr>
<td>x1 :</td><td>the x-coordinate of two of the points</td>
</tr><tr>
<td>x2 :</td><td>the x-coordinate of the other two points</td>
</tr><tr>
<td>y1 :</td><td>the y-coordinate of two of the points</td>
</tr><tr>
<td>y2 :</td><td>the y-coordinate of the other two points</td>
</tr><tr>
<td>radius :</td><td>radius of curvature for the corners</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_rectangle">giza_rectangle</a> <a href="#giza_set_fill">giza_set_fill</a> <a href="#giza_polygon">giza_polygon</a> </p><h3><a name="giza_rectangle_rounded_float">giza_rectangle_rounded_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_rectangle_rounded_float</td><td> (float x1, float x2, float y1, float y2, float radius) ;</tr></table><p>Same functionality as giza_rectangle_rounded but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_rectangle_rounded">giza_rectangle_rounded</a> </p><h3><a name="giza_render">giza_render</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_render</td><td> (int sizex, int sizey, const double* data, int i1, int i2, int j1, int j2, double valMin, double valMax, int extend, int filter, const double *affine) ;</tr></table><p>Renders data to the device.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>sizex :</td><td>The dimensions of data in the x-direction</td>
</tr><tr>
<td>sizey :</td><td>The dimensions of data in the y-direction</td>
</tr><tr>
<td>data :</td><td>The data to be rendered</td>
</tr><tr>
<td>i1 :</td><td>The inclusive range of data to render in the x dimension.</td>
</tr><tr>
<td>i2 :</td><td>The inclusive range of data to render in the x dimension.</td>
</tr><tr>
<td>j1 :</td><td>The inclusive range of data to render in the y direction</td>
</tr><tr>
<td>j2 :</td><td>The inclusive range of data to render in the y direction</td>
</tr><tr>
<td>valMin :</td><td>The value in data that gets assign the colour corresponding to zero on the colour ramp (The ramp is set by giza_set_colour_table)</td>
</tr><tr>
<td>valMax :</td><td>The value in data that gets assigned the colour corresponding to one on the colour ramp</td>
</tr><tr>
<td>extend :</td><td>Option for how to deal with image at edges</td>
</tr><tr>
<td>filter :</td><td>Option for how to interpolate between pixels (since v1.5)</td>
</tr><tr>
<td>affine :</td><td>The affine transformation matrix that will be applied to the data.</td>
</tr></table><h4>Allowed extend settings:</h4>
<table class="api"><tr>
<td>0 or GIZA_EXTEND_NONE :</td><td>no padding</td>
</tr><tr>
<td>1 or GIZA_EXTEND_REPEAT :</td><td>periodic tiling</td>
</tr><tr>
<td>2 or GIZA_EXTEND_REFLECT :</td><td>reflective boundary</td>
</tr><tr>
<td>3 or GIZA_EXTEND_PAD :</td><td>pad by extending last few pixels</td>
</tr></table><h4>Allowed filter settings (from cairo_filter_t):</h4>
<table class="api"><tr>
<td>0 or GIZA_FILTER_DEFAULT :</td><td>default, usually bilinear interpolation</td>
</tr><tr>
<td>1 or GIZA_FILTER_FAST :</td><td>a high performance filter with quality similar to GIZA_FILTER_NEAREST</td>
</tr><tr>
<td>2 or GIZA_FILTER_GOOD :</td><td>a reasonable-performance filter, with quality similar to GIZA_FILTER_BILINEAR</td>
</tr><tr>
<td>3 or GIZA_FILTER_BEST :</td><td>highest quality available, performance may not be suited for interactive use</td>
</tr><tr>
<td>4 or GIZA_FILTER_NEAREST :</td><td>Nearest-neighbour filtering</td>
</tr><tr>
<td>5 or GIZA_FILTER_BILINEAR :</td><td>Linear interpolation in two dimensions</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_set_colour_table">giza_set_colour_table</a> </p><h3><a name="giza_render_transparent">giza_render_transparent</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_render_transparent</td><td> (int sizex, int sizey, const double* data, int i1, int i2, int j1, int j2, double valMin, double valMax, int extend, int filter, const double *affine) ;</tr></table><p>Same as giza_render, but data < valMin rendered as transparent</p>
<h3><a name="giza_render_alpha">giza_render_alpha</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_render_alpha</td><td> (int sizex, int sizey, const double* data, const double* alpha, int i1, int i2, int j1, int j2, double valMin, double valMax, int extend, int filter, const double *affine) ;</tr></table><p>Same as giza_render, but uses additional array specifying transparency of each pixel</p>
<h3><a name="giza_render_float">giza_render_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_render_float</td><td> (int sizex, int sizey, const float* data, int i1, int i2, int j1, int j2, float valMin, float valMax, int extend, int filter, const float *affine) ;</tr></table><p>Same functionality as giza_render but takes floats.</p>
<h4>See Also:</h4><p><a href="#giza_render">giza_render</a> </p><h3><a name="giza_render_transparent_float">giza_render_transparent_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_render_transparent_float</td><td> (int sizex, int sizey, const float* data, int i1, int i2, int j1, int j2, float valMin, float valMax, int extend, int filter, const float *affine) ;</tr></table><p>Same functionality as giza_render_transparent but takes floats.</p>
<h4>See Also:</h4><p><a href="#giza_render_transparent">giza_render_transparent</a> </p><h3><a name="giza_render_alpha_float">giza_render_alpha_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_render_alpha_float</td><td> (int sizex, int sizey, const float* data, const float* alpha, int i1, int i2, int j1, int j2, float valMin, float valMax, int extend, int filter, const float *affine) ;</tr></table><p>Same as giza_render_alpha but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_render_alpha">giza_render_alpha</a> </p><h3><a name="giza_render_gray">giza_render_gray</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_render_gray</td><td> (int sizex, int sizey, const double* data, int i1, int i2, int j1, int j2, double valMin, double valMax, int extend, int filter, const double *affine) ;</tr></table><p>Same functionality as giza_render but renders in grayscale</p>
<h4>See Also:</h4><p><a href="#giza_render">giza_render</a> </p><h3><a name="giza_render_gray_float">giza_render_gray_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_render_gray_float</td><td> (int sizex, int sizey, const float* data, int i1, int i2, int j1, int j2, float valMin, float valMax, int extend, int filter, const float *affine) ;</tr></table><p>Same functionality as giza_render_gray but renders in grayscale</p>
<h4>See Also:</h4><p><a href="#giza_render_gray">giza_render_gray</a> <a href="#giza_render">giza_render</a> </p><h3><a name="giza_draw_pixels">giza_draw_pixels</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_draw_pixels</td><td> (int sizex, int sizey, const int* idata, int i1, int i2, int j1, int j2, double xmin, double xmax, double ymin, double ymax, int extend, int filter) ;</tr></table><p>Renders an array of pixels according to a colour index defined for each pixel</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>sizex :</td><td>The dimensions of data in the x-direction</td>
</tr><tr>
<td>sizey :</td><td>The dimensions of data in the y-direction</td>
</tr><tr>
<td>idata :</td><td>The data to be rendered (colour index on each pixel)</td>
</tr><tr>
<td>i1 :</td><td>The inclusive range of data to render in the x dimension.</td>
</tr><tr>
<td>i2 :</td><td>The inclusive range of data to render in the x dimension.</td>
</tr><tr>
<td>j1 :</td><td>The inclusive range of data to render in the y direction</td>
</tr><tr>
<td>j2 :</td><td>The inclusive range of data to render in the y direction</td>
</tr><tr>
<td>xmin :</td><td>world coordinate corresponding to left of pixel array</td>
</tr><tr>
<td>xmax :</td><td>world coordinate corresponding to right of pixel array</td>
</tr><tr>
<td>ymin :</td><td>world coordinate corresponding to bottom of pixel array</td>
</tr><tr>
<td>ymax :</td><td>world coordinate corresponding to top of pixel array</td>
</tr><tr>
<td>extend :</td><td>Option for how to deal with image at edges (see giza_render)</td>
</tr><tr>
<td>filter :</td><td>Option for how to interpolate between pixels (see giza_render, since v1.5)</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_render">giza_render</a> <a href="#giza_draw_pixels_float">giza_draw_pixels_float</a> </p><h3><a name="giza_draw_pixels_float">giza_draw_pixels_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_draw_pixels_float</td><td> (int sizex, int sizey, const int* idata, int i1, int i2, int j1, int j2, float xmin, float xmax, float ymin, float ymax, int extend, int filter) ;</tr></table><p>Same as giza_draw_pixels, but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_draw_pixels">giza_draw_pixels</a> </p><h3><a name="giza_tick">giza_tick</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_tick</td><td> (double x1, double y1, double x2, double y2, double v, double tickl, double tickr, double disp, double angle, const char *label) ;</tr></table><p>Draw a single tick along an axis. The axis extends from (x1,y1) to (x2,y2) and the tick is drawn perpendicular to the axis which is not drawn by this routine. Optional text label drawn parallel to the axis if the orientation angle is zero</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x1 :</td><td>starting x position in world coordinates</td>
</tr><tr>
<td>y1 :</td><td>starting y position in world coordinates</td>
</tr><tr>
<td>x2 :</td><td>finishing x position in world coordinates</td>
</tr><tr>
<td>y2 :</td><td>finishing y position in world coordinates</td>
</tr><tr>
<td>v :</td><td>axis value at tick location</td>
</tr><tr>
<td>tickl :</td><td>Length of tick mark drawn to "left/bottom" of axis in units of character height</td>
</tr><tr>
<td>tickr :</td><td>Length of tick mark drawn to "right/top" of axis in units of character height</td>
</tr><tr>
<td>disp :</td><td>Displacement of labels from axis in units of character height</td>
</tr><tr>
<td>angle :</td><td>Label orientation; angle between text and direction of axis; in degrees</td>
</tr><tr>
<td>label :</td><td>Text string used for label (can be blank)</td>
</tr></table><h3><a name="giza_tick_float">giza_tick_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_tick_float</td><td> (float x1, float y1, float x2, float y2, float v, float tickl, float tickr, float disp, float angle, const char *label) ;</tr></table><p>Same functionality as giza_tick but takes floats instead of doubles.</p>
<h4>See Also:</h4><p><a href="#giza_tick">giza_tick</a> </p><h3><a name="giza_vector">giza_vector</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_vector</td><td> (int n, int m, const double* horizontal, const double* vertical, int i1, int i2, int j1, int j2, double scale, int position, const double* affine, double blank) ;</tr></table><p>Plot of vector data.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>n :</td><td>The dimensions of data in the x-direction</td>
</tr><tr>
<td>m :</td><td>The dimensions of data in the y-direction</td>
</tr><tr>
<td>horizontal :</td><td>The x-component of the data to be plotted</td>
</tr><tr>
<td>vertical :</td><td>The y-component of the data to be plotted</td>
</tr><tr>
<td>i1 :</td><td>The inclusive range of data to render in the x dimension.</td>
</tr><tr>
<td>i2 :</td><td>The inclusive range of data to render in the x dimension.</td>
</tr><tr>
<td>j1 :</td><td>The inclusive range of data to render in the y direction</td>
</tr><tr>
<td>j2 :</td><td>The inclusive range of data to render in the y direction</td>
</tr><tr>
<td>scale :</td><td>scaling factor for arrow lengths (0 = automatic)</td>
</tr><tr>
<td>position :</td><td>justification of vector arrow with respect to pixel (0=left, 0.5=centred)</td>
</tr><tr>
<td>affine :</td><td>The affine transformation matrix that will be applied to the data.</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_vector_float">giza_vector_float</a> <a href="#giza_arrow">giza_arrow</a> <a href="#giza_set_arrow_style">giza_set_arrow_style</a> </p><h3><a name="giza_vector_float">giza_vector_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_vector_float</td><td> (int n, int m, const float* horizontal, const float* vertical, int i1, int i2, int j1, int j2, float scale, int position, const float* affine, float blank) ;</tr></table><p>Same as giza_vector but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_vector">giza_vector</a> <a href="#giza_arrow">giza_arrow</a> <a href="#giza_set_arrow_style">giza_set_arrow_style</a> </p><a name="Text"></a><h1>Text</h1>
<h3><a name="giza_annotate">giza_annotate</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_annotate</td><td> (const char *side, double displacment, double coord, double justification, const char *string) ;</tr></table><p>Writes text with a position relative to the viewport.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>side :</td><td>Must contain a character 'B','L','T' or 'R' specifying the bottom, left, top or right margin respectively. The position of the text will be relative to the specified side.</td>
</tr><tr>
<td>displacement :</td><td>The displacement of the text from the edge of the view-port specified in side, measured out of the view-port in units of character height.</td>
</tr><tr>
<td>coord :</td><td>The location of the text along the edge of the view port specified in side, measured as a fraction of that size</td>
</tr><tr>
<td>justification :</td><td>Specifies the justification of the text. 0.0 means the left most edge of the string will be aligned with coord, 1.0 means the right most edge of the string will be aligned with coord etc.</td>
</tr><tr>
<td>string :</td><td>The text that will be displayed.</td>
</tr></table><h3><a name="giza_annotate_float">giza_annotate_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_annotate_float</td><td> (const char *side, float displacment, float coord, float justification, const char *string) ;</tr></table><p>The same functionality as giza_annotate but takes floats instead of doubles.</p>
<h4>See Also:</h4><p><a href="#giza_annotate">giza_annotate</a> </p><h3><a name="giza_label">giza_label</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_label</td><td> (const char *labelx, const char *labely, const char *title) ;</tr></table><p>Labels the plot</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>labelx :</td><td>x-axis label</td>
</tr><tr>
<td>labely :</td><td>y-axis label</td>
</tr><tr>
<td>title :</td><td>The title of the plot</td>
</tr></table><h3><a name="giza_print_id">giza_print_id</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_print_id</td><td> (void) ;</tr></table><p>Prints user ID, date and time on the plot</p>
<h3><a name="giza_ptext">giza_ptext</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_ptext</td><td> (double x, double y, double angle, double just, const char *text) ;</tr></table><p>Draws text at a given position in world coords at a given angle with a given justification.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x :</td><td>The x world coord.</td>
</tr><tr>
<td>y :</td><td>The y world coord.</td>
</tr><tr>
<td>angle :</td><td>The angle to be drawn at.</td>
</tr><tr>
<td>just :</td><td>The justification.</td>
</tr><tr>
<td>text :</td><td>The text to be drawn.</td>
</tr></table><h3><a name="giza_ptext_float">giza_ptext_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_ptext_float</td><td> (float x, float y, float angle, float just, const char *text) ;</tr></table><p>Same functionality as giza_ptext but uses floats.</p>
<h4>See Also:</h4><p><a href="#giza_ptext">giza_ptext</a> </p><h3><a name="giza_text">giza_text</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_text</td><td> (double x, double y, const char *text) ;</tr></table><p>Draws text at the position (x, y).</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x :</td><td>The x-coordinate of the bottom left corner of the text.</td>
</tr><tr>
<td>y :</td><td>The y-coordinate of the bottom left corner of the text.</td>
</tr><tr>
<td>text :</td><td>The text to be drawn.</td>
</tr></table><h3><a name="giza_text_float">giza_text_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_text_float</td><td> (float x, float y, const char *text) ;</tr></table><p>Same functionality as giza_text but takes floats.</p>
<h4>See Also:</h4><p><a href="#giza_text">giza_text</a> </p><h3><a name="giza_qtext">giza_qtext</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_qtext</td><td> (double x, double y, double angle, double just, const char *text, double xbox[4], double ybox[4]) ;</tr></table><p>Returns the co-ordinates of a box bounding the given string if printed by giza_ptext.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x :</td><td>The x-coord of the text in world-coords</td>
</tr><tr>
<td>y :</td><td>The y-coord of the text in world-coords</td>
</tr><tr>
<td>angle :</td><td>The angle to draw the text at, in degrees</td>
</tr><tr>
<td>just :</td><td>The horizontal justification of the string. 0. for left-justified, 1. for right-justified</td>
</tr><tr>
<td>text :</td><td>The text to be drawn -xbox :-</td>
</tr><tr>
<td>ybox :</td><td>Set to the world co-ords of the bounding box</td>
</tr></table><h3><a name="giza_qtext_float">giza_qtext_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_qtext_float</td><td> (float x, float y, float angle, float just, const char *text, float xbox[4], float ybox[4]) ;</tr></table><p>Same as giza_qtext but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_qtext">giza_qtext</a> </p><h3><a name="giza_qtextlen">giza_qtextlen</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_qtextlen</td><td> (int units, const char *text, double *xlen, double *ylen) ;</tr></table><p>Returns the length of a string as would be printed by giza_ptext in a variety of units (added by DJP)</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>units :</td><td>The units in which to return the values</td>
</tr><tr>
<td>text :</td><td>The text to be drawn</td>
</tr><tr>
<td>xlen :</td><td>The length of the text in the x-direction</td>
</tr><tr>
<td>ylen :</td><td>The length of the text in the y-direction</td>
</tr></table><h3><a name="giza_qtextlen_float">giza_qtextlen_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_qtextlen_float</td><td> (int units, const char *text, float *xlen, float *ylen) ;</tr></table><p>Same functionality as giza_qtextlen but uses floats</p>
<h4>See Also:</h4><p><a href="#giza_qtextlen">giza_qtextlen</a> </p><a name="Settings"></a><h1>Settings</h1>
<h3><a name="giza_set_arrow_style">giza_set_arrow_style</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_arrow_style</td><td> (int fillStyle, double angle, double cutback) ;</tr></table><p>Sets the style of arrow head to be used for arrows drawn with giza_arrow.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>fillStyle :</td><td>Sets the fill style. See giza_set_fill</td>
</tr><tr>
<td>angle :</td><td>Sets the acute angle of the arrow head. Can range from 0.0 to 90.</td>
</tr><tr>
<td>cutback :</td><td>The fraction of the back of the arrow head that is cut back. 0.0 gives a triangular arrow head, 1.0 gives >.</td>
</tr></table><h3><a name="giza_set_arrow_style_float">giza_set_arrow_style_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_arrow_style_float</td><td> (int fillStyle, float angle, float cutback) ;</tr></table><p>Same functionality as giza_set_arrow_style but takes floats instead of doubles.</p>
<h4>See Also:</h4><p><a href="#giza_set_arrow_style">giza_set_arrow_style</a> </p><h3><a name="giza_get_arrow_style">giza_get_arrow_style</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_arrow_style</td><td> (int *fillStyle, double *angle, double *cutback) ;</tr></table><p>Queries the current arrow style settings, as set by giza_set_arrow_style.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>fillStyle :</td><td>Gets set to the current fillstyle.</td>
</tr><tr>
<td>angle :</td><td>Gets set to the current angle.</td>
</tr><tr>
<td>cutback :</td><td>Gets set to the current cutback.</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_set_arrow_style">giza_set_arrow_style</a> </p><h3><a name="giza_get_arrow_style_float">giza_get_arrow_style_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_arrow_style_float</td><td> (int *fillStyle, float *angle, float *cutback) ;</tr></table><p>Same functionality as giza_get_arrow_style, but takes floats instead of doubles.</p>
<h4>See Also:</h4><p><a href="#giza_get_arrow_style">giza_get_arrow_style</a> </p><h3><a name="giza_set_band_style">giza_set_band_style</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_band_style</td><td> (int ls, double lw) ;</tr></table><p>Sets the line style to be used by giza_band</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ls :</td><td>the line style for the band</td>
</tr><tr>
<td>lw :</td><td>the width for the line</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_band">giza_band</a> <a href="#giza_get_band_style">giza_get_band_style</a> </p><h3><a name="giza_get_band_style">giza_get_band_style</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_band_style</td><td> (int *ls, double *lw) ;</tr></table><p>Queries the current band style settings to be used by giza_band</p>
<h4>Output:</h4>
<table class="api"><tr>
<td>ls :</td><td>the line style for the band</td>
</tr><tr>
<td>lw :</td><td>the width for the line</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_band">giza_band</a> <a href="#giza_set_band_style">giza_set_band_style</a> </p><h3><a name="giza_begin_buffer">giza_begin_buffer</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_begin_buffer</td><td> (void) ;</tr></table><p>Begins buffering</p>
<h4>See Also:</h4><p><a href="#giza_end_buffer">giza_end_buffer</a> <a href="#giza_flush_buffer">giza_flush_buffer</a> </p><h3><a name="giza_end_buffer">giza_end_buffer</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_end_buffer</td><td> (void) ;</tr></table><p>Ends buffering</p>
<h4>See Also:</h4><p><a href="#giza_begin_buffer">giza_begin_buffer</a> <a href="#giza_flush_buffer">giza_flush_buffer</a> </p><h3><a name="giza_get_buffering">giza_get_buffering</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_buffering</td><td> (int *buf) ;</tr></table><p>returns whether output is currently buffered on current device</p>
<h4>See Also:</h4><p><a href="#giza_begin_buffer">giza_begin_buffer</a> <a href="#giza_flush_buffer">giza_flush_buffer</a> <a href="#giza_end_buffer">giza_end_buffer</a> </p><h3><a name="giza_flush_buffer">giza_flush_buffer</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_flush_buffer</td><td> (void) ;</tr></table><p>Updates graphics display Can be used to flush the graphics buffer manually between calls to giza_begin_buffer and giza_end_buffer</p>
<h4>See Also:</h4><p><a href="#giza_begin_buffer">giza_begin_buffer</a> <a href="#giza_end_buffer">giza_end_buffer</a> </p><h3><a name="giza_set_character_height">giza_set_character_height</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_character_height</td><td> (double ch) ;</tr></table><p>Sets the font size in units of character height. A character height of 1.0 corresponds to 1/37th of the plotting surface height by default</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ch :</td><td>the new character height</td>
</tr></table><h3><a name="giza_set_character_height_float">giza_set_character_height_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_character_height_float</td><td> (float ch) ;</tr></table><p>Same functionality as giza_set_character_height but takes a float</p>
<h3><a name="giza_get_character_height">giza_get_character_height</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_character_height</td><td> (double *ch) ;</tr></table><p>Query the character height</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ch :</td><td>gets set to the character height.</td>
</tr></table><h3><a name="giza_get_character_height_float">giza_get_character_height_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_character_height_float</td><td> (float *ch) ;</tr></table><p>Same functionality as giza_get_character_height but takes a float.</p>
<h4>See Also:</h4><p><a href="#giza_get_character_height">giza_get_character_height</a> </p><h3><a name="giza_get_character_size">giza_get_character_size</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_character_size</td><td> (int units, double *heightx, double *heighty) ;</tr></table><p>Returns the character size in a variety of units.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>units :</td><td>select the units the result will be returned in.</td>
</tr></table><h4>Output:</h4>
<table class="api"><tr>
<td>width :</td><td>will be set to the width of a character.</td>
</tr><tr>
<td>height :</td><td>will be set to the height of a character.</td>
</tr></table><h4>Units:</h4>
<table class="api"><tr>
<td>GIZA_UNITS_NORMALIZED :</td><td>normalised device coords.</td>
</tr><tr>
<td>GIZA_UNITS_WORLD :</td><td>world coords.</td>
</tr><tr>
<td>GIZA_UNITS_PIXELS :</td><td>pixels</td>
</tr><tr>
<td>GIZA_UNITS_DEVICE :</td><td>device coords.</td>
</tr><tr>
<td>GIZA_UNITS_MM :</td><td>mm</td>
</tr><tr>
<td>GIZA_UNITS_INCHES :</td><td>inches Other values cause an error message and are treated as GIZA_UNITS_NORMALIZED</td>
</tr></table><h3><a name="giza_get_character_size_float">giza_get_character_size_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_character_size_float</td><td> (int units, float *xch, float *ych) ;</tr></table><p>Same functionality as giza_get_character_size, but returns the values as floats</p>
<h3><a name="giza_set_colour_index">giza_set_colour_index</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_index</td><td> (int ci) ;</tr></table><p>Sets the colour to that represented by the colour index ci. Represented colours can be changed via giza_set_colour_representation.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ci :</td><td>The new colour index.</td>
</tr></table><h3><a name="giza_get_colour_index">giza_get_colour_index</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_colour_index</td><td> (int *ci) ;</tr></table><p>Queries the current colour index.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ci :</td><td>gets set to the current colour index.</td>
</tr></table><h3><a name="giza_set_colour_representation">giza_set_colour_representation</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_representation</td><td> (int ci, double red, double green, double blue) ;</tr></table><p>Allows the user to set the colour represented by the given colour index.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ci :</td><td>Which colour index to set.</td>
</tr><tr>
<td>red :</td><td>The red component of the colour (between 0 and 1).</td>
</tr><tr>
<td>green :</td><td>The green component of the colour (between 0 and 1).</td>
</tr><tr>
<td>blue :</td><td>The blue component of the colour (between 0 and 1).</td>
</tr></table><h3><a name="giza_set_colour_representation_float">giza_set_colour_representation_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_representation_float</td><td> (int ci, float red, float green, float blue) ;</tr></table><p>Same functionality as giza_set_colour_representation but takes floats/</p>
<h3><a name="giza_set_colour_representation_alpha">giza_set_colour_representation_alpha</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_representation_alpha</td><td> (int ci, double red, double green, double blue, double alpha) ;</tr></table><p>Allows the user to set the colour represented by the given colour index, aswell as the alpha.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ci :</td><td>Which colour index to set.</td>
</tr><tr>
<td>red :</td><td>The red component of the colour (between 0 and 1).</td>
</tr><tr>
<td>green :</td><td>The green component of the colour (between 0 and 1).</td>
</tr><tr>
<td>blue :</td><td>The blue component of the colour (between 0 and 1).</td>
</tr><tr>
<td>alpha :</td><td>The alpha used when drawing with this colour index (between 0 and 1).</td>
</tr></table><h3><a name="giza_set_colour_representation_alpha_float">giza_set_colour_representation_alpha_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_representation_alpha_float</td><td> (int ci, float red, float green, float blue, float alpha) ;</tr></table><p>Same functionality as giza_set_colour_representation_alpha but takes floats.</p>
<h4>See Also:</h4><p><a href="#giza_set_colour_representation_alpha">giza_set_colour_representation_alpha</a> <a href="#giza_set_colour_representation">giza_set_colour_representation</a> </p><h3><a name="giza_set_colour_representation_hls">giza_set_colour_representation_hls</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_representation_hls</td><td> (int ci, double hue, double lightness, double saturation) ;</tr></table><p>Allows the user to set the colour represented by the given colour index This routine accepts colours in the Hue, Lightness and Saturation system.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ci :</td><td>Which colour index to set.</td>
</tr><tr>
<td>hue :</td><td>The Hue component of the colour (between 0 and 360 degrees).</td>
</tr><tr>
<td>lightness :</td><td>The Lightness component of the colour (between 0 and 1).</td>
</tr><tr>
<td>saturation :</td><td>The Saturation component of the colour (between 0 and 1).</td>
</tr></table><h3><a name="giza_set_colour_representation_hls_float">giza_set_colour_representation_hls_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_representation_hls_float</td><td> (int ci, float hue, float lightness, float saturation) ;</tr></table><p>Same functionality as giza_set_colour_representation_hls but takes floats</p>
<h3><a name="giza_set_colour_representation_rgb">giza_set_colour_representation_rgb</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_representation_rgb</td><td> (int ci, int red, int green, int blue) ;</tr></table><p>Same as giza_set_colour_representation but accepts integer 0->255 instead of double 0->1</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ci :</td><td>Which colour index to set.</td>
</tr><tr>
<td>red :</td><td>The red component of the colour (between 0 and 255).</td>
</tr><tr>
<td>green :</td><td>The green component of the colour (between 0 and 255).</td>
</tr><tr>
<td>blue :</td><td>The blue component of the colour (between 0 and 255).</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_set_colour_representation">giza_set_colour_representation</a> <a href="#giza_set_colour_representation_rgba">giza_set_colour_representation_rgba</a> </p><h3><a name="giza_set_colour_representation_rgba">giza_set_colour_representation_rgba</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_representation_rgba</td><td> (int ci, int red, int green, int blue, double alpha) ;</tr></table><p>Same as giza_set_colour_representation_alpha but accepts 0->255 instead of 0->1</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ci :</td><td>Which colour index to set.</td>
</tr><tr>
<td>red :</td><td>The red component of the colour (between 0 and 255).</td>
</tr><tr>
<td>green :</td><td>The green component of the colour (between 0 and 255).</td>
</tr><tr>
<td>blue :</td><td>The blue component of the colour (between 0 and 255).</td>
</tr><tr>
<td>alpha :</td><td>The alpha component of the colour (between 0 and 1)</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_set_colour_representation_alpha">giza_set_colour_representation_alpha</a> <a href="#giza_set_colour_representation_rgb">giza_set_colour_representation_rgb</a> </p><h3><a name="giza_set_colour_representation_rgba_float">giza_set_colour_representation_rgba_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_representation_rgba_float</td><td> (int ci, int red, int green, int blue, float alpha) ;</tr></table><p>Same functionality as giza_set_colour_representation_rgba but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_set_colour_representation_rgba">giza_set_colour_representation_rgba</a> <a href="#giza_set_colour_representation_alpha">giza_set_colour_representation_alpha</a> </p><h3><a name="giza_get_colour_representation">giza_get_colour_representation</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_colour_representation</td><td> (int ci, double *red, double *green, double *blue) ;</tr></table><p>Query the RGB at a given colour index.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ci :</td><td>The index to enquire about</td>
</tr><tr>
<td>red :</td><td>Gets set to the red value at ci (range 0->1)</td>
</tr><tr>
<td>green :</td><td>Gets set to the green value at ci (range 0->1)</td>
</tr><tr>
<td>blue :</td><td>Gets set to the blue value at ci (range 0->1)</td>
</tr></table><h3><a name="giza_get_colour_representation_alpha">giza_get_colour_representation_alpha</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_colour_representation_alpha</td><td> (int ci, double *red, double *green, double *blue, double *alpha) ;</tr></table><p>Query the RGB and alpha at a given colour index.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ci :</td><td>The index to enquire about</td>
</tr><tr>
<td>red :</td><td>Gets set to the red value at ci</td>
</tr><tr>
<td>green :</td><td>Gets set to the green value at ci</td>
</tr><tr>
<td>blue :</td><td>Gets set to the blue value at ci</td>
</tr><tr>
<td>alpha :</td><td>Gets set to the alpha at ci</td>
</tr></table><h3><a name="giza_set_colour_index_range">giza_set_colour_index_range</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_index_range</td><td> (int cimin, int cimax) ;</tr></table><p>Set the range of colour indices that are affected by giza_set_colour_table</p>
<h4>Note:</h4>
<table class="api"></table><h4>Input:</h4>
<table class="api"><tr>
<td>cimin :</td><td>lowest colour index in range</td>
</tr><tr>
<td>cimax :</td><td>highest colour index in range</td>
</tr></table><h3><a name="giza_get_colour_index_range">giza_get_colour_index_range</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_colour_index_range</td><td> (int *cimin, int *cimax) ;</tr></table><p>Queries the current range of colour indices affected by giza_set_colour_table, as set by giza_set_colour_index_range</p>
<h4>Output:</h4>
<table class="api"><tr>
<td>cimin :</td><td>lowest colour index in range</td>
</tr><tr>
<td>cimax :</td><td>highest colour index in range</td>
</tr></table><h3><a name="giza_set_range_as_colour_table">giza_set_range_as_colour_table</a><hr></h3>
<table class="proto">
<tr><td width=10%>/*void</td><td width=20%>giza_set_range_as_colour_table</td><td> (int *cimin, int *cimax) ;</tr></table><p>Can be used in place of giza_set_colour_table to install the colour table from a predefined set of colour indices</p>
<h4>See Also:</h4><p><a href="#giza_set_colour_table">giza_set_colour_table</a> </p><h3><a name="giza_set_colour_palette">giza_set_colour_palette</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_colour_palette</td><td> (int palette) ;</tr></table><p>Choose between various preset colour "palettes" for the first 16 colour indices commonly used for point and line drawing. This is equivalent to using giza_set_colour_representation for each index in turn.</p>
<h4>Note:</h4>
<table class="api"></table><h4>Input:</h4>
<table class="api"><tr>
<td>palette :</td><td>choice of colour palette</td>
</tr></table><h4>Available palette options:</h4>
<table class="api"><tr>
<td>0 or GIZA_COLOUR_PALETTE_DEFAULT :</td><td>default giza palette</td>
</tr><tr>
<td>1 or GIZA_COLOUR_PALETTE_PGPLOT :</td><td>default PGPLOT palette</td>
</tr><tr>
<td>2 to 4 :</td><td>various experimental line palettes</td>
</tr><tr>
<td>5 :</td><td>colourblind safe palette from http://jfly.iam.u-tokyo.ac.jp/color/</td>
</tr><tr>
<td>6 :</td><td>optimum palette from http://web.media.mit.edu/~wad/color/palette.html</td>
</tr><tr>
<td>7 :</td><td>graph-a-licious See Also: giza_set_colour_index, giza_set_colour_table</td>
</tr></table><h3><a name="giza_set_colour_table">giza_set_colour_table</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_set_colour_table</td><td> (const double *controlPoints, const double *red, const double *green, const double *blue, int n, double contrast, double brightness) ;</tr></table><p>Sets the colour table.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>controlPoints :</td><td>Specifies at which fraction of the ramp the control points are placed</td>
</tr><tr>
<td>red :</td><td>the normalised value of the red component at each control point</td>
</tr><tr>
<td>green :</td><td>the normalised value of the green component at each control point</td>
</tr><tr>
<td>blue :</td><td>the normalised value of the blue component at each control point</td>
</tr><tr>
<td>n :</td><td>the number of control points</td>
</tr><tr>
<td>contrast :</td><td>contrast of colour ramp (normally 1.0). Use -contrast to reverse direction of ramp</td>
</tr><tr>
<td>brightness :</td><td>brightness of colour ramp (normally 0.5)</td>
</tr></table><h4>Return:</h4>
<table class="api"><tr>
<td>0 :</td><td>No error.</td>
</tr><tr>
<td>1 :</td><td>An error occurred.</td>
</tr></table><h3><a name="giza_set_colour_table_float">giza_set_colour_table_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_set_colour_table_float</td><td> (const float *controlPoints, const float *red, const float *green, const float *blue, int n, float contrast, float brightness) ;</tr></table><p>Same functionality as giza_set_colour_table but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_set_colour_table">giza_set_colour_table</a> </p><h3><a name="giza_rgb_from_table">giza_rgb_from_table</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_rgb_from_table</td><td> (double pos, double *red, double *green, double *blue) ;</tr></table><p>Gets the rgb values from the colour table corresponding to the fraction of the table.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>pos :</td><td>The fraction along the table to retrieve the colour from. A value less then 0 is assigned the colour at zero, and above one assigned the colour at one.</td>
</tr><tr>
<td>red :</td><td>Gets set to the red component of the colour at pos.</td>
</tr><tr>
<td>green :</td><td>Gets set to the green component of the colour at pos.</td>
</tr><tr>
<td>blue :</td><td>Gets set to the blue component of the colour at pos.</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_set_colour_table">giza_set_colour_table</a> </p><h3><a name="giza_rgb_from_table_float">giza_rgb_from_table_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_rgb_from_table_float</td><td> (float pos, float *red, float *green, float *blue) ;</tr></table><p>Same functionality giza_rgb_from_table but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_rgb_from_table">giza_rgb_from_table</a> <a href="#giza_set_colour_table">giza_set_colour_table</a> </p><h3><a name="giza_save_colour_table">giza_save_colour_table</a><hr></h3>
<table class="proto">
<tr><td width=10%>void </td><td width=20%>giza_save_colour_table</td><td> (void) ;</tr></table><p>Saves the current colour table</p>
<h4>See Also:</h4><p><a href="#giza_restore_colour_table">giza_restore_colour_table</a> </p><h3><a name="giza_restore_colour_table">giza_restore_colour_table</a><hr></h3>
<table class="proto">
<tr><td width=10%>void </td><td width=20%>giza_restore_colour_table</td><td> (void) ;</tr></table><p>Restores the colour table from a previously saved one</p>
<h4>See Also:</h4><p><a href="#giza_save_colour_table">giza_save_colour_table</a> </p><h3><a name="giza_set_environment">giza_set_environment</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_environment</td><td> (double xmin, double xmax, double ymin, double ymax, int just, int axis) ;</tr></table><p>Sets the plotting environment.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>xmin :</td><td>The min x value in world coords</td>
</tr><tr>
<td>xmax :</td><td>The max x value in world coords</td>
</tr><tr>
<td>ymin :</td><td>The min y value in world coords</td>
</tr><tr>
<td>ymax :</td><td>The max y value in world coords</td>
</tr><tr>
<td>just :</td><td>Give the x and y axis equal scales</td>
</tr><tr>
<td>axis :</td><td>Options for drawing axis, ticks etc.</td>
</tr></table><h4>Axis:</h4>
<table class="api"><tr>
<td>-4 :</td><td>draw box and major tick marks only</td>
</tr><tr>
<td>-3 :</td><td>draw box and tick marks (major and minor) only</td>
</tr><tr>
<td>-2 :</td><td>no axis, no box, no labels</td>
</tr><tr>
<td>-1 :</td><td>draw the box only</td>
</tr><tr>
<td>0 :</td><td>draw a box and label it with world coords</td>
</tr><tr>
<td>1 :</td><td>same as 0 but also draw the axis</td>
</tr><tr>
<td>2 :</td><td>same as 1 but also draw grid lines at major intervals</td>
</tr><tr>
<td>10 :</td><td>draw box and label X-axis logarithmically</td>
</tr><tr>
<td>20 :</td><td>draw box and label Y-axis logarithmically</td>
</tr><tr>
<td>30 :</td><td>draw box and label X- and Y-axis logarithmically</td>
</tr></table><h3><a name="giza_set_environment_float">giza_set_environment_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_environment_float</td><td> (float xmin, float xmax, float ymin, float ymax, int just, int axis) ;</tr></table><p>Same functionality as giza_set_environment but takes floats</p>
<h3><a name="giza_set_fill">giza_set_fill</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_fill</td><td> (int fs) ;</tr></table><p>Sets the current fill style.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>fs :</td><td>the new fill style</td>
</tr></table><h4>Fill Styles:</h4>
<table class="api"><tr>
<td>1 or GIZA_FILL_SOLID :</td><td>solid</td>
</tr><tr>
<td>2 or GIZA_FILL_HOLLOW :</td><td>hollow</td>
</tr><tr>
<td>3 or GIZA_FILL_HATCH :</td><td>hatch</td>
</tr><tr>
<td>4 or GIZA_FILL_CROSSHATCH :</td><td>crosshatch</td>
</tr></table><h3><a name="giza_get_fill">giza_get_fill</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_fill</td><td> (int *fs) ;</tr></table><p>Query the current fill style.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>fs :</td><td>gets set to the current fill style.</td>
</tr></table><h3><a name="giza_set_hatching_style">giza_set_hatching_style</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_hatching_style</td><td> (double angle, double spacing, double phase) ;</tr></table><p>Sets the hatching style when using GIZA_FILL_HATCH</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>angle :</td><td>the angle of the hatching pattern with respect to the horizontal</td>
</tr><tr>
<td>spacing :</td><td>the line spacing, in units of the default (1.0)</td>
</tr><tr>
<td>phase :</td><td>a number between 0.0 and 1.0 specifying the offset along the horizontal axis to start the hatching lines</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_fill">giza_fill</a> <a href="#giza_get_hatching_style">giza_get_hatching_style</a> </p><h3><a name="giza_set_hatching_style_float">giza_set_hatching_style_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_hatching_style_float</td><td> (float angle, float spacing, float phase) ;</tr></table><p>Same as giza_set_hatching_style, but takes floats</p>
<h3><a name="giza_get_hatching_style">giza_get_hatching_style</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_hatching_style</td><td> (double *angle, double *spacing, double *phase) ;</tr></table><p>Queries the current hatching style wgen using GIZA_FILL_HATCH</p>
<h4>Output:</h4>
<table class="api"><tr>
<td>angle :</td><td>the angle of the hatching pattern with respect to the horizontal</td>
</tr><tr>
<td>spacing :</td><td>the line spacing, in units of the default (1.0)</td>
</tr><tr>
<td>phase :</td><td>a number between 0.0 and 1.0 specifying the offset along the horizontal axis to start the hatching lines</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_fill">giza_fill</a> <a href="#giza_set_hatching_style">giza_set_hatching_style</a> </p><h3><a name="giza_get_hatching_style_float">giza_get_hatching_style_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_hatching_style_float</td><td> (float *angle, float *spacing, float *phase) ;</tr></table><p>Same as giza_get_hatching_style, but takes floats</p>
<h3><a name="giza_begin_autolog">giza_begin_autolog</a><hr></h3>
<table class="proto">
<tr><td width=10%>void giza_begin_autolog (void)</td><td width=20%></td><td>;</tr></table><p>Turns on automatic logging of interactive devices This writes a png file every time the page is changed in an interactive device, with a name based on the current date/time (giza-%Y-%M-%D-%H:%M:%S.png). Logging can also be turned on by setting the GIZA_LOG environment variable.</p>
<h4>See Also:</h4><p><a href="#giza_end_autolog">giza_end_autolog</a> </p><h3><a name="giza_end_autolog">giza_end_autolog</a><hr></h3>
<table class="proto">
<tr><td width=10%>void giza_end_autolog (void)</td><td width=20%></td><td>;</tr></table><p>Turns off automatic logging feature.</p>
<h4>See Also:</h4><p><a href="#giza_begin_autolog">giza_begin_autolog</a> </p><h3><a name="giza_set_line_cap">giza_set_line_cap</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_line_cap</td><td> (int lc) ;</tr></table><p>Sets the line cap.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>lc :</td><td>An integer representing the line cap.</td>
</tr></table><h4>Options:</h4>
<table class="api"><tr>
<td>0 :</td><td>butt</td>
</tr><tr>
<td>1 :</td><td>round</td>
</tr><tr>
<td>2 :</td><td>square</td>
</tr></table><h3><a name="giza_get_line_cap">giza_get_line_cap</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_line_cap</td><td> (int *lc) ;</tr></table><p>Gets the current line cap, as set by giza_set_line_cap.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>lc :</td><td>gets set to the current line cap.</td>
</tr></table><h3><a name="giza_set_line_style">giza_set_line_style</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_line_style</td><td> (int ls) ;</tr></table><p>Sets the current line style.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ls :</td><td>the new line style</td>
</tr></table><h4>Line Styles:</h4>
<table class="api"><tr>
<td>GIZA_LS_SOLID :</td><td>solid</td>
</tr><tr>
<td>GIZA_LS_LONG_DASH :</td><td>long dash</td>
</tr><tr>
<td>GIZA_LS_SHORT_DASH :</td><td>short dash</td>
</tr><tr>
<td>GIZA_LS_DOT :</td><td>dot</td>
</tr><tr>
<td>GIZA_LS_DASH_DOT :</td><td>dash dot</td>
</tr><tr>
<td>GIZA_LS_DASH_DOT_DOT_DOT :</td><td>dash dot dot dot</td>
</tr></table><h3><a name="giza_get_line_style">giza_get_line_style</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_line_style</td><td> (int *ls) ;</tr></table><p>Query the current line style.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>ls :</td><td>gets set to the current line style</td>
</tr></table><h3><a name="giza_set_line_width">giza_set_line_width</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_line_width</td><td> (double lw) ;</tr></table><p>Sets the line width for all subsequent drawing.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>lw :</td><td>The new line width. 1 is 1/4 of a millimetre.</td>
</tr></table><h3><a name="giza_set_line_width_float">giza_set_line_width_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_line_width_float</td><td> (float lw) ;</tr></table><p>Same functionality as giza_set_line_width but uses floats</p>
<h4>See Also:</h4><p><a href="#giza_set_line_width">giza_set_line_width</a> </p><h3><a name="giza_get_line_width">giza_get_line_width</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_line_width</td><td> (double *lw) ;</tr></table><p>Queries the current line width.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>lw :</td><td>gets set to the current line width.</td>
</tr></table><h3><a name="giza_start_prompting">giza_start_prompting</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_start_prompting</td><td> (void) ;</tr></table><p>Turns on prompting for current device, i.e. the user will be prompted before a page change or a device being closed.</p>
<h4>See Also:</h4><p><a href="#giza_stop_prompting">giza_stop_prompting</a> </p><h3><a name="giza_stop_prompting">giza_stop_prompting</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_stop_prompting</td><td> (void) ;</tr></table><p>Turns off prompting, i.e. the user will not be prompted before a page change or a device being closed.</p>
<h4>See Also:</h4><p><a href="#giza_start_prompting">giza_start_prompting</a> </p><h3><a name="giza_save">giza_save</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_save</td><td> (void) ;</tr></table><p>Saves current plot settings</p>
<h4>See Also:</h4><p><a href="#giza_restore">giza_restore</a> </p><h3><a name="giza_restore">giza_restore</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_restore</td><td> (void) ;</tr></table><p>Restores plot settings stored via giza_save</p>
<h4>See Also:</h4><p><a href="#giza_save">giza_save</a> </p><h3><a name="giza_set_font">giza_set_font</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_font</td><td> (const char *font) ;</tr></table><p>Sets the current font to the family specified in font, otherwise it is unchanged.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>font :</td><td>the font family to be used.</td>
</tr></table><h3><a name="giza_set_font_bold">giza_set_font_bold</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_font_bold</td><td> (const char *font) ;</tr></table><p>Sets the current font to the family specified in font, otherwise it is unchanged.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>font :</td><td>the font family to be used.</td>
</tr></table><h3><a name="giza_set_font_italic">giza_set_font_italic</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_font_italic</td><td> (const char *font) ;</tr></table><p>Sets the current font to the family specified in font, otherwise it is unchanged.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>font :</td><td>the font family to be used.</td>
</tr></table><h3><a name="giza_set_font_bold_italic">giza_set_font_bold_italic</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_font_bold_italic</td><td> (const char *font) ;</tr></table><p>Sets the current font to the family specified in font, otherwise it is unchanged.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>font :</td><td>the font family to be used.</td>
</tr></table><h3><a name="giza_get_font">giza_get_font</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_font</td><td> (char *font, int n) ;</tr></table><p>Sets the current font to the family specified in font, otherwise it is unchanged.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>font :</td><td>Gets set to the current font family</td>
</tr><tr>
<td>n :</td><td>The length of memory allocated to font</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_set_font">giza_set_font</a> </p><h3><a name="giza_set_text_background">giza_set_text_background</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_text_background</td><td> (int colourIndex) ;</tr></table><p>Set the colour index for the background of any text to be drawn. Use a negative value for a transparent background.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>colourIndex :</td><td>The colour index the background will be.</td>
</tr></table><h3><a name="giza_get_text_background">giza_get_text_background</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_text_background</td><td> (int *colourIndex) ;</tr></table><p>Queries the current text background colour</p>
<h4>Output:</h4>
<table class="api"><tr>
<td>colourIndex :</td><td>Current setting for the background text colour.</td>
</tr></table><h3><a name="giza_version">giza_version</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_version</td><td> (int *major, int *minor, int *micro) ;</tr></table><p>Returns the giza version. Note that version information can also be obtained using the header variables GIZA_VERSION_STRING, GIZA_VERSION_MAJOR, GIZA_VERSION_MINOR and GIZA_VERSION_MICRO. These are available in the Fortran interface also.</p>
<h4>Output:</h4>
<table class="api"><tr>
<td>major :</td><td>major version number</td>
</tr><tr>
<td>minor :</td><td>minor version number</td>
</tr><tr>
<td>micro :</td><td>micro version number</td>
</tr></table><h3><a name="giza_set_viewport">giza_set_viewport</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_viewport</td><td> (double xleft, double xright, double ybottom, double ytop) ;</tr></table><p>Changes the size and position of the viewport, all arguments are in normalised device coordinates. The viewport is the region of the device that can be drawn to.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>xleft :</td><td>The x coordinate of the left edge of the viewport</td>
</tr><tr>
<td>xright :</td><td>The x coordinate of the right edge of the viewport</td>
</tr><tr>
<td>ybottom :</td><td>The y coordinate of the bottom edge of the viewport</td>
</tr><tr>
<td>ytop :</td><td>The y coordinate of the top edge of the viewport</td>
</tr></table><h3><a name="giza_set_viewport_float">giza_set_viewport_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_viewport_float</td><td> (float xleft, float xright, float ybottom, float ytop) ;</tr></table><p>Same functionality as giza_set_viewport but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_set_viewport">giza_set_viewport</a> </p><h3><a name="giza_get_viewport">giza_get_viewport</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_viewport</td><td> (int units, double *x1, double *x2, double *y1, double *y2) ;</tr></table><p>Returns the viewport size and position.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>units :</td><td>specify the units to return values in.</td>
</tr><tr>
<td>x1 :</td><td>set to x-coord of upper-left corner</td>
</tr><tr>
<td>x2 :</td><td>set to x-coord of lower-right corner</td>
</tr><tr>
<td>y1 :</td><td>set to y-coord of upper-left corner</td>
</tr><tr>
<td>y2 :</td><td>set to y-coord of lower-right corner</td>
</tr></table><h4>Units:</h4>
<table class="api"><tr>
<td>0 or GIZA_UNITS_NORMALIZED :</td><td>normalised device units</td>
</tr><tr>
<td>1 or GIZA_UNITS_INCHES :</td><td>inches</td>
</tr><tr>
<td>2 or GIZA_UNITS_MM :</td><td>mm</td>
</tr><tr>
<td>3 or GIZA_UNITS_PIXELS :</td><td>pixels</td>
</tr><tr>
<td>5 or GIZA_UNITS_DEVICE :</td><td>device units (pixels or points)</td>
</tr><tr>
<td>default :</td><td>normalised device units</td>
</tr></table><h3><a name="giza_get_viewport_float">giza_get_viewport_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_viewport_float</td><td> (int units, float *x1, float *x2, float *y1, float *y2) ;</tr></table><p>Same functionality as giza_get_viewport but uses floats</p>
<h4>See Also:</h4><p><a href="#giza_get_viewport">giza_get_viewport</a> </p><h3><a name="giza_set_viewport_default">giza_set_viewport_default</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_viewport_default</td><td> (void) ;</tr></table><p>Sets the viewport to the default settings</p>
<h4>See Also:</h4><p><a href="#giza_set_viewport">giza_set_viewport</a> </p><h3><a name="giza_set_viewport_inches">giza_set_viewport_inches</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_viewport_inches</td><td> (double xleftin, double xrightin, double ybottomin, double ytopin) ;</tr></table><p>Sets the viewport size in inches</p>
<h4>See Also:</h4><p><a href="#giza_set_viewport">giza_set_viewport</a> </p><h3><a name="giza_set_viewport_inches_float">giza_set_viewport_inches_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_viewport_inches_float</td><td> (float xleftin, float xrightin, float ybottomin, float ytopin) ;</tr></table><p>Same as giza_set_viewport_inches but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_set_viewport_inches">giza_set_viewport_inches</a> </p><h3><a name="giza_start_warnings">giza_start_warnings</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_start_warnings</td><td> (void) ;</tr></table><p>Warnings will be printed to stderr.</p>
<h4>See Also:</h4><p><a href="#giza_stop_warnings">giza_stop_warnings</a> </p><h3><a name="giza_stop_warnings">giza_stop_warnings</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_stop_warnings</td><td> (void) ;</tr></table><p>Warnings will not be printed to stderr.</p>
<h4>See Also:</h4><p><a href="#giza_start_warnings">giza_start_warnings</a> </p><h3><a name="giza_set_window">giza_set_window</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_window</td><td> (double x1, double x2, double y1, double y2) ;</tr></table><p>Sets the limits of the axis.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x1 :</td><td>the lowest value of the x axis</td>
</tr><tr>
<td>x2 :</td><td>the highest value of the x axis</td>
</tr><tr>
<td>y1 :</td><td>the lowest value of the y axis</td>
</tr><tr>
<td>y2 :</td><td>the highest value of the y axis</td>
</tr></table><h3><a name="giza_set_window_float">giza_set_window_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_window_float</td><td> (float x1, float x2, float y1, float y2) ;</tr></table><p>Same functionality as giza_set_window but uses floats.</p>
<h4>See Also:</h4><p><a href="#giza_set_window">giza_set_window</a> </p><h3><a name="giza_set_window_equal_scale">giza_set_window_equal_scale</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_window_equal_scale</td><td> (double x1, double x2, double y1, double y2) ;</tr></table><p>Sets the window so the x axis ranges from x1 to x2 and y from y1 to y2, then adjusts the view port to the largest possible size that that allows the axis have equal scales.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x1 :</td><td>the lowest value of the x axis</td>
</tr><tr>
<td>x2 :</td><td>the highest value of the x axis</td>
</tr><tr>
<td>y1 :</td><td>the lowest value of the y axis</td>
</tr><tr>
<td>y2 :</td><td>the highest value of the y axis</td>
</tr></table><h3><a name="giza_set_window_equal_scale_float">giza_set_window_equal_scale_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_set_window_equal_scale_float</td><td> (float x1, float x2, float y1, float y2) ;</tr></table><p>Same functionality as giza_set_window_equal_scale but uses floats</p>
<h4>See Also:</h4><p><a href="#giza_set_window_equal_scale">giza_set_window_equal_scale</a> </p><h3><a name="giza_get_window">giza_get_window</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_window</td><td> (double *x1, double *x2, double *y1, double *y2) ;</tr></table><p>Query the boundaries of the window in world coords</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x1 :</td><td>Gets set to the lowest value of the x axis</td>
</tr><tr>
<td>x2 :</td><td>Gets set to the highest value of the x axis</td>
</tr><tr>
<td>y1 :</td><td>Gets set to the lowest value of the y axis</td>
</tr><tr>
<td>y2 :</td><td>Gets set to the highest value of the y axis</td>
</tr></table><h3><a name="giza_get_window_float">giza_get_window_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_get_window_float</td><td> (float *x1, float *x2, float *y1, float *y2) ;</tr></table><p>Same functionality as giza_get_window but uses floats</p>
<a name="Interactive"></a><h1>Interactive</h1>
<h3><a name="giza_band">giza_band</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_band</td><td> (int mode, int moveCurs, double xanc, double yanc, double *x, double *y, char *ch) ;</tr></table><p>Returns the cursor position and character typed by the user relative to an anchor point</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>mode :</td><td>selects the type of shape to draw during input</td>
</tr><tr>
<td>moveCurs :</td><td>if 1 the cursor is moved to (x, y), if 0 the cursor is not moved.</td>
</tr><tr>
<td>xanc :</td><td>the x-coord of the anchor point.</td>
</tr><tr>
<td>yanc :</td><td>the y-coord of the anchor point.</td>
</tr><tr>
<td>x :</td><td>Gets set to the x position of the cursor.</td>
</tr><tr>
<td>y :</td><td>Gets set to the y position of the cursor.</td>
</tr><tr>
<td>ch :</td><td>Gets set to the character pressed by the user.</td>
</tr></table><h4>Return:</h4>
<table class="api"><tr>
<td>1 :</td><td>The device has no cursor</td>
</tr><tr>
<td>0 :</td><td>The call was successful</td>
</tr></table><h4>Modes:</h4>
<table class="api"><tr>
<td>0 or GIZA_BAND_NONE :</td><td>None, behaves like giza_get_key_press</td>
</tr><tr>
<td>1 or GIZA_BAND_LINE :</td><td>Straight line drawn from anchor point</td>
</tr><tr>
<td>2 or GIZA_BAND_RECTANGLE :</td><td>Hollow rectangle</td>
</tr><tr>
<td>3 or GIZA_BAND_HORZLINES :</td><td>Two horizontal lines</td>
</tr><tr>
<td>4 or GIZA_BAND_VERTLINES :</td><td>Two vertical lines</td>
</tr><tr>
<td>5 or GIZA_BAND_HORZLINE :</td><td>Single horizontal line, ignores anchor point</td>
</tr><tr>
<td>6 or GIZA_BAND_VERTLINE :</td><td>Single vertical lines, ignores anchor point</td>
</tr><tr>
<td>7 or GIZA_BAND_CROSSHAIR :</td><td>Cross hair, ignores anchor point</td>
</tr><tr>
<td>8 or GIZA_BAND_CIRCLE :</td><td>Circle centred on anchor point</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_get_key_press">giza_get_key_press</a> </p><h3><a name="giza_band_float">giza_band_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_band_float</td><td> (int mode, int moveCurs, float xanc, float yanc, float *x, float *y, char *ch) ;</tr></table><p>Same functionality as giza_band, but uses floats.</p>
<h4>See Also:</h4><p><a href="#giza_band">giza_band</a> </p><h3><a name="giza_mark_points">giza_mark_points</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_mark_points</td><td> (int maxpts, int *npts, double* xpts, double* ypts, int symbol) ;</tr></table><p>Mark a set of points using the cursor</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>maxpts :</td><td>maximum number of points that may be accepted</td>
</tr><tr>
<td>symbol :</td><td>symbol code for drawing points</td>
</tr></table><h4>Input/Output:</h4>
<table class="api"><tr>
<td>xpts :</td><td>the x-coord of the points</td>
</tr><tr>
<td>ypts :</td><td>the y-coord of the anchor point.</td>
</tr><tr>
<td>npts :</td><td>number of points entered, should be zero on first call</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_points">giza_points</a> </p><h3><a name="giza_mark_points_float">giza_mark_points_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_mark_points_float</td><td> (int maxpts, int *npts, float* xpts, float* ypts, int symbol) ;</tr></table><p>Same functionality as giza_mark_points, but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_mark_points">giza_mark_points</a> </p><h3><a name="giza_mark_points_ordered">giza_mark_points_ordered</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_mark_points_ordered</td><td> (int maxpts, int *npts, double* xpts, double* ypts, int symbol) ;</tr></table><p>Mark a set of points using the cursor</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>maxpts :</td><td>maximum number of points that may be accepted</td>
</tr><tr>
<td>symbol :</td><td>symbol code for drawing points</td>
</tr></table><h4>Input/Output:</h4>
<table class="api"><tr>
<td>xpts :</td><td>the x-coord of the points</td>
</tr><tr>
<td>ypts :</td><td>the y-coord of the anchor point.</td>
</tr><tr>
<td>npts :</td><td>number of points entered, should be zero on first call</td>
</tr></table><h4>Note:</h4>
<table class="api"></table><h4>See Also:</h4><p><a href="#giza_points">giza_points</a> </p><h3><a name="giza_mark_points_ordered_float">giza_mark_points_ordered_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_mark_points_ordered_float</td><td> (int maxpts, int *npts, float* xpts, float* ypts, int symbol) ;</tr></table><p>Same functionality as giza_mark_points_ordered, but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_mark_points">giza_mark_points</a> </p><h3><a name="giza_mark_line">giza_mark_line</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_mark_line</td><td> (int maxpts, int *npts, double* xpts, double* ypts) ;</tr></table><p>Mark a set of points using the cursor</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>maxpts :</td><td>maximum number of points that may be accepted</td>
</tr></table><h4>Input/Output:</h4>
<table class="api"><tr>
<td>xpts :</td><td>the x-coord of the points</td>
</tr><tr>
<td>ypts :</td><td>the y-coord of the anchor point.</td>
</tr><tr>
<td>npts :</td><td>number of points entered, should be zero on first call</td>
</tr></table><h4>See Also:</h4><p><a href="#giza_mark_points">giza_mark_points</a> </p><h3><a name="giza_mark_points_float">giza_mark_points_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_mark_line_float</td><td> (int maxpts, int *npts, float* xpts, float* ypts) ;</tr></table><p>Same functionality as giza_mark_line, but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_mark_line">giza_mark_line</a> <a href="#giza_mark_points">giza_mark_points</a> <a href="#giza_mark_line_ordered">giza_mark_line_ordered</a> </p><h3><a name="giza_mark_line_ordered">giza_mark_line_ordered</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_mark_line_ordered</td><td> (int maxpts, int *npts, double* xpts, double* ypts) ;</tr></table><p>Mark a set of points using the cursor</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>maxpts :</td><td>maximum number of points that may be accepted</td>
</tr></table><h4>Input/Output:</h4>
<table class="api"><tr>
<td>xpts :</td><td>the x-coord of the points</td>
</tr><tr>
<td>ypts :</td><td>the y-coord of the anchor point.</td>
</tr><tr>
<td>npts :</td><td>number of points entered, should be zero on first call</td>
</tr></table><h4>Note:</h4>
<table class="api"></table><h4>See Also:</h4><p><a href="#giza_mark_line">giza_mark_line</a> <a href="#giza_mark_points">giza_mark_points</a> </p><h3><a name="giza_mark_line_ordered_float">giza_mark_line_ordered_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_mark_line_ordered_float</td><td> (int maxpts, int *npts, float* xpts, float* ypts) ;</tr></table><p>Same functionality as giza_mark_line_ordered, but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_mark_points">giza_mark_points</a> </p><h3><a name="giza_mark_line_char">giza_mark_line_char</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_mark_line_char</td><td> (int maxpts, int *npts, double* xpts, double* ypts, char *ch) ;</tr></table><p>Same functionality as giza_mark_line, but also returns last character pressed</p>
<h4>See Also:</h4><p><a href="#giza_mark_line">giza_mark_line</a> </p><h3><a name="giza_mark_points_float">giza_mark_points_float</a><hr></h3>
<table class="proto">
<tr><td width=10%>void</td><td width=20%>giza_mark_line_char_float</td><td> (int maxpts, int *npts, float* xpts, float* ypts, char *ch) ;</tr></table><p>Same functionality as giza_mark_line, but takes floats</p>
<h4>See Also:</h4><p><a href="#giza_mark_line">giza_mark_line</a> <a href="#giza_mark_points">giza_mark_points</a> <a href="#giza_mark_line_ordered">giza_mark_line_ordered</a> </p><h3><a name="giza_get_key_press">giza_get_key_press</a><hr></h3>
<table class="proto">
<tr><td width=10%>int</td><td width=20%>giza_get_key_press</td><td> (double *x, double *y, char *ch) ;</tr></table><p>Returns the cursor position and key press after a key press.</p>
<h4>Input:</h4>
<table class="api"><tr>
<td>x :</td><td>Gets set to the x world coord of the cursor.</td>
</tr><tr>
<td>y :</td><td>Gets set to the y world coord of the cursor.</td>
</tr><tr>
<td>ch :</td><td>Gets set to the character pressed.</td>
</tr></table><h4>Return value:</h4>
<table class="api"><tr>
<td>0 :</td><td>If the call was successful</td>
</tr><tr>
<td>1 :</td><td>If the device has no cursor</td>
</tr></table>
|
