Module gwy
[hide private]
[frames] | no frames]

Source Code for Module gwy

    1  # This is dummy GENERATED file used for generation of documentation 
2 -class Axis:
3 - def __init__( orientation ):
4 """ 5 Creates a new axis. 6 7 8 @return: New axis as a B{C{GtkWidget}}. 9 10 """ 11 return None
12 - def set_logarithmic( is_logarithmic ):
13 """ 14 Sets logarithmic mode. 15 16 @param is_logarithmic: logarithmic mode I{(bool)} 17 @return: 18 """ 19 return None
20 - def set_visible( is_visible ):
21 """ 22 Sets the visibility of an axis. 23 24 @param is_visible: visibility I{(bool)} 25 @return: 26 """ 27 return None
28 - def is_visible( ):
29 """ 30 Determines whether axis is set to be visible. 31 32 Return: B{C{True}} if B{C{axis}} is set to be visible. 33 34 @return: 35 """ 36 return None
37 - def is_logarithmic( ):
38 """ 39 Determines whether axis is set to be locarithmic. 40 41 42 @return: B{C{True}} if B{C{axis}} is logarithmic. 43 44 """ 45 return None
46 - def get_orientation( ):
47 """ 48 Gets the orientation of an axis. 49 50 51 @return: The orientation. 52 53 """ 54 return None
55 - def set_auto( is_auto ):
56 """ 57 Enables or disables automatic axis adjustmet. 58 59 @param is_auto: B{C{True}} to enable automatic tick size and distribution adjustment, 60 B{C{False}} to disable it. I{(bool)} 61 @return: 62 """ 63 return None
64 - def request_range( min , max ):
65 """ 66 Sets the requisition of axis boundaries. 67 68 The axis will adjust the boundaries to satisfy requisition but still have 69 reasonable tick values and spacing. Use L{Axis.get_range}() to obtain the 70 boundaries the axis actually decided to use. 71 72 @param min: Minimum requisition (min boundary value). I{(float)} 73 @param max: Maximum requisition (max boundary value). I{(float)} 74 @return: 75 """ 76 return None
77 - def get_range( min , max ):
78 """ 79 Gets the actual boundaries of an axis. 80 81 @param min: Location to store actual axis minimum, or B{C{NULL}}. I{(float)} 82 @param max: Location to store actual axis maximum, or B{C{NULL}}. I{(float)} 83 @return: 84 """ 85 return None
86 - def get_requested_range( min , max ):
87 """ 88 Gets the requested boundaries of an axis. 89 90 @param min: Location to store requested axis minimum, or B{C{NULL}}. I{(float)} 91 @param max: Location to store requested axis maximum, or B{C{NULL}}. I{(float)} 92 @return: 93 """ 94 return None
95 - def get_magnification( ):
96 """ 97 98 @return: Magnification value of the axis 99 100 """ 101 return None
103 """ 104 Gets the magnification string of an axis. 105 106 107 @return: Magnification string of the axis, owned by the axis. 108 109 """ 110 return None
111 - def set_label( label ):
112 """ 113 Sets the label text of an axis. 114 115 @param label: The new label text (it can be B{C{NULL}} for an empty label). I{(string)} 116 @return: 117 """ 118 return None
119 - def get_label( ):
120 """ 121 Gets the label of an axis. 122 123 124 @return: Axis label as a string owned by B{C{axis}}. 125 126 """ 127 return None
128 - def set_si_unit( unit ):
129 """ 130 Sets the axis unit. This will be added automatically 131 to the label. B{C{unit}} is duplicated. 132 133 @param unit: axis unit I{(L{SIUnit})} 134 @return: 135 """ 136 return None
137 - def enable_label_edit( enable ):
138 """ 139 Enables/disables user to change axis label by clicking on axis widget. 140 141 @param enable: enable/disable user to change axis label I{(bool)} 142 @return: 143 """ 144 return None
145 - def draw_on_drawable( drawable , gc , xmin , ymin , width , height ):
146 """ 147 Draws the x and y-axis on a drawable 148 149 @param drawable: Drawable to draw on. I{(GdkDrawable*)} 150 @param gc: Graphics context. 151 It is modified by this function unpredictably. I{(GdkGC*)} 152 @param xmin: The minimum x-axis value. I{(int)} 153 @param ymin: The minimum y-axis value. I{(int)} 154 @param width: The width of the x-axis. I{(int)} 155 @param height: The height of the y-axis. I{(int)} 156 @return: 157 """ 158 return None
159 - def UNIMPLEMENTED_export_vector( xmin , ymin , width , height , fontsize ):
160 """ 161 162 @param xmin: I{(int)} 163 @param ymin: I{(int)} 164 @param width: width of the x-axis I{(int)} 165 @param height: hieght of the y-axis I{(int)} 166 @param fontsize: I{(int)} 167 @return: 168 """ 169 return None
170 - def get_major_ticks( nticks ):
171 """ 172 Gets the positions of major ticks of an axis. 173 174 175 @param nticks: Location to store the number of returned ticks. I{(int)} 176 @return: The positions of axis major ticks (as real values, not pixels). 177 The returned array is owned by the axis. 178 179 """ 180 return None
181 -class Brick:
182 - def __init__( xres , yres , zres , xreal , yreal , zreal , nullme ):
183 """ 184 Creates a new data brick. 185 186 Since: 2.31 187 188 @param xres: Y resolution, i.e., the number of samples in y direction I{(int)} 189 @param xres: Z resolution, i.e., the number of samples in z direction I{(int)} 190 @param xreal: Real physical dimension in x direction. I{(float)} 191 @param yreal: Real physical dimension in y direction. I{(float)} 192 @param zreal: Real physical dimension in z direction. I{(float)} 193 @param nullme: Whether the data brick should be initialized to zeroes. If B{C{False}}, 194 the data will not be initialized. I{(bool)} 195 @return: A newly created data brick. 196 197 198 """ 199 return None
200 - def new_alike( nullme ):
201 """ 202 Creates a new data brick similar to an existing one. 203 204 Use L{Brick.duplicate}() if you want to copy a data brick including 205 data. 206 207 Since: 2.31 208 209 @param nullme: Whether the data brick should be initialized to zeroes. If B{C{False}}, 210 the data will not be initialized. I{(bool)} 211 @return: A newly created data brick. 212 213 214 """ 215 return None
216 - def new_part( xpos , ypos , zpos , xres , yres , zres , keep_offsets ):
217 """ 218 Creates a new data brick as a part of existing one. 219 220 Use L{Brick.duplicate}() if you want to copy a whole data brick. 221 222 Since: 2.32 223 224 @param xpos: x position where to start from I{(int)} 225 @param ypos: y position where to start from I{(int)} 226 @param zpos: z position where to start from I{(int)} 227 @param xres: x resolution (width) to be extracted I{(int)} 228 @param yres: y resolution (height) to be extracted I{(int)} 229 @param zres: z resolution (depth) to be extracted I{(int)} 230 @param keep_offsets: keep offsets of data during extraction I{(bool)} 231 @return: A newly created data brick. 232 233 234 """ 235 return None
236 - def data_changed( ):
237 """ 238 Emits signal "data_changed" on a data brick. 239 240 Since: 2.31 241 242 @return: 243 """ 244 return None
245 - def resample( xres , yres , zres , interpolation ):
246 """ 247 Resamples a data brick. 248 249 In other words changes the size of three dimensional field related with data 250 brick. The original values are used for resampling using a requested 251 interpolation alorithm. 252 253 Since: 2.31 254 255 @param xres: Desired x resolution. I{(int)} 256 @param yres: Desired y resolution. I{(int)} 257 @param zres: Desired z resolution. I{(int)} 258 @param interpolation: Interpolation method to use. I{(InterpolationType)} 259 @return: 260 """ 261 return None
262 - def get_xres( ):
263 """ 264 Gets the x resolution of a data brick. 265 266 Since: 2.31 267 268 @return: Resolution (number of data points). 269 270 271 """ 272 return None
273 - def get_yres( ):
274 """ 275 Gets the y resolution of a data brick. 276 277 Since: 2.31 278 279 @return: Resolution (number of data points). 280 281 282 """ 283 return None
284 - def get_zres( ):
285 """ 286 Gets the z resolution of a data brick. 287 288 Since: 2.31 289 290 @return: Resolution (number of data points). 291 292 293 """ 294 return None
295 - def get_xreal( ):
296 """ 297 Gets the physical size of a data brick in the x direction. 298 299 Since: 2.31 300 301 @return: Real size of a data brick the x direction. 302 303 304 """ 305 return None
306 - def get_yreal( ):
307 """ 308 Gets the physical size of a data brick in the y direction. 309 310 Since: 2.31 311 312 @return: Real size of a data brick the y direction. 313 314 315 """ 316 return None
317 - def get_zreal( ):
318 """ 319 Gets the physical size of a data brick in the z direction. 320 321 Since: 2.31 322 323 @return: Real size of a data brick the z direction. 324 325 326 """ 327 return None
328 - def get_xoffset( ):
329 """ 330 Gets the offset of data brick origin in x direction. 331 332 Since: 2.31 333 334 @return: Offset value. 335 336 337 """ 338 return None
339 - def get_yoffset( ):
340 """ 341 Gets the offset of data brick origin in y direction. 342 343 Since: 2.31 344 345 @return: Offset value. 346 347 348 """ 349 return None
350 - def get_zoffset( ):
351 """ 352 Gets the offset of data brick origin in z direction. 353 354 Since: 2.31 355 356 @return: Offset value. 357 358 359 """ 360 return None
361 - def get_data_const( ):
362 """ 363 Gets the raw data buffer of a data brick, read-only. 364 365 The returned buffer is not guaranteed to be valid through whole data 366 brick life time. Some function may change it, most notably 367 L{Brick.resize}() and L{Brick.resample}(). 368 369 Use L{Brick.get_data}() if you want to change the data. 370 371 Since: 2.31 372 373 @return: The data as an array of doubles of length L{Brick.get_res}(). 374 375 376 """ 377 return None
378 - def set_xreal( xreal ):
379 """ 380 Sets the real x dimension of a brick. 381 382 Since: 2.31 383 384 @param xreal: New real x dimensions value I{(float)} 385 @return: 386 """ 387 return None
388 - def set_yreal( yreal ):
389 """ 390 Sets the real y dimension of a brick. 391 392 Since: 2.31 393 394 @param yreal: New real y dimensions value I{(float)} 395 @return: 396 """ 397 return None
398 - def set_zreal( zreal ):
399 """ 400 Sets the real z dimension of a brick. 401 402 Since: 2.31 403 404 @param zreal: New real z dimensions value I{(float)} 405 @return: 406 """ 407 return None
408 - def set_xoffset( xoffset ):
409 """ 410 Sets the offset of a data brick origin in the x direction. 411 412 Note offsets don't affect any calculation, nor functions like 413 L{Brick.rtoi}(). 414 415 Since: 2.31 416 417 @param xoffset: New offset value. I{(float)} 418 @return: 419 """ 420 return None
421 - def set_yoffset( yoffset ):
422 """ 423 Sets the offset of a data brick origin in the y direction. 424 425 Note offsets don't affect any calculation, nor functions like 426 L{Brick.rtoi}(). 427 428 Since: 2.31 429 430 @param yoffset: New offset value. I{(float)} 431 @return: 432 """ 433 return None
434 - def set_zoffset( zoffset ):
435 """ 436 Sets the offset of a data brick origin in the z direction. 437 438 Note offsets don't affect any calculation, nor functions like 439 L{Brick.rtoi}(). 440 441 Since: 2.31 442 443 @param zoffset: New offset value. I{(float)} 444 @return: 445 """ 446 return None
447 - def get_si_unit_x( ):
448 """ 449 Returns x direction SI unit of a data brick. 450 451 Since: 2.31 452 453 @return: SI unit corresponding to the lateral (X) dimension of the data 454 brick. Its reference count is not incremented. 455 456 457 """ 458 return None
459 - def get_si_unit_y( ):
460 """ 461 Returns y direction SI unit of a data brick. 462 463 Since: 2.31 464 465 @return: SI unit corresponding to the lateral (Y) dimension of the data 466 brick. Its reference count is not incremented. 467 468 469 """ 470 return None
471 - def get_si_unit_z( ):
472 """ 473 Returns z direction SI unit of a data brick. 474 475 Since: 2.31 476 477 @return: SI unit corresponding to the "height" (Z) dimension of the data 478 brick. Its reference count is not incremented. 479 480 481 """ 482 return None
483 - def get_si_unit_w( ):
484 """ 485 Returns value SI unit of a data brick. 486 487 Since: 2.31 488 489 @return: SI unit corresponding to the "value" of the data 490 brick. Its reference count is not incremented. 491 492 493 """ 494 return None
495 - def set_si_unit_x( si_unit ):
496 """ 497 Sets the SI unit corresponding to the lateral (X) dimension of a data 498 brick. 499 500 It does not assume a reference on B{C{si_unit}}, instead it adds its own 501 reference. 502 503 Since: 2.31 504 505 @param si_unit: SI unit to be set. I{(L{SIUnit})} 506 @return: 507 """ 508 return None
509 - def set_si_unit_y( si_unit ):
510 """ 511 Sets the SI unit corresponding to the lateral (Y) dimension of a data 512 brick. 513 514 It does not assume a reference on B{C{si_unit}}, instead it adds its own 515 reference. 516 517 Since: 2.31 518 519 @param si_unit: SI unit to be set. I{(L{SIUnit})} 520 @return: 521 """ 522 return None
523 - def set_si_unit_z( si_unit ):
524 """ 525 Sets the SI unit corresponding to the "height" (Z) dimension of a data 526 brick. 527 528 It does not assume a reference on B{C{si_unit}}, instead it adds its own 529 reference. 530 531 Since: 2.31 532 533 @param si_unit: SI unit to be set. I{(L{SIUnit})} 534 @return: 535 """ 536 return None
537 - def set_si_unit_w( si_unit ):
538 """ 539 Sets the SI unit corresponding to the "value" of a data 540 brick. 541 542 It does not assume a reference on B{C{si_unit}}, instead it adds its own 543 reference. 544 545 Since: 2.31 546 547 @param si_unit: SI unit to be set. I{(L{SIUnit})} 548 @return: 549 """ 550 return None
551 - def get_min( ):
552 """ 553 Since: 2.31 554 555 @return: The minimum value within the brick. 556 557 558 """ 559 return None
560 - def get_max( ):
561 """ 562 Since: 2.31 563 564 @return: The maximum value within the brick. 565 566 567 """ 568 return None
569 - def UNIMPLEMENTED_get_value_format_x( style , format ):
570 """ 571 Finds value format good for displaying coordinates of a data brick. 572 573 Since: 2.31 574 575 @param style: Unit format style. I{(SIUnitFormatStyle)} 576 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 577 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 578 is returned, otherwise (modified) B{C{format}} itself is returned. 579 580 581 """ 582 return None
583 - def UNIMPLEMENTED_get_value_format_y( style , format ):
584 """ 585 Finds value format good for displaying values of a data brick. 586 587 Since: 2.31 588 589 @param style: Unit format style. I{(SIUnitFormatStyle)} 590 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 591 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 592 is returned, otherwise (modified) B{C{format}} itself is returned. 593 594 595 """ 596 return None
597 - def UNIMPLEMENTED_get_value_format_z( style , format ):
598 """ 599 Finds value format good for displaying values of a data brick. 600 601 Since: 2.31 602 603 @param style: Unit format style. I{(SIUnitFormatStyle)} 604 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 605 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 606 is returned, otherwise (modified) B{C{format}} itself is returned. 607 608 609 """ 610 return None
611 - def UNIMPLEMENTED_get_value_format_w( style , format ):
612 """ 613 Finds value format good for displaying values of a data brick. 614 615 Note this functions searches for minimum and maximum value in B{C{brick}}, 616 therefore it's relatively slow. 617 618 Since: 2.31 619 620 @param style: Unit format style. I{(SIUnitFormatStyle)} 621 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 622 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 623 is returned, otherwise (modified) B{C{format}} itself is returned. 624 625 626 """ 627 return None
628 - def get_data( ):
629 """ 630 Gets the raw data buffer of a data brick. 631 632 The returned buffer is not guaranteed to be valid through whole data 633 brick life time. Some function may change it, most notably 634 L{Brick.resize}() and L{Brick.resample}(). 635 636 This function invalidates any cached information, use 637 L{Brick.get_data_const}() if you are not going to change the data. 638 639 Since: 2.31 640 641 @return: The data as an array of doubles of length L{Brick.get_res}(). 642 643 644 """ 645 return None
646 - def itor( pixpos ):
647 """ 648 Transforms pixel coordinate to real (physical) coordinate in x direction. 649 650 That is it maps range [0..x resolution] to range [0..x real-size]. It is not 651 suitable for conversion of matrix indices to physical coordinates, you 652 have to use L{Brick.itor}(B{C{brick}}, B{C{pixpos}} + 0.5) for that. 653 654 Since: 2.31 655 656 @param pixpos: Pixel coordinate. I{(float)} 657 @return: B{C{pixpos}} in real coordinates. 658 659 660 """ 661 return None
662 - def rtoi( realpos ):
663 """ 664 Transforms real (physical) coordinate to pixel coordinate in x axis. 665 666 That is it maps range [0..x real-size] to range [0..x resolution]. 667 668 Since: 2.31 669 670 @param realpos: Real coordinate. I{(float)} 671 @return: B{C{realpos}} in pixel coordinates. 672 673 674 """ 675 return None
676 - def jtor( pixpos ):
677 """ 678 Transforms pixel coordinate to real (physical) coordinate in y direction. 679 680 That is it maps range [0..y resolution] to range [0..y real-size]. It is not 681 suitable for conversion of matrix indices to physical coordinates, you 682 have to use L{Brick.itor}(B{C{brick}}, B{C{pixpos}} + 0.5) for that. 683 684 Since: 2.31 685 686 @param pixpos: Pixel coordinate. I{(float)} 687 @return: B{C{pixpos}} in real coordinates. 688 689 690 """ 691 return None
692 - def rtoj( realpos ):
693 """ 694 Transforms real (physical) coordinate to pixel coordinate in y axis. 695 696 That is it maps range [0..y real-size] to range [0..y resolution]. 697 698 Since: 2.31 699 700 @param realpos: Real coordinate. I{(float)} 701 @return: B{C{realpos}} in pixel coordinates. 702 703 704 """ 705 return None
706 - def ktor( pixpos ):
707 """ 708 Transforms pixel coordinate to real (physical) coordinate. 709 710 That is it maps range [0..z resolution] to range [0..z real-size]. It is not 711 suitable for conversion of matrix indices to physical coordinates, you 712 have to use L{Brick.itor}(B{C{brick}}, B{C{pixpos}} + 0.5) for that. 713 714 Since: 2.31 715 716 @param pixpos: Pixel coordinate. I{(float)} 717 @return: B{C{pixpos}} in real coordinates. 718 719 720 """ 721 return None
722 - def rtok( realpos ):
723 """ 724 Transforms real (physical) coordinate to pixel coordinate in z axis. 725 726 That is it maps range [0..z real-size] to range [0..z resolution]. 727 728 Since: 2.31 729 730 @param realpos: Real coordinate. I{(float)} 731 @return: B{C{realpos}} in pixel coordinates. 732 733 734 """ 735 return None
736 - def get_val( col , row , lev ):
737 """ 738 Gets value at given position in a data brick. 739 740 Do not access data with this function inside inner loops, it's slow. 741 Get raw data buffer with L{Brick.get_data_const}() and access it 742 directly instead. 743 744 Since: 2.31 745 746 @param col: Position in the brick (column index). I{(int)} 747 @param row: Position in the brick (row index). I{(int)} 748 @param lev: Position in the brick (level index). I{(int)} 749 @return: Value at given index. 750 751 752 """ 753 return None
754 - def set_val( col , row , lev , value ):
755 """ 756 Sets value at given position in a data brick. 757 758 Do not access data with this function inside inner loops, it's slow. 759 Get raw data buffer with L{Brick.get_data_const}() and access it 760 directly instead. 761 762 Since: 2.31 763 764 @param col: Position in the brick (column index). I{(int)} 765 @param row: Position in the brick (row index). I{(int)} 766 @param lev: Position in the brick (level index). I{(int)} 767 @param value: value to be set. I{(float)} 768 @return: 769 """ 770 return None
771 - def get_val_real( x , y , z ):
772 """ 773 Gets value at given position in a data brick, in real coordinates. 774 775 Do not access data with this function inside inner loops, it's slow. 776 Get raw data buffer with L{Brick.get_data_const}() and access it 777 directly instead. 778 779 Since: 2.31 780 781 @param x: Position in the brick (x direction). I{(float)} 782 @param y: Position in the brick (y direction). I{(float)} 783 @param z: Position in the brick (z direction). I{(float)} 784 @return: Value at given index. 785 786 787 """ 788 return None
789 - def set_val_real( x , y , z , value ):
790 """ 791 Sets value at given position in a data brick. 792 793 Do not access data with this function inside inner loops, it's slow. 794 Get raw data buffer with L{Brick.get_data_const}() and access it 795 directly instead. 796 797 Since: 2.31 798 799 @param x: Position in the brick (x direction). I{(float)} 800 @param y: Position in the brick (y direction). I{(float)} 801 @param z: Position in the brick (z direction). I{(float)} 802 @return: 803 """ 804 return None
805 - def get_dval( x , y , z , interpolation ):
806 """ 807 Gets interpolated value at arbitrary data brick point indexed by pixel 808 coordinates. 809 810 Note pixel values are centered in intervals [B{C{i}}, B{C{i}}+1]. 811 See also L{Brick.get_dval_real}() that does the same, but takes 812 real coordinates. 813 814 Since: 2.31 815 816 @param x: Position in data brick in range [0, x resolution]. If the value is outside 817 this range, the nearest border value is returned. I{(float)} 818 @param y: Position in data brick in range [0, y resolution]. If the value is outside 819 this range, the nearest border value is returned. I{(float)} 820 @param z: Position in data brick in range [0, z resolution]. If the value is outside 821 this range, the nearest border value is returned. I{(float)} 822 @param interpolation: Interpolation method to use. I{(int)} 823 @return: Value interpolated in the data brick. 824 825 826 """ 827 return None
828 - def get_dval_real( x , y , z , interpolation ):
829 """ 830 Gets interpolated value at arbitrary data brick point indexed by pixel 831 coordinates. 832 833 Note pixel values are centered in intervals [B{C{j}}, B{C{j}}+1]. 834 See also L{Brick.get_dval}() that does the same, but takes 835 pixel coordinates. 836 837 Since: 2.31 838 839 @param x: Position in data brick in range [0, x resolution]. If the value is outside 840 this range, the nearest border value is returned. I{(float)} 841 @param y: Position in data brick in range [0, y resolution]. If the value is outside 842 this range, the nearest border value is returned. I{(float)} 843 @param z: Position in data brick in range [0, z resolution]. If the value is outside 844 this range, the nearest border value is returned. I{(float)} 845 @param interpolation: Interpolation method to use. I{(int)} 846 @return: Value interpolated in the data brick. 847 848 849 """ 850 return None
851 - def clear( ):
852 """ 853 Fills a data brick with zeroes. 854 855 Since: 2.31 856 857 @return: 858 """ 859 return None
860 - def fill( value ):
861 """ 862 Fills a data brick with specified value. 863 864 Since: 2.31 865 866 @param value: Value to fill data brick with. I{(float)} 867 @return: 868 """ 869 return None
870 - def multiply( value ):
871 """ 872 Multiplies all values in a data brick with a specified value. 873 874 Since: 2.31 875 876 @param value: Value to multiply data brick with. I{(float)} 877 @return: 878 """ 879 return None
880 - def add( value ):
881 """ 882 Adds a specified value to all values in a data brick. 883 884 Since: 2.31 885 886 @param value: Value to be added. I{(float)} 887 @return: 888 """ 889 return None
890 - def extract_plane( target , istart , jstart , kstart , width , height , depth , keep_offsets ):
891 """ 892 Extract a plane (DataField) from the brick. One value of set (B{C{width}}, B{C{height}}, B{C{depth}}) needs 893 to be -1, determining the plane orientation. 894 895 Since: 2.31 896 897 @param target: Datafield to be filled by extracted plane. It will be resampled if necessary. I{(L{DataField})} 898 @param istart: column where to start (pixel coordinates). I{(int)} 899 @param jstart: row where to start (pixel coordinates). I{(int)} 900 @param kstart: level where to start (pixel coordinates). I{(int)} 901 @param width: pixel width of extracted plane. If B{C{width}} is -1, the yz plane will be extracted. I{(int)} 902 @param height: pixel height of extracted plane. If B{C{height}} is -1, the xz plane will be extracted I{(int)} 903 @param depth: pixel depth of extacted plane. If B{C{depth}} is -1, the xy plane will be extracted I{(int)} 904 @param keep_offsets: keep the physical offsets in extracted field. I{(bool)} 905 @return: 906 """ 907 return None
908 - def sum_plane( target , istart , jstart , kstart , width , height , depth , keep_offsets ):
909 """ 910 Sums planes in certain direction and extract the result (DataField). One 911 value of set (B{C{width}}, B{C{height}}, B{C{depth}}) needs to be -1, determining the plane 912 orientation. In contrast to L{Brick.extract_plane}, the appropriate start 913 coordinate (e.g. B{C{istart}} if B{C{width}} = -1) is not used for single plane 914 extraction, but the planes are accumulated in whole range (0..xres for given 915 example) 916 917 Since: 2.31 918 919 @param target: Datafield to be filled by summed plane. It will be resampled if 920 necessary. I{(L{DataField})} 921 @param istart: column where to start (pixel coordinates). I{(int)} 922 @param jstart: row where to start (pixel coordinates). I{(int)} 923 @param kstart: level where to start (pixel coordinates). I{(int)} 924 @param width: pixel width of summed plane. If B{C{width}} is -1, the yz planes will be 925 summed. I{(int)} 926 @param height: pixel height of summed plane. If B{C{height}} is -1, the xz planes will 927 be summed I{(int)} 928 @param depth: pixel depth of extacted plane. If B{C{depth}} is -1, the xy planes will 929 be summed I{(int)} 930 @param keep_offsets: keep the physical offsets in extracted field. Not 931 implemented. I{(bool)} 932 @return: 933 """ 934 return None
935 - def min_plane( target , istart , jstart , kstart , width , height , depth , keep_offsets ):
936 """ 937 Finds minima of planes in certain direction and extract the result 938 (DataField). One value of set (B{C{width}}, B{C{height}}, B{C{depth}}) needs to be -1, 939 determining the plane orientation. In contrast to L{Brick.extract_plane}, 940 the appropriate start coordinate (e.g. B{C{istart}} if B{C{width}} = -1) is not used 941 for single plane extraction, but the planes are accumulated in whole range 942 (0..xres for given example) 943 944 Since: 2.32 945 946 @param target: Datafield to be filled by the minima plane. It will be resampled if 947 necessary. I{(L{DataField})} 948 @param istart: column where to start (pixel coordinates). I{(int)} 949 @param jstart: row where to start (pixel coordinates). I{(int)} 950 @param kstart: level where to start (pixel coordinates). I{(int)} 951 @param width: pixel width of summed plane. If B{C{width}} is -1, the yz planes will be 952 summed. I{(int)} 953 @param height: pixel height of summed plane. If B{C{height}} is -1, the xz planes will 954 be summed I{(int)} 955 @param depth: pixel depth of extacted plane. If B{C{depth}} is -1, the xy planes will 956 be summed I{(int)} 957 @param keep_offsets: keep the physical offsets in extracted field. Not 958 implemented. I{(bool)} 959 @return: 960 """ 961 return None
962 - def max_plane( target , istart , jstart , kstart , width , height , depth , keep_offsets ):
963 """ 964 Finds minima of planes in certain direction and extract the result 965 (DataField). One value of set (B{C{width}}, B{C{height}}, B{C{depth}}) needs to be -1, 966 determining the plane orientation. In contrast to L{Brick.extract_plane}, 967 the appropriate start coordinate (e.g. B{C{istart}} if B{C{width}} = -1) is not used 968 for single plane extraction, but the planes are accumulated in whole range 969 (0..xres for given example) 970 971 Since: 2.32 972 973 @param target: Datafield to be filled by the maxima plane. It will be resampled if 974 necessary. I{(L{DataField})} 975 @param istart: column where to start (pixel coordinates). I{(int)} 976 @param jstart: row where to start (pixel coordinates). I{(int)} 977 @param kstart: level where to start (pixel coordinates). I{(int)} 978 @param width: pixel width of summed plane. If B{C{width}} is -1, the yz planes will be 979 summed. I{(int)} 980 @param height: pixel height of summed plane. If B{C{height}} is -1, the xz planes will 981 be summed I{(int)} 982 @param depth: pixel depth of extacted plane. If B{C{depth}} is -1, the xy planes will 983 be summed I{(int)} 984 @param keep_offsets: keep the physical offsets in extracted field. Not 985 implemented. I{(bool)} 986 @return: 987 """ 988 return None
989 - def minpos_plane( target , istart , jstart , kstart , width , height , depth , keep_offsets ):
990 """ 991 Finds minima positions of planes in certain direction and extract the result 992 (DataField). One value of set (B{C{width}}, B{C{height}}, B{C{depth}}) needs to be -1, 993 determining the plane orientation. In contrast to L{Brick.extract_plane}, 994 the appropriate start coordinate (e.g. B{C{istart}} if B{C{width}} = -1) is not used 995 for single plane extraction, but the planes are accumulated in whole range 996 (0..xres for given example) 997 998 Since: 2.32 999 1000 @param target: Datafield to be filled by the minima positions plane. 1001 It will be resampled if necessary. I{(L{DataField})} 1002 @param istart: column where to start (pixel coordinates). I{(int)} 1003 @param jstart: row where to start (pixel coordinates). I{(int)} 1004 @param kstart: level where to start (pixel coordinates). I{(int)} 1005 @param width: pixel width of summed plane. If B{C{width}} is -1, the yz planes will be 1006 summed. I{(int)} 1007 @param height: pixel height of summed plane. If B{C{height}} is -1, the xz planes will 1008 be summed I{(int)} 1009 @param depth: pixel depth of extacted plane. If B{C{depth}} is -1, the xy planes will 1010 be summed I{(int)} 1011 @param keep_offsets: keep the physical offsets in extracted field. Not 1012 implemented. I{(bool)} 1013 @return: 1014 """ 1015 return None
1016 - def maxpos_plane( target , istart , jstart , kstart , width , height , depth , keep_offsets ):
1017 """ 1018 Finds maxima positions of planes in certain direction and extract the result 1019 (DataField). One value of set (B{C{width}}, B{C{height}}, B{C{depth}}) needs to be -1, 1020 determining the plane orientation. In contrast to L{Brick.extract_plane}, 1021 the appropriate start coordinate (e.g. B{C{istart}} if B{C{width}} = -1) is not used 1022 for single plane extraction, but the planes are accumulated in whole range 1023 (0..xres for given example) 1024 1025 Since: 2.32 1026 1027 @param target: Datafield to be filled by the maxima positions plane. 1028 It will be resampled if necessary. I{(L{DataField})} 1029 @param istart: column where to start (pixel coordinates). I{(int)} 1030 @param jstart: row where to start (pixel coordinates). I{(int)} 1031 @param kstart: level where to start (pixel coordinates). I{(int)} 1032 @param width: pixel width of summed plane. If B{C{width}} is -1, the yz planes will be 1033 summed. I{(int)} 1034 @param height: pixel height of summed plane. If B{C{height}} is -1, the xz planes will 1035 be summed I{(int)} 1036 @param depth: pixel depth of extacted plane. If B{C{depth}} is -1, the xy planes will 1037 be summed I{(int)} 1038 @param keep_offsets: keep the physical offsets in extracted field. Not 1039 implemented. I{(bool)} 1040 @return: 1041 """ 1042 return None
1043 - def mean_plane( target , istart , jstart , kstart , width , height , depth , keep_offsets ):
1044 """ 1045 Finds mean of planes in certain direction and extract the result 1046 (DataField). One value of set (B{C{width}}, B{C{height}}, B{C{depth}}) needs to be -1, 1047 determining the plane orientation. In contrast to L{Brick.extract_plane}, 1048 the appropriate start coordinate (e.g. B{C{istart}} if B{C{width}} = -1) is not used 1049 for single plane extraction, but the planes are accumulated in whole range 1050 (0..xres for given example) 1051 1052 Since: 2.32 1053 1054 @param target: Datafield to be filled by the mean plane. It will be resampled if 1055 necessary. I{(L{DataField})} 1056 @param istart: column where to start (pixel coordinates). I{(int)} 1057 @param jstart: row where to start (pixel coordinates). I{(int)} 1058 @param kstart: level where to start (pixel coordinates). I{(int)} 1059 @param width: pixel width of summed plane. If B{C{width}} is -1, the yz planes will be 1060 summed. I{(int)} 1061 @param height: pixel height of summed plane. If B{C{height}} is -1, the xz planes will 1062 be summed I{(int)} 1063 @param depth: pixel depth of extacted plane. If B{C{depth}} is -1, the xy planes will 1064 be summed I{(int)} 1065 @param keep_offsets: keep the physical offsets in extracted field. Not 1066 implemented. I{(bool)} 1067 @return: 1068 """ 1069 return None
1070 - def rms_plane( target , istart , jstart , kstart , width , height , depth , keep_offsets ):
1071 """ 1072 Finds rms of planes in certain direction and extract the result 1073 (DataField). One value of set (B{C{width}}, B{C{height}}, B{C{depth}}) needs to be -1, 1074 determining the plane orientation. In contrast to L{Brick.extract_plane}, 1075 the appropriate start coordinate (e.g. B{C{istart}} if B{C{width}} = -1) is not used 1076 for single plane extraction, but the planes are accumulated in whole range 1077 (0..xres for given example) 1078 1079 Since: 2.32 1080 1081 @param target: Datafield to be filled by the rms plane. It will be resampled if 1082 necessary. I{(L{DataField})} 1083 @param istart: column where to start (pixel coordinates). I{(int)} 1084 @param jstart: row where to start (pixel coordinates). I{(int)} 1085 @param kstart: level where to start (pixel coordinates). I{(int)} 1086 @param width: pixel width of summed plane. If B{C{width}} is -1, the yz planes will be 1087 summed. I{(int)} 1088 @param height: pixel height of summed plane. If B{C{height}} is -1, the xz planes will 1089 be summed I{(int)} 1090 @param depth: pixel depth of extacted plane. If B{C{depth}} is -1, the xy planes will 1091 be summed I{(int)} 1092 @param keep_offsets: keep the physical offsets in extracted field. Not 1093 implemented. I{(bool)} 1094 @return: 1095 """ 1096 return None
1097 - def extract_line( target , istart , jstart , kstart , iend , jend , kend , keep_offsets ):
1098 """ 1099 Extract a line (DataField) from the brick. Only line orientations parallel to coordinate 1100 axes are supported now, i.e. two of the start coordinates need to be same as end ones. 1101 1102 Since: 2.31 1103 1104 @param target: Dataline to be filled by extracted line. It will be resampled if necessary. I{(L{DataLine})} 1105 @param istart: column where to start (pixel coordinates). I{(int)} 1106 @param jstart: row where to start (pixel coordinates). I{(int)} 1107 @param kstart: level where to start (pixel coordinates). I{(int)} 1108 @param iend: column where to start (pixel coordinates). I{(int)} 1109 @param jend: row where to start (pixel coordinates). I{(int)} 1110 @param kend: level where to start (pixel coordinates). I{(int)} 1111 @param keep_offsets: keep physical offsets in extracted line I{(bool)} 1112 @return: 1113 """ 1114 return None
1115 - def get_zcalibration( ):
1116 """ 1117 Gets the z-axis non-linear calibration of a data brick. 1118 1119 Since: 2.32 1120 1121 @return: Z Calibration (non-linear Z-axis values as ordinates). 1122 1123 1124 """ 1125 return None
1126 - def set_zcalibration( calibration ):
1127 """ 1128 Sets the z-axis non-linear calibration of a data brick. 1129 1130 Since: 2.32 1131 1132 @param calibration: DataLine pointer with z-axis non-linear calibration 1133 of a data brick (values are stored as ordinates). I{(L{DataLine})} 1134 @return: 1135 """ 1136 return None
1137 - def UNIMPLEMENTED_invert( brick , x , y , z ):
1138 return None
1139 - def duplicate( ):
1140 """ 1141 Duplicate brick 1142 1143 1144 @return: duplicated brick 1145 1146 """ 1147 return None
1148 - def get_data_pointer( ):
1149 """ 1150 Get Pointer to data which the brick contains. 1151 1152 1153 @return: integer pointing to the raw data of the brick 1154 1155 """ 1156 return None
1157 -class ColorAxis:
1158 - def __init__( orientation ):
1159 """ 1160 Creates a new color axis. 1161 1162 1163 @return: The newly created color axis as a B{C{GtkWidget}}. 1164 1165 """ 1166 return None
1167 - def get_range( min , max ):
1168 """ 1169 Gets the range of a color axis. 1170 1171 @param min: Location to store the range maximum (or B{C{NULL}}). I{(float)} 1172 @param max: Location to store the range minimum (or B{C{NULL}}). I{(float)} 1173 @return: 1174 """ 1175 return None
1176 - def set_range( min , max ):
1177 """ 1178 Sets the range of a color axis. 1179 1180 @param min: The range minimum. I{(float)} 1181 @param max: The range maximum. I{(float)} 1182 @return: 1183 """ 1184 return None
1185 - def get_si_unit( ):
1186 """ 1187 Gets the SI unit a color axis displays. 1188 1189 1190 @return: The SI unit. 1191 1192 """ 1193 return None
1194 - def set_si_unit( unit ):
1195 """ 1196 Sets the SI unit a color axis displays. 1197 1198 @param unit: A SI unit to display next to minimum and maximum value. I{(L{SIUnit})} 1199 @return: 1200 """ 1201 return None
1202 - def set_gradient( gradient ):
1203 """ 1204 Sets the color gradient a color axis should use. 1205 1206 @param gradient: Name of gradient B{C{axis}} should use. It should exist. I{(string)} 1207 @return: 1208 """ 1209 return None
1210 - def get_gradient( ):
1211 """ 1212 Gets the color gradient a color axis uses. 1213 1214 1215 @return: The color gradient. 1216 1217 """ 1218 return None
1219 - def get_ticks_style( ):
1220 """ 1221 Gets ticks style of a color axis. 1222 1223 1224 @return: The ticks style. 1225 1226 """ 1227 return None
1228 - def set_ticks_style( ticks_style ):
1229 """ 1230 Sets the ticks style of a color axis. 1231 1232 @param ticks_style: The ticks style to use. I{(TicksStyle)} 1233 @return: 1234 """ 1235 return None
1236 - def get_labels_visible( ):
1237 """ 1238 Gets the visibility of labels of a color axis. 1239 1240 1241 @return: B{C{True}} if labels are displayed, B{C{False}} if they are omitted. 1242 1243 """ 1244 return None
1245 - def set_labels_visible( labels_visible ):
1246 """ 1247 Sets the visibility of labels of a color axis. 1248 1249 @param labels_visible: B{C{True}} to display labels with minimum and maximum values, 1250 B{C{False}} to display no labels. I{(bool)} 1251 @return: 1252 """ 1253 return None
1254 - def UNIMPLEMENTED_set_tick_map_func( func , user_data ):
1255 """ 1256 Set the tick mapping function for a color axis. 1257 1258 The axis calculates tick positions as for the linear axis and then places 1259 them non-linearly using B{C{func}}. Hence a mapping function should be used with 1260 ticks mode B{C{TICKS_STYLE_UNLABELLED}} because minimum tick spacing is not 1261 guaranteed. 1262 1263 Since: 2.39 1264 1265 @param func: Tick mapping function. I{(ColorAxisMapFunc)} 1266 @param data: Data to pass to B{C{func}}. 1267 @return: 1268 """ 1269 return None
1270 -class ColorButton:
1271 - def __init__( ):
1272 """ 1273 Creates a new color button. This returns a widget in the form of 1274 a small button containing a swatch representing the current selected 1275 color. When the button is clicked, a color-selection dialog will open, 1276 allowing the user to select a color. The swatch will be updated to reflect 1277 the new color when the user finishes. 1278 1279 1280 @return: a new color button. 1281 1282 """ 1283 return None
1284 - def set_color( color ):
1285 """ 1286 Sets the current color to be B{C{color}}. 1287 1288 @param color: A B{C{RGBA}} to set the current color with. I{(L{RGBA})} 1289 @return: 1290 """ 1291 return None
1292 - def get_color( color ):
1293 """ 1294 Sets B{C{color}} to be the current color in the B{C{ColorButton}} widget. 1295 1296 @param color: a B{C{RGBA}} to fill in with the current color. I{(L{RGBA})} 1297 @return: 1298 """ 1299 return None
1300 - def set_use_alpha( use_alpha ):
1301 """ 1302 Sets whether or not the color button should use the alpha channel. 1303 1304 @param use_alpha: B{C{True}} if color button should use alpha channel, B{C{False}} if not. I{(bool)} 1305 @return: 1306 """ 1307 return None
1308 - def get_use_alpha( ):
1309 """ 1310 Does the color selection dialog use the alpha channel? 1311 1312 1313 @return: B{C{True}} if the color sample uses alpha channel, B{C{False}} if not. 1314 1315 """ 1316 return None
1317 -class Container:
1318 - def __init__( ):
1319 """ 1320 Creates a new B{C{Container}}. 1321 1322 1323 @return: The container, as a B{C{GObject}}. 1324 1325 """ 1326 return None
1327 - def get_n_items( ):
1328 """ 1329 Gets the number of items in a container. 1330 1331 1332 @return: The number of items. 1333 1334 """ 1335 return None
1336 - def value_type( key ):
1337 """ 1338 Returns the type of value in B{C{container}} identified by B{C{key}}. 1339 1340 1341 @param key: A B{C{GQuark}} key. I{(int)} 1342 @return: The value type as B{C{GType}}; 0 if there is no such value. 1343 1344 """ 1345 return None
1346 - def contains( key ):
1347 """ 1348 Returns B{C{True}} if B{C{container}} contains a value identified by B{C{key}}. 1349 1350 1351 @param key: A B{C{GQuark}} key. I{(int)} 1352 @return: Whether B{C{container}} contains something identified by B{C{key}}. 1353 1354 """ 1355 return None
1356 - def get_value( key ):
1357 """ 1358 Returns the value in B{C{container}} identified by B{C{key}}. 1359 1360 1361 @param key: A B{C{GQuark}} key. I{(int)} 1362 @return: The value as a B{C{GValue}}. 1363 1364 """ 1365 return None
1366 - def UNIMPLEMENTED_gis_value( key , value ):
1367 """ 1368 Get-if-set a generic value from a container. 1369 1370 1371 @param key: A B{C{GQuark}} key. I{(int)} 1372 @param value: Pointer to a B{C{GValue}} to update. If item does not exist, 1373 it is left untouched. I{(GValue*)} 1374 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1375 such value in the container. 1376 1377 """ 1378 return None
1379 - def remove( key ):
1380 """ 1381 Removes a value identified by B{C{key}} from a container. 1382 1383 1384 @param key: A B{C{GQuark}} key. I{(int)} 1385 @return: B{C{True}} if there was such a value and was removed. 1386 1387 """ 1388 return None
1389 - def remove_by_prefix( prefix ):
1390 """ 1391 Removes a values whose key start with B{C{prefix}} from container B{C{container}}. 1392 1393 B{C{prefix}} can be B{C{NULL}}, all values are then removed. 1394 1395 1396 @param prefix: A nul-terminated id prefix. I{(string)} 1397 @return: The number of values removed. 1398 1399 """ 1400 return None
1401 - def transfer( dest , source_prefix , dest_prefix , force ):
1402 """ 1403 Copies a items from one place in container to another place. 1404 1405 The copies are shallow, objects are not physically duplicated, only 1406 referenced in B{C{dest}}. 1407 1408 1409 @param dest: Destination container. It may be the same container as B{C{source}}, but 1410 B{C{source_prefix}} and B{C{dest_prefix}} may not overlap then. I{(L{Container})} 1411 @param source_prefix: Prefix in B{C{source}} to take values from. I{(string)} 1412 @param dest_prefix: Prefix in B{C{dest}} to put values to. I{(string)} 1413 @param force: B{C{True}} to replace existing values in B{C{dest}}. I{(bool)} 1414 @return: The number of actually transferred items. 1415 1416 """ 1417 return None
1418 - def rename( key , newkey , force ):
1419 """ 1420 Makes a value in B{C{container}} identified by B{C{key}} to be identified by B{C{newkey}}. 1421 1422 When B{C{force}} is B{C{True}} existing value at B{C{newkey}} is removed from B{C{container}}. 1423 When it's B{C{False}}, an existing value B{C{newkey}} inhibits the rename and B{C{False}} 1424 is returned. 1425 1426 1427 @param key: The current key. I{(int)} 1428 @param newkey: A new key for the value. I{(int)} 1429 @param force: Whether to replace existing value at B{C{newkey}}. I{(bool)} 1430 @return: Whether the rename succeeded. 1431 1432 """ 1433 return None
1434 - def UNIMPLEMENTED_foreach( prefix , function , user_data ):
1435 """ 1436 Calls B{C{function}} on each B{C{container}} item whose identifier starts with 1437 B{C{prefix}}. 1438 1439 The function is called B{C{function}}(B{C{GQuark}} key, B{C{GValue}} *value, user_data). 1440 1441 1442 @param prefix: A nul-terminated id prefix. I{(string)} 1443 @param function: The function called on the items. I{(GHFunc)} 1444 @param user_data: The user data passed to B{C{function}}. I{(gpointer)} 1445 @return: The number of items B{C{function}} was called on. 1446 1447 """ 1448 return None
1449 - def keys( ):
1450 """ 1451 Gets all quark keys of a container. 1452 1453 Since: 2.7 1454 1455 @return: A newly allocated array with quark keys of all B{C{container}} items, 1456 in no particular order. The number of items can be obtained 1457 with L{Container.get_n_items}(). If there are no items, B{C{NULL}} 1458 is returned. 1459 1460 1461 """ 1462 return None
1463 - def keys_by_name( ):
1464 """ 1465 Gets all string keys of a container. 1466 1467 Since: 2.7 1468 1469 @return: A newly allocated array with string keys of all B{C{container}} items, 1470 in no particular order. The number of items can be obtained 1471 with L{Container.get_n_items}(). If there are no items, B{C{NULL}} 1472 is returned. Unlike the array the strings are owned by GLib and 1473 must not be freed. 1474 1475 1476 """ 1477 return None
1478 - def set_boolean( key , value ):
1479 """ 1480 Stores a boolean into B{C{container}}, identified by B{C{key}}. 1481 1482 @param key: A B{C{GQuark}} key. I{(int)} 1483 @param value: A boolean. I{(bool)} 1484 @return: 1485 """ 1486 return None
1487 - def get_boolean( key ):
1488 """ 1489 Returns the boolean in B{C{container}} identified by B{C{key}}. 1490 1491 1492 @param key: A B{C{GQuark}} key. I{(int)} 1493 @return: The boolean as B{C{gboolean}}. 1494 1495 """ 1496 return None
1497 - def UNIMPLEMENTED_gis_boolean( key , value ):
1498 """ 1499 Get-if-set a boolean from a container. 1500 1501 1502 @param key: A B{C{GQuark}} key. I{(int)} 1503 @param value: Pointer to the boolean to update. I{(gboolean*)} 1504 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1505 such boolean in the container. 1506 1507 """ 1508 return None
1509 - def set_uchar( key , value ):
1510 """ 1511 Stores an unsigned character into B{C{container}}, identified by B{C{key}}. 1512 1513 @param key: A B{C{GQuark}} key. I{(int)} 1514 @param value: An unsigned character. I{(guchar)} 1515 @return: 1516 """ 1517 return None
1518 - def get_uchar( key ):
1519 """ 1520 Returns the unsigned character in B{C{container}} identified by B{C{key}}. 1521 1522 1523 @param key: A B{C{GQuark}} key. I{(int)} 1524 @return: The character as B{C{guchar}}. 1525 1526 """ 1527 return None
1528 - def UNIMPLEMENTED_gis_uchar( key , value ):
1529 """ 1530 Get-if-set an unsigned char from a container. 1531 1532 1533 @param key: A B{C{GQuark}} key. I{(int)} 1534 @param value: Pointer to the unsigned char to update. I{(guchar*)} 1535 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1536 such unsigned char in the container. 1537 1538 """ 1539 return None
1540 - def set_int32( key , value ):
1541 """ 1542 Stores a 32bit integer into B{C{container}}, identified by B{C{key}}. 1543 1544 @param key: A B{C{GQuark}} key. I{(int)} 1545 @param value: A 32bit integer. I{(int)} 1546 @return: 1547 """ 1548 return None
1549 - def get_int32( key ):
1550 """ 1551 Returns the 32bit integer in B{C{container}} identified by B{C{key}}. 1552 1553 1554 @param key: A B{C{GQuark}} key. I{(int)} 1555 @return: The integer as B{C{guint32}}. 1556 1557 """ 1558 return None
1559 - def UNIMPLEMENTED_gis_int32( key , value ):
1560 """ 1561 Get-if-set a 32bit integer from a container. 1562 1563 1564 @param key: A B{C{GQuark}} key. I{(int)} 1565 @param value: Pointer to the 32bit integer to update. I{(int)} 1566 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1567 such 32bit integer in the container. 1568 1569 """ 1570 return None
1571 - def set_enum( key , value ):
1572 """ 1573 Stores an enum into B{C{container}}, identified by B{C{key}}. 1574 1575 Note enums are treated as 32bit integers. 1576 1577 @param key: A B{C{GQuark}} key. I{(int)} 1578 @param value: An enum integer. I{(int)} 1579 @return: 1580 """ 1581 return None
1582 - def get_enum( key ):
1583 """ 1584 Returns the enum in B{C{container}} identified by B{C{key}}. 1585 1586 Note enums are treated as 32bit integers. 1587 1588 1589 @param key: A B{C{GQuark}} key. I{(int)} 1590 @return: The enum as B{C{gint}}. 1591 1592 """ 1593 return None
1594 - def UNIMPLEMENTED_gis_enum( key , value ):
1595 """ 1596 Get-if-set an enum from a container. 1597 1598 Note enums are treated as 32bit integers. 1599 1600 1601 @param key: A B{C{GQuark}} key. I{(int)} 1602 @param value: Pointer to the enum to update. I{(int)} 1603 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1604 such enum in the container. 1605 1606 """ 1607 return None
1608 - def set_int64( key , value ):
1609 """ 1610 Stores a 64bit integer into B{C{container}}, identified by B{C{key}}. 1611 1612 @param key: A B{C{GQuark}} key. I{(int)} 1613 @param value: A 64bit integer. I{(gint64)} 1614 @return: 1615 """ 1616 return None
1617 - def get_int64( key ):
1618 """ 1619 Returns the 64bit integer in B{C{container}} identified by B{C{key}}. 1620 1621 1622 @param key: A B{C{GQuark}} key. I{(int)} 1623 @return: The 64bit integer as B{C{guint64}}. 1624 1625 """ 1626 return None
1627 - def UNIMPLEMENTED_gis_int64( key , value ):
1628 """ 1629 Get-if-set a 64bit integer from a container. 1630 1631 1632 @param key: A B{C{GQuark}} key. I{(int)} 1633 @param value: Pointer to the 64bit integer to update. I{(int)} 1634 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1635 such 64bit integer in the container. 1636 1637 """ 1638 return None
1639 - def set_double( key , value ):
1640 """ 1641 Stores a double into B{C{container}}, identified by B{C{key}}. 1642 1643 @param key: A B{C{GQuark}} key. I{(int)} 1644 @param value: A double. I{(float)} 1645 @return: 1646 """ 1647 return None
1648 - def get_double( key ):
1649 """ 1650 Returns the double in B{C{container}} identified by B{C{key}}. 1651 1652 1653 @param key: A B{C{GQuark}} key. I{(int)} 1654 @return: The double as B{C{gdouble}}. 1655 1656 """ 1657 return None
1658 - def UNIMPLEMENTED_gis_double( key , value ):
1659 """ 1660 Get-if-set a double from a container. 1661 1662 1663 @param key: A B{C{GQuark}} key. I{(int)} 1664 @param value: Pointer to the double to update. I{(float)} 1665 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1666 such double in the container. 1667 1668 """ 1669 return None
1670 - def set_string( key , value ):
1671 """ 1672 Set string for key to given value 1673 1674 1675 @param value: new string I{(string)} 1676 @return: 1677 """ 1678 return None
1679 - def set_const_string( key , value ):
1680 """ 1681 Stores a string into B{C{container}}, identified by B{C{key}}. 1682 1683 The container makes a copy of the string, so it can be used on static 1684 strings. 1685 1686 Since: 2.38 1687 1688 @param key: A B{C{GQuark}} key. I{(int)} 1689 @param value: A nul-terminated string. I{(string)} 1690 @return: 1691 """ 1692 return None
1693 - def get_string( key ):
1694 """ 1695 Returns the string in B{C{container}} identified by B{C{key}}. 1696 1697 The returned string must be treated as constant and never freed or modified. 1698 1699 1700 @param key: A B{C{GQuark}} key. I{(int)} 1701 @return: The string. 1702 1703 """ 1704 return None
1705 - def UNIMPLEMENTED_gis_string( key , value ):
1706 """ 1707 Get-if-set a string from a container. 1708 1709 The string eventually stored in B{C{value}} must be treated as constant and 1710 never freed or modified. 1711 1712 1713 @param key: A B{C{GQuark}} key. I{(int)} 1714 @param value: Pointer to the string pointer to update. I{(const-guchar**)} 1715 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1716 such string in the container. 1717 1718 """ 1719 return None
1720 - def set_object( key , value ):
1721 """ 1722 Stores an object into B{C{container}}, identified by B{C{key}}. 1723 1724 The container claims ownership on the object, i.e. its reference count is 1725 incremented. 1726 1727 The object must implement B{C{Serializable}} interface to allow serialization 1728 of the container. 1729 1730 @param key: A B{C{GQuark}} key. I{(int)} 1731 @param value: An object to store into container. I{(gpointer)} 1732 @return: 1733 """ 1734 return None
1735 - def get_object( key ):
1736 """ 1737 Get object of given key from container. 1738 1739 1740 @return: object of given key 1741 1742 """ 1743 return None
1744 - def gis_object( key , value ):
1745 """ 1746 Get-if-set an object from a container. 1747 1748 The object eventually stored in B{C{value}} doesn't have its reference count 1749 increased, use g_object_ref() if you want to access it even when 1750 B{C{container}} may cease to exist. 1751 1752 1753 @param key: A B{C{GQuark}} key. I{(int)} 1754 @param value: Pointer to the object pointer to update. I{(gpointer)} 1755 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1756 such object in the container. 1757 1758 """ 1759 return None
1761 """ 1762 Creates a text representation of B{C{container}} contents. 1763 1764 Note only simple data types are supported as serialization of compound 1765 objects is not controllable. 1766 1767 1768 @return: A pointer array, each item containing string with one container 1769 item representation (name, type, value). The array is sorted by name. 1770 1771 """ 1772 return None
1773 - def contains_by_name( name ):
1774 """ 1775 Expands to B{C{True}} if container B{C{c}} contains a value identified by name B{C{n}}. 1776 1777 @param n: A nul-terminated name (id). 1778 @return: 1779 """ 1780 return None
1781 - def remove_by_name( name ):
1782 """ 1783 Removes a value identified by name B{C{n}} from container B{C{c}}. 1784 1785 Expands to B{C{True}} if there was such a value and was removed. 1786 1787 @param n: A nul-terminated name (id). 1788 @return: 1789 """ 1790 return None
1791 - def rename_by_name( name , new_name , delete ):
1792 """ 1793 Makes a value in container B{C{c}} identified by name B{C{n}} to be identified by 1794 new name B{C{nn}}. 1795 1796 See L{Container.rename}() for details. 1797 1798 @param n: A nul-terminated name (id). 1799 @param nn: A nul-terminated name (id). 1800 @param f: Whether to delete existing value at B{C{newkey}}. 1801 @return: 1802 """ 1803 return None
1804 - def set_boolean_by_name( name , value ):
1805 """ 1806 Stores a boolean into container B{C{c}}, identified by name B{C{n}}. 1807 1808 @param n: A nul-terminated name (id). 1809 @param v: A boolean. 1810 @return: 1811 """ 1812 return None
1813 - def set_double_by_name( name , value ):
1814 """ 1815 Stores a double into container B{C{c}}, identified by name B{C{n}}. 1816 1817 @param n: A nul-terminated name (id). 1818 @param v: A double integer. 1819 @return: 1820 """ 1821 return None
1822 - def set_enum_by_name( name , value ):
1823 """ 1824 Stores an enum into container B{C{c}}, identified by name B{C{n}}. 1825 1826 Note enums are treated as 32bit integers. 1827 1828 @param n: A nul-terminated name (id). 1829 @param v: An enum. 1830 @return: 1831 """ 1832 return None
1833 - def set_int32_by_name( name , value ):
1834 """ 1835 Stores a 32bit integer into container B{C{c}}, identified by name B{C{n}}. 1836 1837 @param n: A nul-terminated name (id). 1838 @param v: A 32bit integer. 1839 @return: 1840 """ 1841 return None
1842 - def set_int64_by_name( name , value ):
1843 """ 1844 Stores a 64bit integer into container B{C{c}}, identified by name B{C{n}}. 1845 1846 @param n: A nul-terminated name (id). 1847 @param v: A 64bit integer. 1848 @return: 1849 """ 1850 return None
1851 - def set_object_by_name( name , value ):
1852 """ 1853 Stores an object into container B{C{c}}, identified by name B{C{n}}. 1854 1855 See L{Container.set_object}() for details. 1856 1857 @param n: A nul-terminated name (id). 1858 @param v: An object to store into container. 1859 @return: 1860 """ 1861 return None
1862 - def set_uchar_by_name( name , value ):
1863 """ 1864 Stores an unsigned character into container B{C{c}}, identified by name B{C{n}}. 1865 1866 @param n: A nul-terminated name (id). 1867 @param v: An unsigned character. 1868 @return: 1869 """ 1870 return None
1871 - def set_string_by_name( name , value ):
1872 """ 1873 Stores a string into container B{C{c}}, identified by name B{C{n}}. 1874 1875 The container takes ownership of the string, so it can't be used on 1876 static strings, use g_strdup() to duplicate them first. 1877 1878 @param n: A nul-terminated name (id). 1879 @param v: A nul-terminated string. 1880 @return: 1881 """ 1882 return None
1883 - def get_boolean_by_name( name ):
1884 """ 1885 Gets the boolean in container B{C{c}} identified by name B{C{n}}. 1886 1887 @param n: A nul-terminated name (id). 1888 @return: 1889 """ 1890 return None
1891 - def get_double_by_name( name ):
1892 """ 1893 Gets the double in container B{C{c}} identified by name B{C{n}}. 1894 1895 @param n: A nul-terminated name (id). 1896 @return: 1897 """ 1898 return None
1899 - def get_enum_by_name( name ):
1900 """ 1901 Gets the enum in container B{C{c}} identified by name B{C{n}}. 1902 1903 Note enums are treated as 32bit integers. 1904 1905 @param n: A nul-terminated name (id). 1906 @return: 1907 """ 1908 return None
1909 - def get_int32_by_name( name ):
1910 """ 1911 Gets the 32bit integer in container B{C{c}} identified by name B{C{n}}. 1912 1913 @param n: A nul-terminated name (id). 1914 @return: 1915 """ 1916 return None
1917 - def get_int64_by_name( name ):
1918 """ 1919 Gets the 64bit integer in container B{C{c}} identified by name B{C{n}}. 1920 1921 @param n: A nul-terminated name (id). 1922 @return: 1923 """ 1924 return None
1925 - def get_object_by_name( name ):
1926 """ 1927 Gets the object in container B{C{c}} identified by name B{C{n}}. 1928 1929 The returned object doesn't have its reference count increased, use 1930 g_object_ref() if you want to access it even when B{C{container}} may cease 1931 to exist. 1932 1933 @param n: A nul-terminated name (id). 1934 @return: 1935 """ 1936 return None
1937 - def get_uchar_by_name( name ):
1938 """ 1939 Gets the unsigned character in container B{C{c}} identified by name B{C{n}}. 1940 1941 @param n: A nul-terminated name (id). 1942 @return: 1943 """ 1944 return None
1945 - def get_value_by_name( name ):
1946 """ 1947 Gets the value in container B{C{c}} identified by name B{C{n}}. 1948 1949 @param n: A nul-terminated name (id). 1950 @return: 1951 """ 1952 return None
1953 - def get_string_by_name( name ):
1954 """ 1955 Gets the string in container B{C{c}} identified by name B{C{n}}. 1956 1957 The returned string must be treated as constant and never freed or modified. 1958 1959 @param n: A nul-terminated name (id). 1960 @return: 1961 """ 1962 return None
1963 - def get_object( key ):
1964 """ 1965 Get object of given key from container. 1966 1967 1968 @return: object of given key 1969 1970 """ 1971 return None
1972 - def set_string( key , value ):
1973 """ 1974 Set string for key to given value 1975 1976 1977 @param value: new string I{(some_type)} 1978 @return: 1979 """ 1980 return None
1981 -class Curve:
1982 - def __init__( ):
1983 """ 1984 Creates B{C{Curve}} widget. By default, the widget will have 3 curves. 1985 1986 1987 @return: new B{C{Curve}} widget. 1988 1989 """ 1990 return None
1991 - def reset( ):
1992 """ 1993 Removes all control points, resetting the curves to their initial state. 1994 1995 1996 @return: 1997 """ 1998 return None
1999 - def set_range( min_x , max_x , min_y , max_y ):
2000 return None
2001 - def set_curve_type( type ):
2002 return None
2003 - def set_channels( num_channels , colors ):
2004 return None
2005 - def UNIMPLEMENTED_set_control_points( channel_data , prune ):
2006 return None
2007 - def UNIMPLEMENTED_get_control_points( channel_data , triplets ):
2008 return None
2009 -class DataField:
2010 - def __init__( xres , yres , xreal , yreal , nullme ):
2011 """ 2012 Creates a new data field. 2013 2014 2015 @param yres: Y-resolution, i.e., the number of rows. I{(int)} 2016 @param xreal: Real horizontal physical dimension. I{(float)} 2017 @param yreal: Real vertical physical dimension. I{(float)} 2018 @param nullme: Whether the data field should be initialized to zeroes. If B{C{False}}, 2019 the data will not be initialized. I{(bool)} 2020 @return: A newly created data field. 2021 2022 """ 2023 return None
2024 - def sum_fields( operand1 , operand2 ):
2025 """ 2026 Sums two data fields. 2027 2028 @param operand1: First data field operand. I{(L{DataField})} 2029 @param operand2: Second data field operand. I{(L{DataField})} 2030 @return: 2031 """ 2032 return None
2033 - def subtract_fields( operand1 , operand2 ):
2034 """ 2035 Subtracts one data field from another. 2036 2037 @param operand1: First data field operand. I{(L{DataField})} 2038 @param operand2: Second data field operand. I{(L{DataField})} 2039 @return: 2040 """ 2041 return None
2042 - def divide_fields( operand1 , operand2 ):
2043 """ 2044 Divides one data field with another. 2045 2046 @param operand1: First data field operand. I{(L{DataField})} 2047 @param operand2: Second data field operand. I{(L{DataField})} 2048 @return: 2049 """ 2050 return None
2051 - def multiply_fields( operand1 , operand2 ):
2052 """ 2053 Multiplies two data fields. 2054 2055 @param operand1: First data field operand. I{(L{DataField})} 2056 @param operand2: Second data field operand. I{(L{DataField})} 2057 @return: 2058 """ 2059 return None
2060 - def min_of_fields( operand1 , operand2 ):
2061 """ 2062 Finds point-wise maxima of two data fields. 2063 2064 @param operand1: First data field operand. I{(L{DataField})} 2065 @param operand2: Second data field operand. I{(L{DataField})} 2066 @return: 2067 """ 2068 return None
2069 - def max_of_fields( operand1 , operand2 ):
2070 """ 2071 Finds point-wise minima of two data fields. 2072 2073 @param operand1: First data field operand. I{(L{DataField})} 2074 @param operand2: Second data field operand. I{(L{DataField})} 2075 @return: 2076 """ 2077 return None
2078 - def hypot_of_fields( operand1 , operand2 ):
2079 """ 2080 Finds point-wise hypotenuse of two data fields. 2081 2082 Since: 2.31 2083 2084 @param operand1: First data field operand. I{(L{DataField})} 2085 @param operand2: Second data field operand. I{(L{DataField})} 2086 @return: 2087 """ 2088 return None
2089 - def check_compatibility( data_field2 , check ):
2090 """ 2091 Checks whether two data fields are compatible. 2092 2093 2094 @param data_field2: Another data field. I{(L{DataField})} 2095 @param check: The compatibility tests to perform. I{(DataCompatibilityFlags)} 2096 @return: Zero if all tested properties are compatible. Flags corresponding 2097 to failed tests if data fields are not compatible. 2098 2099 """ 2100 return None
2101 - def extend( left , right , up , down , exterior , fill_value , keep_offsets ):
2102 """ 2103 Creates a new data field by extending another data field using the specified 2104 method of exterior handling. 2105 2106 Since: 2.36 2107 2108 @param left: Number of pixels to extend to the left (towards lower column indices). I{(int)} 2109 @param right: Number of pixels to extend to the right (towards higher column 2110 indices). I{(int)} 2111 @param up: Number of pixels to extend up (towards lower row indices). I{(int)} 2112 @param down: Number of pixels to extend down (towards higher row indices). I{(int)} 2113 @param exterior: Exterior pixels handling. I{(ExteriorType)} 2114 @param fill_value: The value to use with B{C{EXTERIOR_FIXED_VALUE}} exterior. I{(float)} 2115 @param keep_offsets: B{C{True}} to set the X and Y offsets of the new field 2116 using B{C{field}} offsets. B{C{False}} to set offsets 2117 of the new field to zeroes. I{(bool)} 2118 @return: A newly created data field. 2119 2120 2121 """ 2122 return None
2123 - def correct_laplace_iteration( mask_field , buffer_field , corrfactor , error ):
2124 """ 2125 Performs one interation of Laplace data correction. 2126 2127 Tries to remove all the points in mask off the data by using 2128 iterative method similar to solving heat flux equation. 2129 2130 Use this function repeatedly until reasonable B{C{error}} is reached. 2131 2132 @param mask_field: Mask of places to be corrected. I{(L{DataField})} 2133 @param buffer_field: Initialized to same size as mask and data. I{(L{DataField})} 2134 @param error: Maximum change within last step. I{(float)} 2135 @param corrfactor: Correction factor within step. I{(float)} 2136 @return: 2137 """ 2138 return None
2139 - def correct_average( mask_field ):
2140 """ 2141 Fills data under mask with average value. 2142 2143 Simply puts average value of all the B{C{data_field}} values into 2144 points in B{C{data_field}} lying under points where B{C{mask_field}} values 2145 are nonzero. 2146 2147 @param mask_field: Mask of places to be corrected. I{(L{DataField})} 2148 @return: 2149 """ 2150 return None
2151 - def mask_outliers( mask_field , thresh ):
2152 """ 2153 Creates mask of data that are above or below B{C{thresh}}*sigma from average 2154 height. 2155 2156 Sigma denotes root-mean square deviation of heights. This criterium 2157 corresponds to the usual Gaussian distribution outliers detection if 2158 B{C{thresh}} is 3. 2159 2160 @param mask_field: A data field to be filled with mask. I{(L{DataField})} 2161 @param thresh: Threshold value. I{(float)} 2162 @return: 2163 """ 2164 return None
2165 - def mask_outliers2( mask_field , thresh_low , thresh_high ):
2166 """ 2167 Creates mask of data that are above or below multiples of rms from average 2168 height. 2169 2170 Data that are below B{C{mean}}-B{C{thresh_low}}*B{C{sigma}} or above 2171 B{C{mean}}+B{C{thresh_high}}*B{C{sigma}} are marked as outliers, where B{C{sigma}} denotes the 2172 root-mean square deviation of heights. 2173 2174 Since: 2.26 2175 2176 @param mask_field: A data field to be filled with mask. I{(L{DataField})} 2177 @param thresh_low: Lower threshold value. I{(float)} 2178 @param thresh_high: Upper threshold value. I{(float)} 2179 @return: 2180 """ 2181 return None
2182 - def UNIMPLEMENTED_distort( dest , invtrans , user_data , interp , exterior , fill_value ):
2183 """ 2184 Distorts a data field in the horizontal plane. 2185 2186 Note the transform function B{C{invtrans}} is the inverse transform, in other 2187 words it calculates the old coordinates from the new coordinates (the 2188 transform would not be uniquely defined the other way round). 2189 2190 Since: 2.5 2191 2192 @param dest: Destination data field. I{(L{DataField})} 2193 @param invtrans: Inverse transform function, that is the transformation from 2194 new coordinates to old coordinates. It gets 2195 (B{C{j}}+0.5, B{C{i}}+0.5), where B{C{i}} and B{C{j}} are the new row and column 2196 indices, passed as the input coordinates. The output coordinates 2197 should follow the same convention. Unless a special exterior 2198 handling is required, the transform function does not need to 2199 concern itself with coordinates being outside of the data. I{(CoordTransform2DFunc)} 2200 @param user_data: Pointer passed as B{C{user_data}} to B{C{invtrans}}. I{(gpointer)} 2201 @param interp: Interpolation type to use. I{(InterpolationType)} 2202 @param exterior: Exterior pixels handling. I{(ExteriorType)} 2203 @param fill_value: The value to use with B{C{EXTERIOR_FIXED_VALUE}}. I{(float)} 2204 @return: 2205 """ 2206 return None
2207 - def affine( dest , invtrans , interp , exterior , fill_value ):
2208 """ 2209 Performs an affine transformation of a data field in the horizontal plane. 2210 2211 Note the transform B{C{invtrans}} is the inverse transform, in other 2212 words it calculates the old coordinates from the new coordinates. This 2213 way even degenerate (non-invertible) transforms can be meaningfully used. 2214 Also note that the (column, row) coordinate system is left-handed. 2215 2216 Since: 2.34 2217 2218 @param dest: Destination data field. I{(L{DataField})} 2219 @param invtrans: Inverse transform, that is the transformation from 2220 new pixel coordinates to old pixel coordinates, represented as 2221 (B{C{j}}+0.5, B{C{i}}+0.5), where B{C{i}} and B{C{j}} are the row and column 2222 indices. It is represented as a six-element array [B{C{axx}}, B{C{axy}}, 2223 B{C{ayx}}, B{C{ayy}}, B{C{bx}}, B{C{by}}] where B{C{axy}} is the coefficient from B{C{x}} to 2224 B{C{y}}. I{(const-gdouble*)} 2225 @param interp: Interpolation type to use. I{(InterpolationType)} 2226 @param exterior: Exterior pixels handling. I{(ExteriorType)} 2227 @param fill_value: The value to use with B{C{EXTERIOR_FIXED_VALUE}}. I{(float)} 2228 @return: 2229 """ 2230 return None
2231 - def get_correlation_score( kernel_field , col , row , kernel_col , kernel_row , kernel_width , kernel_height ):
2232 """ 2233 Calculates a correlation score in one point. 2234 2235 Correlation window size is given 2236 by B{C{kernel_col}}, B{C{kernel_row}}, B{C{kernel_width}}, B{C{kernel_height}}, 2237 postion of the correlation window on data is given by 2238 B{C{col}}, B{C{row}}. 2239 2240 If anything fails (data too close to boundary, etc.), 2241 function returns -1.0 (none correlation).. 2242 2243 2244 @param kernel_field: Kernel to correlate data field with. I{(L{DataField})} 2245 @param col: Upper-left column position in the data field. I{(int)} 2246 @param row: Upper-left row position in the data field. I{(int)} 2247 @param kernel_col: Upper-left column position in kernel field. I{(int)} 2248 @param kernel_row: Upper-left row position in kernel field. I{(int)} 2249 @param kernel_width: Width of kernel field area. I{(int)} 2250 @param kernel_height: Heigh of kernel field area. I{(int)} 2251 @return: Correlation score (between -1.0 and 1.0). Value 1.0 denotes 2252 maximum correlation, -1.0 none correlation. 2253 2254 """ 2255 return None
2256 - def crosscorrelate( data_field2 , x_dist , y_dist , score , search_width , search_height , window_width , window_height ):
2257 """ 2258 Algorithm for matching two different images of the same object under changes. 2259 2260 It does not use any special features 2261 for matching. It simply searches for all points (with their neighbourhood) 2262 of B{C{data_field1}} within B{C{data_field2}}. Parameters B{C{search_width}} and 2263 B{C{search_height}} 2264 determine maimum area where to search for points. The area is cenetered 2265 in the B{C{data_field2}} at former position of points at B{C{data_field1}}. 2266 2267 @param data_field2: A data field. I{(L{DataField})} 2268 @param x_dist: A data field to store x-distances to. I{(L{DataField})} 2269 @param y_dist: A data field to store y-distances to. I{(L{DataField})} 2270 @param score: Data field to store correlation scores to. I{(L{DataField})} 2271 @param search_width: Search area width. I{(int)} 2272 @param search_height: Search area height. I{(int)} 2273 @param window_width: Correlation window width. This parameter is not actually 2274 used. Pass zero. I{(int)} 2275 @param window_height: Correlation window height. This parameter is not actually 2276 used. Pass zero. I{(int)} 2277 @return: 2278 """ 2279 return None
2280 - def UNIMPLEMENTED_crosscorrelate_init( data_field2 , x_dist , y_dist , score , search_width , search_height , window_width , window_height ):
2281 """ 2282 Initializes a cross-correlation iterator. 2283 2284 This iterator reports its state as B{C{ComputationStateType}}. 2285 2286 2287 @param data_field2: A data field. I{(L{DataField})} 2288 @param x_dist: A data field to store x-distances to, or B{C{NULL}}. I{(L{DataField})} 2289 @param y_dist: A data field to store y-distances to, or B{C{NULL}}. I{(L{DataField})} 2290 @param score: Data field to store correlation scores to, or B{C{NULL}}. I{(L{DataField})} 2291 @param search_width: Search area width. I{(int)} 2292 @param search_height: Search area height. I{(int)} 2293 @param window_width: Correlation window width. I{(int)} 2294 @param window_height: Correlation window height. I{(int)} 2295 @return: A new cross-correlation iterator. 2296 2297 """ 2298 return None
2299 - def correlate( kernel_field , score , method ):
2300 """ 2301 Computes correlation score for all positions in a data field. 2302 2303 Correlation score is compute for all points in data field B{C{data_field}} 2304 and full size of correlation kernel B{C{kernel_field}}. 2305 2306 The points in B{C{score}} correspond to centers of kernel. More precisely, the 2307 point ((B{C{kxres}}-1)/2, (B{C{kyres}}-1)/2) in B{C{score}} corresponds to kernel field 2308 top left corner coincident with data field top left corner. Points outside 2309 the area where the kernel field fits into the data field completely are 2310 set to -1 for B{C{CORRELATION_NORMAL}}. 2311 2312 @param kernel_field: Correlation kernel. I{(L{DataField})} 2313 @param score: Data field to store correlation scores to. I{(L{DataField})} 2314 @param method: Correlation score calculation method. I{(CorrelationType)} 2315 @return: 2316 """ 2317 return None
2318 - def UNIMPLEMENTED_correlate_init( kernel_field , score ):
2319 """ 2320 Creates a new correlation iterator. 2321 2322 This iterator reports its state as B{C{ComputationStateType}}. 2323 2324 2325 @param kernel_field: Kernel to correlate data field with. I{(L{DataField})} 2326 @param score: Data field to store correlation scores to. I{(L{DataField})} 2327 @return: A new correlation iterator. 2328 2329 """ 2330 return None
2331 - def invalidate( ):
2332 """ 2333 Invalidates cached data field stats. 2334 2335 User code should rarely need this macro, as all B{C{DataField}} methods do 2336 proper invalidation when they change data, as well as 2337 L{DataField.get_data}() does. 2338 2339 However, if you get raw data with L{DataField.get_data}() and then mix 2340 direct changes to it with calls to methods like L{DataField.get_max}(), 2341 you may need to explicitely invalidate cached values to let 2342 L{DataField.get_max}() know it has to recompute the maximum. 2343 2344 @return: 2345 """ 2346 return None
2347 - def new_alike( nullme ):
2348 """ 2349 Creates a new data field similar to an existing one. 2350 2351 Use L{DataField.duplicate}() if you want to copy a data field including 2352 data. 2353 2354 2355 @param nullme: Whether the data field should be initialized to zeroes. If B{C{False}}, 2356 the data will not be initialized. I{(bool)} 2357 @return: A newly created data field. 2358 2359 """ 2360 return None
2361 - def data_changed( ):
2362 """ 2363 Emits signal "data-changed" on a data field. 2364 2365 @return: 2366 """ 2367 return None
2368 - def new_resampled( xres , yres , interpolation ):
2369 """ 2370 Creates a new data field by resampling an existing one. 2371 2372 This method is equivalent to L{DataField.duplicate}() followed by 2373 L{DataField.resample}(), but it is more efficient. 2374 2375 2376 @param xres: Desired X resolution. I{(int)} 2377 @param yres: Desired Y resolution. I{(int)} 2378 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2379 @return: A newly created data field. 2380 2381 """ 2382 return None
2383 - def resample( xres , yres , interpolation ):
2384 """ 2385 Resamples a data field using given interpolation method 2386 2387 This method may invalidate raw data buffer returned by 2388 L{DataField.get_data}(). 2389 2390 @param xres: Desired X resolution. I{(int)} 2391 @param yres: Desired Y resolution. I{(int)} 2392 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2393 @return: 2394 """ 2395 return None
2396 - def resize( ulcol , ulrow , brcol , brrow ):
2397 """ 2398 Resizes (crops) a data field. 2399 2400 Crops a data field to a rectangle between upper-left and bottom-right 2401 points, recomputing real size. 2402 2403 This method may invalidate raw data buffer returned by 2404 L{DataField.get_data}(). 2405 2406 @param ulcol: Upper-left column coordinate. I{(int)} 2407 @param ulrow: Upper-left row coordinate. I{(int)} 2408 @param brcol: Bottom-right column coordinate + 1. I{(int)} 2409 @param brrow: Bottom-right row coordinate + 1. I{(int)} 2410 @return: 2411 """ 2412 return None
2413 - def area_extract( col , row , width , height ):
2414 """ 2415 Extracts a rectangular part of a data field to a new data field. 2416 2417 2418 @param row: Upper-left row coordinate. I{(int)} 2419 @param col: Upper-left column coordinate. I{(int)} 2420 @param width: Area width (number of columns). I{(int)} 2421 @param height: Area height (number of rows). I{(int)} 2422 @return: The extracted area as a newly created data field. 2423 2424 """ 2425 return None
2426 - def copy( dest , nondata_too ):
2427 """ 2428 Copies the contents of an already allocated data field to a data field 2429 of the same size. 2430 2431 @param dest: Destination data field. I{(L{DataField})} 2432 @param nondata_too: Whether non-data (units) should be compied too. I{(bool)} 2433 @return: 2434 """ 2435 return None
2436 - def area_copy( dest , col , row , width , height , destcol , destrow ):
2437 """ 2438 Copies a rectangular area from one data field to another. 2439 2440 The area starts at (B{C{col}}, B{C{row}}) in B{C{src}} and its dimension is B{C{width}}*B{C{height}}. 2441 It is copied to B{C{dest}} starting from (B{C{destcol}}, B{C{destrow}}). 2442 2443 The source area has to be completely contained in B{C{src}}. No assumptions are 2444 made about destination position, however, parts of the source area sticking 2445 out the destination data field B{C{dest}} are cut off. 2446 2447 If B{C{src}} is equal to B{C{dest}}, the areas may not overlap. 2448 2449 @param dest: Destination data field. I{(L{DataField})} 2450 @param col: Area upper-left column coordinate in B{C{src}}. I{(int)} 2451 @param row: Area upper-left row coordinate B{C{src}}. I{(int)} 2452 @param width: Area width (number of columns), pass -1 for full B{C{src}} widdth. I{(int)} 2453 @param height: Area height (number of rows), pass -1 for full B{C{src}} height. I{(int)} 2454 @param destcol: Destination column in B{C{dest}}. I{(int)} 2455 @param destrow: Destination row in B{C{dest}}. I{(int)} 2456 @return: 2457 """ 2458 return None
2459 - def get_data( ):
2460 """ 2461 Create a tuple of data which the datafield contains. Content of the tuple is NOT reference to original datafield but its copy. 2462 2463 2464 @return: tuple of raw numeric data from DataField 2465 2466 """ 2467 return None
2468 - def get_xres( ):
2469 """ 2470 Gets X resolution (number of columns) of a data field. 2471 2472 2473 @return: X resolution. 2474 2475 """ 2476 return None
2477 - def get_yres( ):
2478 """ 2479 Gets Y resolution (number of rows) of the field. 2480 2481 2482 @return: Y resolution. 2483 2484 """ 2485 return None
2486 - def get_xreal( ):
2487 """ 2488 Gets the X real (physical) size of a data field. 2489 2490 2491 @return: X real size value. 2492 2493 """ 2494 return None
2495 - def get_yreal( ):
2496 """ 2497 Gets the Y real (physical) size of a data field. 2498 2499 2500 @return: Y real size value. 2501 2502 """ 2503 return None
2504 - def set_xreal( xreal ):
2505 """ 2506 Sets X real (physical) size value of a data field. 2507 2508 @param xreal: New X real size value. I{(float)} 2509 @return: 2510 """ 2511 return None
2512 - def set_yreal( yreal ):
2513 """ 2514 Sets Y real (physical) size value of a data field. 2515 2516 @param yreal: New Y real size value. I{(float)} 2517 @return: 2518 """ 2519 return None
2520 - def get_xoffset( ):
2521 """ 2522 Gets the X offset of data field origin. 2523 2524 2525 @return: X offset value. 2526 2527 """ 2528 return None
2529 - def get_yoffset( ):
2530 """ 2531 Gets the Y offset of data field origin. 2532 2533 2534 @return: Y offset value. 2535 2536 """ 2537 return None
2538 - def set_xoffset( xoff ):
2539 """ 2540 Sets the X offset of a data field origin. 2541 2542 Note offsets don't affect any calculation, nor functions like 2543 L{DataField.rotj}(). 2544 2545 @param xoff: New X offset value. I{(float)} 2546 @return: 2547 """ 2548 return None
2549 - def set_yoffset( yoff ):
2550 """ 2551 Sets the Y offset of a data field origin. 2552 2553 Note offsets don't affect any calculation, nor functions like 2554 L{DataField.rtoi}(). 2555 2556 @param yoff: New Y offset value. I{(float)} 2557 @return: 2558 """ 2559 return None
2560 - def get_si_unit_xy( ):
2561 """ 2562 Returns lateral SI unit of a data field. 2563 2564 2565 @return: SI unit corresponding to the lateral (XY) dimensions of the data 2566 field. Its reference count is not incremented. 2567 2568 """ 2569 return None
2570 - def get_si_unit_z( ):
2571 """ 2572 Returns value SI unit of a data field. 2573 2574 2575 @return: SI unit corresponding to the "height" (Z) dimension of the data 2576 field. Its reference count is not incremented. 2577 2578 """ 2579 return None
2580 - def set_si_unit_xy( si_unit ):
2581 """ 2582 Sets the SI unit corresponding to the lateral (XY) dimensions of a data 2583 field. 2584 2585 It does not assume a reference on B{C{si_unit}}, instead it adds its own 2586 reference. 2587 2588 @param si_unit: SI unit to be set. I{(L{SIUnit})} 2589 @return: 2590 """ 2591 return None
2592 - def set_si_unit_z( si_unit ):
2593 """ 2594 Sets the SI unit corresponding to the "height" (Z) dimension of a data 2595 field. 2596 2597 It does not assume a reference on B{C{si_unit}}, instead it adds its own 2598 reference. 2599 2600 @param si_unit: SI unit to be set. I{(L{SIUnit})} 2601 @return: 2602 """ 2603 return None
2604 - def UNIMPLEMENTED_get_value_format_xy( style , format ):
2605 """ 2606 Finds value format good for displaying coordinates of a data field. 2607 2608 2609 @param style: Unit format style. I{(SIUnitFormatStyle)} 2610 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 2611 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 2612 is returned, otherwise (modified) B{C{format}} itself is returned. 2613 2614 """ 2615 return None
2616 - def UNIMPLEMENTED_get_value_format_z( style , format ):
2617 """ 2618 Finds value format good for displaying values of a data field. 2619 2620 2621 @param style: Unit format style. I{(SIUnitFormatStyle)} 2622 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 2623 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 2624 is returned, otherwise (modified) B{C{format}} itself is returned. 2625 2626 """ 2627 return None
2628 - def copy_units_to_data_line( data_line ):
2629 """ 2630 Sets lateral and value units of a data line to match a data field. 2631 2632 @param data_line: A data line to set units of. I{(L{DataLine})} 2633 @return: 2634 """ 2635 return None
2636 - def itor( row ):
2637 """ 2638 Transforms vertical pixel coordinate to real (physical) Y coordinate. 2639 2640 That is it maps range [0..y-resolution] to range [0..real-y-size]. 2641 It is not suitable for conversion of matrix indices to physical coordinates, 2642 you have to use L{DataField.itor}(B{C{data_field}}, B{C{row}} + 0.5) for that. 2643 2644 2645 @param row: Vertical pixel coordinate. I{(float)} 2646 @return: Real Y coordinate. 2647 2648 """ 2649 return None
2650 - def jtor( col ):
2651 """ 2652 Transforms horizontal pixel coordinate to real (physical) X coordinate. 2653 2654 That is it maps range [0..x-resolution] to range [0..real-x-size]. 2655 It is not suitable for conversion of matrix indices to physical coordinates, 2656 you have to use L{DataField.jtor}(B{C{data_field}}, B{C{col}} + 0.5) for that. 2657 2658 2659 @param col: Horizontal pixel coordinate. I{(float)} 2660 @return: Real X coordinate. 2661 2662 """ 2663 return None
2664 - def rtoi( realy ):
2665 """ 2666 Transforms real (physical) Y coordinate to row. 2667 2668 That is it maps range [0..real-y-size] to range [0..y-resolution]. 2669 2670 2671 @param realy: Real (physical) Y coordinate. I{(float)} 2672 @return: Vertical pixel coodinate. 2673 2674 """ 2675 return None
2676 - def rtoj( realx ):
2677 """ 2678 Transforms real (physical) X coordinate to column. 2679 2680 That is it maps range [0..real-x-size] to range [0..x-resolution]. 2681 2682 2683 @param realx: Real (physical) X coodinate. I{(float)} 2684 @return: Horizontal pixel coordinate. 2685 2686 """ 2687 return None
2688 - def get_val( col , row ):
2689 """ 2690 Gets value at given position in a data field. 2691 2692 Do not access data with this function inside inner loops, it's slow. 2693 Get the raw data buffer with L{DataField.get_data_const}() and access it 2694 directly instead. 2695 2696 2697 @param col: Column index. I{(int)} 2698 @param row: Row index. I{(int)} 2699 @return: Value at (B{C{col}}, B{C{row}}). 2700 2701 """ 2702 return None
2703 - def set_val( col , row , value ):
2704 """ 2705 Sets value at given position in a data field. 2706 2707 Do not set data with this function inside inner loops, it's slow. Get the 2708 raw data buffer with L{DataField.get_data}() and write to it directly 2709 instead. 2710 2711 @param col: Column index. I{(int)} 2712 @param row: Row index. I{(int)} 2713 @param value: Value to set. I{(float)} 2714 @return: 2715 """ 2716 return None
2717 - def get_dval( x , y , interpolation ):
2718 """ 2719 Gets interpolated value at arbitrary data field point indexed by pixel 2720 coordinates. 2721 2722 Note pixel values are centered in pixels, so to get the same 2723 value as L{DataField.get_val}(B{C{data_field}}, B{C{j}}, B{C{i}}) returns, 2724 it's necessary to add 0.5: 2725 L{DataField.get_dval}(B{C{data_field}}, B{C{j}}+0.5, B{C{i}}+0.5, B{C{interpolation}}). 2726 2727 See also L{DataField.get_dval_real}() that does the same, but takes 2728 real coordinates. 2729 2730 2731 @param x: Horizontal position in pixel units, in range [0, x-resolution]. I{(float)} 2732 @param y: Vertical postition in pixel units, in range [0, y-resolution]. I{(float)} 2733 @param interpolation: Interpolation method to be used. I{(InterpolationType)} 2734 @return: Interpolated value at position (B{C{x}},B{C{y}}). 2735 2736 """ 2737 return None
2738 - def get_dval_real( x , y , interpolation ):
2739 """ 2740 Gets interpolated value at arbitrary data field point indexed by real 2741 coordinates. 2742 2743 See also L{DataField.get_dval}() that does the same, but takes pixel 2744 coordinates. 2745 2746 2747 @param x: X postion in real coordinates. I{(float)} 2748 @param y: Y postition in real coordinates. I{(float)} 2749 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2750 @return: Value at position (B{C{x}},B{C{y}}). 2751 2752 """ 2753 return None
2754 - def rotate( angle , interpolation ):
2755 """ 2756 Rotates a data field by a given angle. 2757 2758 Values that get outside of data field by the rotation are lost. 2759 Undefined values from outside of data field that get inside are set to 2760 data field minimum value. 2761 2762 @param angle: Rotation angle (in radians). I{(float)} 2763 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2764 @return: 2765 """ 2766 return None
2767 - def invert( x , y , z ):
2768 """ 2769 Reflects amd/or inverts a data field. 2770 2771 In the case of value reflection, it's inverted about the mean value. 2772 2773 @param x: B{C{True}} to reflect about X axis (i.e., vertically). I{(bool)} 2774 @param y: B{C{True}} to reflect about Y axis (i.e., horizontally). I{(bool)} 2775 @param z: B{C{True}} to invert in Z direction (i.e., invert values). I{(bool)} 2776 @return: 2777 """ 2778 return None
2779 - def fill( value ):
2780 """ 2781 Fills a data field with given value. 2782 2783 @param value: Value to be entered. I{(float)} 2784 @return: 2785 """ 2786 return None
2787 - def clear( ):
2788 """ 2789 Fills a data field with zeroes. 2790 2791 @return: 2792 """ 2793 return None
2794 - def multiply( value ):
2795 """ 2796 Multiplies all values in a data field by given value. 2797 2798 @param value: Value to multiply B{C{data_field}} with. I{(float)} 2799 @return: 2800 """ 2801 return None
2802 - def add( value ):
2803 """ 2804 Adds given value to all values in a data field. 2805 2806 @param value: Value to be added to data field values. I{(float)} 2807 @return: 2808 """ 2809 return None
2810 - def area_fill( col , row , width , height , value ):
2811 """ 2812 Fills a rectangular part of a data field with given value. 2813 2814 @param col: Upper-left column coordinate. I{(int)} 2815 @param row: Upper-left row coordinate. I{(int)} 2816 @param width: Area width (number of columns). I{(int)} 2817 @param height: Area height (number of rows). I{(int)} 2818 @param value: Value to be entered I{(float)} 2819 @return: 2820 """ 2821 return None
2822 - def area_clear( col , row , width , height ):
2823 """ 2824 Fills a rectangular part of a data field with zeroes. 2825 2826 @param col: Upper-left column coordinate. I{(int)} 2827 @param row: Upper-left row coordinate. I{(int)} 2828 @param width: Area width (number of columns). I{(int)} 2829 @param height: Area height (number of rows). I{(int)} 2830 @return: 2831 """ 2832 return None
2833 - def area_multiply( col , row , width , height , value ):
2834 """ 2835 Multiplies values in a rectangular part of a data field by given value 2836 2837 @param col: Upper-left column coordinate. I{(int)} 2838 @param row: Upper-left row coordinate. I{(int)} 2839 @param width: Area width (number of columns). I{(int)} 2840 @param height: Area height (number of rows). I{(int)} 2841 @param value: Value to multiply area with. I{(float)} 2842 @return: 2843 """ 2844 return None
2845 - def area_add( col , row , width , height , value ):
2846 """ 2847 Adds given value to all values in a rectangular part of a data field. 2848 2849 @param col: Upper-left column coordinate. I{(int)} 2850 @param row: Upper-left row coordinate. I{(int)} 2851 @param width: Area width (number of columns). I{(int)} 2852 @param height: Area height (number of rows). I{(int)} 2853 @param value: Value to be added to area values. I{(float)} 2854 @return: 2855 """ 2856 return None
2857 - def get_profile( data_line , scol , srow , ecol , erow , res , thickness , interpolation ):
2858 """ 2859 Extracts a possibly averaged profile from data field to a data line. 2860 2861 2862 @param data_line: A data line. It will be resized to B{C{res}} samples. It is 2863 possible to pass B{C{NULL}} to instantiate and return a new 2864 B{C{DataLine}}. I{(L{DataLine})} 2865 @param scol: The column the line starts at (inclusive). I{(int)} 2866 @param srow: The row the line starts at (inclusive). I{(int)} 2867 @param ecol: The column the line ends at (inclusive). I{(int)} 2868 @param erow: The row the line ends at (inclusive). I{(int)} 2869 @param res: Requested resolution of data line (the number of samples to take). 2870 If nonpositive, data line resolution is chosen to match B{C{data_field}}'s. I{(int)} 2871 @param thickness: Thickness of line to be averaged. I{(int)} 2872 @param interpolation: Interpolation type to use. I{(InterpolationType)} 2873 @return: B{C{data_line}} itself if it was not B{C{NULL}}, otherwise a newly created 2874 data line. 2875 2876 """ 2877 return None
2878 - def get_row( data_line , row ):
2879 """ 2880 Extracts a data field row into a data line. 2881 2882 @param data_line: A data line. It will be resized to width ot B{C{data_field}}. I{(L{DataLine})} 2883 @param row: Row index. I{(int)} 2884 @return: 2885 """ 2886 return None
2887 - def get_column( data_line , col ):
2888 """ 2889 Extracts a data field column into a data line. 2890 2891 @param data_line: A data line. It will be resized to height of B{C{data_field}}. I{(L{DataLine})} 2892 @param col: Column index. I{(int)} 2893 @return: 2894 """ 2895 return None
2896 - def set_row( data_line , row ):
2897 """ 2898 Sets a row in the data field to values of a data line. 2899 2900 Data line length must be equal to width of data field. 2901 2902 @param data_line: A data line. I{(L{DataLine})} 2903 @param row: Row index. I{(int)} 2904 @return: 2905 """ 2906 return None
2907 - def set_column( data_line , col ):
2908 """ 2909 Sets a column in the data field to values of a data line. 2910 2911 Data line length must be equal to height of data field. 2912 2913 @param data_line: A data line. I{(L{DataLine})} 2914 @param col: Column index. I{(int)} 2915 @return: 2916 """ 2917 return None
2918 - def get_row_part( data_line , row , _from , to ):
2919 """ 2920 Extracts part of a data field row into a data line. 2921 2922 @param data_line: A data line. It will be resized to the row part width. I{(L{DataLine})} 2923 @param row: Row index. I{(int)} 2924 @param _from: Start column index. I{(int)} 2925 @param to: End column index + 1. I{(int)} 2926 @return: 2927 """ 2928 return None
2929 - def get_column_part( data_line , col , _from , to ):
2930 """ 2931 Extracts part of a data field column into a data line. 2932 2933 @param data_line: A data line. It will be resized to the column part height. I{(L{DataLine})} 2934 @param col: Column index. I{(int)} 2935 @param _from: Start row index. I{(int)} 2936 @param to: End row index + 1. I{(int)} 2937 @return: 2938 """ 2939 return None
2940 - def set_row_part( data_line , row , _from , to ):
2941 """ 2942 Puts a data line into a data field row. 2943 2944 If data line length differs from B{C{to}}-B{C{from}}, it is resampled to this length. 2945 2946 @param data_line: A data line. I{(L{DataLine})} 2947 @param row: Row index. I{(int)} 2948 @param _from: Start row index. I{(int)} 2949 @param to: End row index + 1. I{(int)} 2950 @return: 2951 """ 2952 return None
2953 - def set_column_part( data_line , col , _from , to ):
2954 """ 2955 Puts a data line into data field column. 2956 2957 If data line length differs from B{C{to}}-B{C{from}}, it is resampled to this length. 2958 2959 @param data_line: A data line. I{(L{DataLine})} 2960 @param col: Column index. I{(int)} 2961 @param _from: Start row index. I{(int)} 2962 @param to: End row index + 1. I{(int)} 2963 @return: 2964 """ 2965 return None
2966 - def get_xder( col , row ):
2967 """ 2968 Computes central derivative in X direction. 2969 2970 On border points, one-side derivative is returned. 2971 2972 2973 @param col: Column index. I{(int)} 2974 @param row: Row index. I{(int)} 2975 @return: Derivative in X direction. 2976 2977 """ 2978 return None
2979 - def get_yder( col , row ):
2980 """ 2981 Computes central derivative in Y direction. 2982 2983 On border points, one-side derivative is returned. 2984 2985 Note the derivative is for legacy reasons calulcated for the opposite 2986 y direction than is usual elsewhere in Gwyddion, i.e. if values increase 2987 with increasing row number, the returned value is negative. 2988 2989 2990 @param col: Column index. I{(int)} 2991 @param row: Row index. I{(int)} 2992 @return: Derivative in Y direction 2993 2994 """ 2995 return None
2996 - def get_angder( col , row , theta ):
2997 """ 2998 Computes derivative in direction specified by given angle. 2999 3000 3001 @param col: Column index. I{(int)} 3002 @param row: Row index. I{(int)} 3003 @param theta: Angle defining the direction (in radians, counterclockwise). I{(float)} 3004 @return: Derivative in direction given by angle B{C{theta}}. 3005 3006 """ 3007 return None
3008 - def xdwt( wt_coefs , direction , minsize ):
3009 """ 3010 Performs steps of the X-direction image wavelet decomposition. 3011 3012 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 3013 B{C{minsize}} = B{C{dfield}}->xres/2 to perform one step of decomposition 3014 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 3015 3016 3017 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 3018 @param direction: Transform direction. I{(TransformDirection)} 3019 @param minsize: size of minimal transform result block I{(int)} 3020 @return: 3021 """ 3022 return None
3023 - def ydwt( wt_coefs , direction , minsize ):
3024 """ 3025 Performs steps of the Y-direction image wavelet decomposition. 3026 3027 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 3028 B{C{minsize}} = B{C{dfield}}->yres/2 to perform one step of decomposition 3029 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 3030 3031 3032 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 3033 @param direction: Transform direction. I{(TransformDirection)} 3034 @param minsize: size of minimal transform result block I{(int)} 3035 @return: 3036 """ 3037 return None
3038 - def dwt( wt_coefs , direction , minsize ):
3039 """ 3040 Performs steps of the 2D image wavelet decomposition. 3041 3042 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 3043 B{C{minsize}} = B{C{dfield}}->xres/2 to perform one step of decomposition 3044 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 3045 3046 3047 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 3048 @param direction: Transform direction. I{(TransformDirection)} 3049 @param minsize: size of minimal transform result block I{(int)} 3050 @return: 3051 """ 3052 return None
3053 - def dwt_mark_anisotropy( mask , wt_coefs , ratio , lowlimit ):
3054 return None
3055 - def elliptic_area_fill( col , row , width , height , value ):
3056 """ 3057 Fills an elliptic region of a data field with given value. 3058 3059 The elliptic region is defined by its bounding box which must be completely 3060 contained in the data field. 3061 3062 3063 @param col: Upper-left bounding box column coordinate. I{(int)} 3064 @param row: Upper-left bounding box row coordinate. I{(int)} 3065 @param width: Bounding box width (number of columns). I{(int)} 3066 @param height: Bounding box height (number of rows). I{(int)} 3067 @param value: Value to be entered. I{(float)} 3068 @return: The number of filled values. 3069 3070 """ 3071 return None
3072 - def elliptic_area_extract( col , row , width , height , data ):
3073 """ 3074 Extracts values from an elliptic region of a data field. 3075 3076 The elliptic region is defined by its bounding box which must be completely 3077 contained in the data field. 3078 3079 3080 @param col: Upper-left bounding box column coordinate. I{(int)} 3081 @param row: Upper-left bounding box row coordinate. I{(int)} 3082 @param width: Bounding box width (number of columns). I{(int)} 3083 @param height: Bounding box height (number of rows). I{(int)} 3084 @param data: Location to store the extracted values to. Its size has to be 3085 sufficient to contain all the extracted values. As a conservative 3086 estimate B{C{width}}*B{C{height}} can be used, or the 3087 size can be calculated with L{DataField.get_elliptic_area_size}(). I{(gdouble*)} 3088 @return: The number of extracted values. 3089 3090 """ 3091 return None
3092 - def elliptic_area_unextract( col , row , width , height , data ):
3093 """ 3094 Puts values back to an elliptic region of a data field. 3095 3096 The elliptic region is defined by its bounding box which must be completely 3097 contained in the data field. 3098 3099 This method does the reverse of L{DataField.elliptic_area_extract}() 3100 allowing to implement pixel-wise filters on elliptic areas. Values from 3101 B{C{data}} are put back to the same positions 3102 L{DataField.elliptic_area_extract}() took them from. 3103 3104 @param col: Upper-left bounding box column coordinate. I{(int)} 3105 @param row: Upper-left bounding box row coordinate. I{(int)} 3106 @param width: Bounding box width (number of columns). I{(int)} 3107 @param height: Bounding box height (number of rows). I{(int)} 3108 @param data: The values to put back. It must be the same array as in previous 3109 L{DataField.elliptic_area_extract}(). I{(const-gdouble*)} 3110 @return: 3111 """ 3112 return None
3113 - def circular_area_fill( col , row , radius , value ):
3114 """ 3115 Fills an elliptic region of a data field with given value. 3116 3117 3118 @param col: Row index of circular area centre. I{(int)} 3119 @param row: Column index of circular area centre. I{(int)} 3120 @param radius: Circular area radius (in pixels). Any value is allowed, although 3121 to get areas that do not deviate from true circles after 3122 pixelization too much, half-integer values are recommended, 3123 integer values are NOT recommended. I{(float)} 3124 @param value: Value to be entered. I{(float)} 3125 @return: The number of filled values. 3126 3127 """ 3128 return None
3129 - def circular_area_extract( col , row , radius , data ):
3130 """ 3131 Extracts values from a circular region of a data field. 3132 3133 3134 @param col: Row index of circular area centre. I{(int)} 3135 @param row: Column index of circular area centre. I{(int)} 3136 @param radius: Circular area radius (in pixels). See 3137 L{DataField.circular_area_extract_with_pos}() for caveats. I{(float)} 3138 @param data: Location to store the extracted values to. See 3139 L{DataField.circular_area_extract_with_pos}(). I{(gdouble*)} 3140 @return: The number of extracted values. It can be zero when the inside of 3141 the circle does not intersect with the data field. 3142 3143 """ 3144 return None
3145 - def UNIMPLEMENTED_circular_area_extract_with_pos( col , row , radius , data , xpos , ypos ):
3146 """ 3147 Extracts values with positions from a circular region of a data field. 3148 3149 The row and column indices stored to B{C{xpos}} and B{C{ypos}} are relative to the 3150 area centre, i.e. to (B{C{col}}, B{C{row}}). The central pixel will therefore have 3151 0 at the corresponding position in both B{C{xpos}} and B{C{ypos}}. 3152 3153 Since: 2.2 3154 3155 @param col: Row index of circular area centre. I{(int)} 3156 @param row: Column index of circular area centre. I{(int)} 3157 @param radius: Circular area radius (in pixels). Any value is allowed, although 3158 to get areas that do not deviate from true circles after 3159 pixelization too much, half-integer values are recommended, 3160 integer radii are NOT recommended. I{(float)} 3161 @param data: Location to store the extracted values to. Its size has to be 3162 sufficient to contain all the extracted values. As a conservative 3163 estimate (2*floor(B{C{radius}})+1)^2 can be used, or the size can be 3164 calculated with L{DataField.get_circular_area_size}(). I{(gdouble*)} 3165 @param xpos: Location to store relative column indices of values in B{C{data}} to, 3166 the size requirements are the same as for B{C{data}}. I{(int)} 3167 @param ypos: Location to store relative tow indices of values in B{C{data}} to, 3168 the size requirements are the same as for B{C{data}}. I{(int)} 3169 @return: The number of extracted values. It can be zero when the inside of 3170 the circle does not intersect with the data field. 3171 3172 3173 """ 3174 return None
3175 - def circular_area_unextract( col , row , radius , data ):
3176 """ 3177 Puts values back to a circular region of a data field. 3178 3179 This method does the reverse of L{DataField.circular_area_extract}() 3180 allowing to implement pixel-wise filters on circular areas. Values from 3181 B{C{data}} are put back to the same positions 3182 L{DataField.circular_area_extract}() took them from. 3183 3184 @param col: Row index of circular area centre. I{(int)} 3185 @param row: Column index of circular area centre. I{(int)} 3186 @param radius: Circular area radius (in pixels). I{(float)} 3187 @param data: The values to put back. It must be the same array as in previous 3188 L{DataField.circular_area_unextract}(). I{(const-gdouble*)} 3189 @return: 3190 """ 3191 return None
3192 - def normalize( ):
3193 """ 3194 Normalizes data in a data field to range 0.0 to 1.0. 3195 3196 It is equivalent to L{DataField.renormalize}(B{C{data_field}}, 1.0, 0.0); 3197 3198 If B{C{data_field}} is filled with only one value, it is changed to 0.0. 3199 3200 @return: 3201 """ 3202 return None
3203 - def renormalize( range , offset ):
3204 """ 3205 Transforms data in a data field with first linear function to given range. 3206 3207 When B{C{range}} is positive, the new data range is (B{C{offset}}, B{C{offset}}+B{C{range}}); 3208 when B{C{range}} is negative, the new data range is (B{C{offset}}-B{C{range}}, B{C{offset}}). 3209 In neither case the data are flipped, negative range only means different 3210 selection of boundaries. 3211 3212 When B{C{range}} is zero, this method is equivalent to 3213 L{DataField.fill}(B{C{data_field}}, B{C{offset}}). 3214 3215 @param range: New data interval size. I{(float)} 3216 @param offset: New data interval offset. I{(float)} 3217 @return: 3218 """ 3219 return None
3220 - def threshold( threshval , bottom , top ):
3221 """ 3222 Tresholds values of a data field. 3223 3224 Values smaller than B{C{threshold}} are set to value B{C{bottom}}, values higher 3225 than B{C{threshold}} or equal to it are set to value B{C{top}} 3226 3227 3228 @param threshval: Threshold value. I{(float)} 3229 @param bottom: Lower replacement value. I{(float)} 3230 @param top: Upper replacement value. I{(float)} 3231 @return: The total number of values above threshold. 3232 3233 """ 3234 return None
3235 - def area_threshold( col , row , width , height , threshval , bottom , top ):
3236 """ 3237 Tresholds values of a rectangular part of a data field. 3238 3239 Values smaller than B{C{threshold}} are set to value B{C{bottom}}, values higher 3240 than B{C{threshold}} or equal to it are set to value B{C{top}} 3241 3242 3243 @param col: Upper-left column coordinate. I{(int)} 3244 @param row: Upper-left row coordinate. I{(int)} 3245 @param width: Area width (number of columns). I{(int)} 3246 @param height: Area height (number of rows). I{(int)} 3247 @param threshval: Threshold value. I{(float)} 3248 @param bottom: Lower replacement value. I{(float)} 3249 @param top: Upper replacement value. I{(float)} 3250 @return: The total number of values above threshold. 3251 3252 """ 3253 return None
3254 - def clamp( bottom , top ):
3255 """ 3256 Limits data field values to a range. 3257 3258 3259 @param bottom: Lower limit value. I{(float)} 3260 @param top: Upper limit value. I{(float)} 3261 @return: The number of changed values, i.e., values that were outside 3262 [B{C{bottom}}, B{C{top}}]. 3263 3264 """ 3265 return None
3266 - def area_clamp( col , row , width , height , bottom , top ):
3267 """ 3268 Limits values in a rectangular part of a data field to a range. 3269 3270 3271 @param col: Upper-left column coordinate. I{(int)} 3272 @param row: Upper-left row coordinate. I{(int)} 3273 @param width: Area width (number of columns). I{(int)} 3274 @param height: Area height (number of rows). I{(int)} 3275 @param bottom: Lower limit value. I{(float)} 3276 @param top: Upper limit value. I{(float)} 3277 @return: The number of changed values, i.e., values that were outside 3278 [B{C{bottom}}, B{C{top}}]. 3279 3280 """ 3281 return None
3282 - def area_gather( result , buffer , hsize , vsize , average , col , row , width , height ):
3283 """ 3284 Sums or averages values in reactangular areas around each sample in a data 3285 field. 3286 3287 When the gathered area extends out of calculation area, only samples from 3288 their intersection are taken into the local sum (or average). 3289 3290 There are no restrictions on values of B{C{hsize}} and B{C{vsize}} with regard to 3291 B{C{width}} and B{C{height}}, but they have to be positive. 3292 3293 The result is calculated by the means of two-dimensional rolling sums. 3294 One one hand it means the calculation time depends linearly on 3295 (B{C{width}} + B{C{hsize}})*(B{C{height}} + B{C{vsize}}) instead of 3296 B{C{width}}*B{C{hsize}}*B{C{height}}*B{C{vsize}}. On the other hand it means absolute rounding 3297 errors of all output values are given by the largest input values, that is 3298 relative precision of results small in absolute value may be poor. 3299 3300 @param result: A data field to put the result to, it may be B{C{data_field}} itself. I{(L{DataField})} 3301 @param buffer: A data field to use as a scratch area, its size must be at least 3302 B{C{width}}*B{C{height}}. May be B{C{NULL}} to allocate a private temporary 3303 buffer. I{(L{DataField})} 3304 @param col: Upper-left column coordinate. I{(int)} 3305 @param row: Upper-left row coordinate. I{(int)} 3306 @param width: Area width (number of columns). I{(int)} 3307 @param height: Area height (number of rows). I{(int)} 3308 @param hsize: Horizontal size of gathered area. The area is centered around 3309 each sample if B{C{hsize}} is odd, it extends one pixel more to the 3310 right if B{C{hsize}} is even. I{(int)} 3311 @param vsize: Vertical size of gathered area. The area is centered around 3312 each sample if B{C{vsize}} is odd, it extends one pixel more down 3313 if B{C{vsize}} is even. I{(int)} 3314 @param average: B{C{True}} to divide resulting sums by the number of involved samples 3315 to get averages instead of sums. I{(bool)} 3316 @return: 3317 """ 3318 return None
3319 - def convolve( kernel_field ):
3320 """ 3321 Convolves a data field with given kernel. 3322 3323 @param kernel_field: Kenrel field to convolve B{C{data_field}} with. I{(L{DataField})} 3324 @return: 3325 """ 3326 return None
3327 - def area_convolve( kernel_field , col , row , width , height ):
3328 """ 3329 Convolves a rectangular part of a data field with given kernel. 3330 3331 @param kernel_field: Kenrel field to convolve B{C{data_field}} with. I{(L{DataField})} 3332 @param col: Upper-left column coordinate. I{(int)} 3333 @param row: Upper-left row coordinate. I{(int)} 3334 @param width: Area width (number of columns). I{(int)} 3335 @param height: Area height (number of rows). I{(int)} 3336 @return: 3337 """ 3338 return None
3339 - def convolve_1d( kernel_line , orientation ):
3340 """ 3341 Convolves a data field with given linear kernel. 3342 3343 Since: 2.4 3344 3345 @param kernel_line: Kenrel line to convolve B{C{data_field}} with. I{(L{DataLine})} 3346 @param orientation: Filter orientation (see L{DataField.area_convolve_1d}()). I{(Orientation)} 3347 @return: 3348 """ 3349 return None
3350 - def area_convolve_1d( kernel_line , orientation , col , row , width , height ):
3351 """ 3352 Convolves a rectangular part of a data field with given linear kernel. 3353 3354 For large separable kernels it can be more efficient to use a sequence of 3355 horizontal and vertical convolutions instead one 2D convolution. 3356 3357 Since: 2.4 3358 3359 @param kernel_line: Kernel line to convolve B{C{data_field}} with. I{(L{DataLine})} 3360 @param orientation: Filter orientation (B{C{ORIENTATION_HORIZONTAL}} for 3361 row-wise convolution, B{C{ORIENTATION_VERTICAL}} for 3362 column-wise convolution). I{(Orientation)} 3363 @param col: Upper-left column coordinate. I{(int)} 3364 @param row: Upper-left row coordinate. I{(int)} 3365 @param width: Area width (number of columns). I{(int)} 3366 @param height: Area height (number of rows). I{(int)} 3367 @return: 3368 """ 3369 return None
3370 - def filter_median( size ):
3371 """ 3372 Filters a data field with median filter. 3373 3374 @param size: Size of area to take median of. I{(int)} 3375 @return: 3376 """ 3377 return None
3378 - def area_filter_median( size , col , row , width , height ):
3379 """ 3380 Filters a rectangular part of a data field with median filter. 3381 3382 @param size: Size of area to take median of. I{(int)} 3383 @param col: Upper-left column coordinate. I{(int)} 3384 @param row: Upper-left row coordinate. I{(int)} 3385 @param width: Area width (number of columns). I{(int)} 3386 @param height: Area height (number of rows). I{(int)} 3387 @return: 3388 """ 3389 return None
3390 - def filter_mean( size ):
3391 """ 3392 Filters a data field with mean filter of size B{C{size}}. 3393 3394 @param size: Averaged area size. I{(int)} 3395 @return: 3396 """ 3397 return None
3398 - def area_filter_mean( size , col , row , width , height ):
3399 """ 3400 Filters a rectangular part of a data field with mean filter of size B{C{size}}. 3401 3402 This method is a simple L{DataField.area_gather}() wrapper. 3403 3404 @param size: Averaged area size. I{(int)} 3405 @param col: Upper-left column coordinate. I{(int)} 3406 @param row: Upper-left row coordinate. I{(int)} 3407 @param width: Area width (number of columns). I{(int)} 3408 @param height: Area height (number of rows). I{(int)} 3409 @return: 3410 """ 3411 return None
3412 - def filter_conservative( size ):
3413 """ 3414 Filters a data field with conservative denoise filter. 3415 3416 @param size: Filtered area size. I{(int)} 3417 @return: 3418 """ 3419 return None
3420 - def area_filter_conservative( size , col , row , width , height ):
3421 """ 3422 Filters a rectangular part of a data field with conservative denoise filter. 3423 3424 @param size: Filtered area size. I{(int)} 3425 @param col: Upper-left column coordinate. I{(int)} 3426 @param row: Upper-left row coordinate. I{(int)} 3427 @param width: Area width (number of columns). I{(int)} 3428 @param height: Area height (number of rows). I{(int)} 3429 @return: 3430 """ 3431 return None
3432 - def filter_laplacian( ):
3433 """ 3434 Filters a data field with Laplacian filter. 3435 3436 @return: 3437 """ 3438 return None
3439 - def area_filter_laplacian( col , row , width , height ):
3440 """ 3441 Filters a rectangular part of a data field with Laplacian filter. 3442 3443 @param col: Upper-left column coordinate. I{(int)} 3444 @param row: Upper-left row coordinate. I{(int)} 3445 @param width: Area width (number of columns). I{(int)} 3446 @param height: Area height (number of rows). I{(int)} 3447 @return: 3448 """ 3449 return None
3451 """ 3452 Filters a data field with Laplacian of Gaussians filter. 3453 3454 Since: 2.23 3455 3456 @return: 3457 """ 3458 return None
3459 - def area_filter_laplacian_of_gaussians( col , row , width , height ):
3460 """ 3461 Filters a rectangular part of a data field 3462 with Laplacian of Gaussians filter. 3463 3464 Since: 2.23 3465 3466 @param col: Upper-left column coordinate. I{(int)} 3467 @param row: Upper-left row coordinate. I{(int)} 3468 @param width: Area width (number of columns). I{(int)} 3469 @param height: Area height (number of rows). I{(int)} 3470 @return: 3471 """ 3472 return None
3473 - def filter_sobel( orientation ):
3474 """ 3475 Filters a data field with a directional Sobel filter. 3476 3477 @param orientation: Filter orientation. I{(Orientation)} 3478 @return: 3479 """ 3480 return None
3481 - def area_filter_sobel( orientation , col , row , width , height ):
3482 """ 3483 Filters a rectangular part of a data field with a directional Sobel filter. 3484 3485 @param orientation: Filter orientation. I{(Orientation)} 3486 @param col: Upper-left column coordinate. I{(int)} 3487 @param row: Upper-left row coordinate. I{(int)} 3488 @param width: Area width (number of columns). I{(int)} 3489 @param height: Area height (number of rows). I{(int)} 3490 @return: 3491 """ 3492 return None
3493 - def filter_sobel_total( ):
3494 """ 3495 Filters a data field with total Sobel filter. 3496 3497 Since: 2.31 3498 3499 @return: 3500 """ 3501 return None
3502 - def filter_prewitt( orientation ):
3503 """ 3504 Filters a data field with Prewitt filter. 3505 3506 @param orientation: Filter orientation. I{(Orientation)} 3507 @return: 3508 """ 3509 return None
3510 - def area_filter_prewitt( orientation , col , row , width , height ):
3511 """ 3512 Filters a rectangular part of a data field with a directional Prewitt 3513 filter. 3514 3515 @param orientation: Filter orientation. I{(Orientation)} 3516 @param col: Upper-left column coordinate. I{(int)} 3517 @param row: Upper-left row coordinate. I{(int)} 3518 @param width: Area width (number of columns). I{(int)} 3519 @param height: Area height (number of rows). I{(int)} 3520 @return: 3521 """ 3522 return None
3523 - def filter_prewitt_total( ):
3524 """ 3525 Filters a data field with total Prewitt filter. 3526 3527 Since: 2.31 3528 3529 @return: 3530 """ 3531 return None
3532 - def filter_slope( xder , yder ):
3533 """ 3534 Calculates x and y derivaties for an entire field. 3535 3536 The derivatives are calculated as the simple symmetrical differences (in 3537 physical units, not pixel-wise), except at the edges where the differences 3538 are one-sided. 3539 3540 Since: 2.37 3541 3542 @param xder: Data field where the x-derivarive is to be stored, or B{C{NULL}} if you 3543 are only interested in the y-derivarive. I{(L{DataField})} 3544 @param yder: Data field where the y-derivarive is to be stored, or B{C{NULL}} if you 3545 are only interested in the x-derivarive. I{(L{DataField})} 3546 @return: 3547 """ 3548 return None
3549 - def filter_dechecker( ):
3550 """ 3551 Filters a data field with 5x5 checker pattern removal filter. 3552 3553 Since: 2.1 3554 3555 @return: 3556 """ 3557 return None
3558 - def area_filter_dechecker( col , row , width , height ):
3559 """ 3560 Filters a rectangular part of a data field with 5x5 checker pattern removal 3561 filter. 3562 3563 Since: 2.1 3564 3565 @param col: Upper-left column coordinate. I{(int)} 3566 @param row: Upper-left row coordinate. I{(int)} 3567 @param width: Area width (number of columns). I{(int)} 3568 @param height: Area height (number of rows). I{(int)} 3569 @return: 3570 """ 3571 return None
3572 - def filter_gaussian( sigma ):
3573 """ 3574 Filters a data field with a Gaussian filter. 3575 3576 Since: 2.4 3577 3578 @param sigma: The sigma parameter of the Gaussian. I{(float)} 3579 @return: 3580 """ 3581 return None
3582 - def area_filter_gaussian( sigma , col , row , width , height ):
3583 """ 3584 Filters a rectangular part of a data field with a Gaussian filter. 3585 3586 The Gausian is normalized, i.e. it is sum-preserving. 3587 3588 Since: 2.4 3589 3590 @param sigma: The sigma parameter of the Gaussian. I{(float)} 3591 @param col: Upper-left column coordinate. I{(int)} 3592 @param row: Upper-left row coordinate. I{(int)} 3593 @param width: Area width (number of columns). I{(int)} 3594 @param height: Area height (number of rows). I{(int)} 3595 @return: 3596 """ 3597 return None
3598 - def filter_minimum( size ):
3599 """ 3600 Filters a data field with minimum filter. 3601 3602 @param size: Neighbourhood size for minimum search. I{(int)} 3603 @return: 3604 """ 3605 return None
3606 - def area_filter_minimum( size , col , row , width , height ):
3607 """ 3608 Filters a rectangular part of a data field with minimum filter. 3609 3610 This operation is often called erosion filter. 3611 3612 @param size: Neighbourhood size for minimum search. I{(int)} 3613 @param col: Upper-left column coordinate. I{(int)} 3614 @param row: Upper-left row coordinate. I{(int)} 3615 @param width: Area width (number of columns). I{(int)} 3616 @param height: Area height (number of rows). I{(int)} 3617 @return: 3618 """ 3619 return None
3620 - def filter_maximum( size ):
3621 """ 3622 Filters a data field with maximum filter. 3623 3624 @param size: Neighbourhood size for maximum search. I{(int)} 3625 @return: 3626 """ 3627 return None
3628 - def area_filter_maximum( size , col , row , width , height ):
3629 """ 3630 Filters a rectangular part of a data field with maximum filter. 3631 3632 This operation is often called dilation filter. 3633 3634 @param size: Neighbourhood size for maximum search. I{(int)} 3635 @param col: Upper-left column coordinate. I{(int)} 3636 @param row: Upper-left row coordinate. I{(int)} 3637 @param width: Area width (number of columns). I{(int)} 3638 @param height: Area height (number of rows). I{(int)} 3639 @return: 3640 """ 3641 return None
3642 - def filter_rms( size ):
3643 """ 3644 Filters a data field with RMS filter. 3645 3646 @param size: Area size. I{(int)} 3647 @return: 3648 """ 3649 return None
3650 - def area_filter_rms( size , col , row , width , height ):
3651 """ 3652 Filters a rectangular part of a data field with RMS filter of size B{C{size}}. 3653 3654 RMS filter computes root mean square in given area. 3655 3656 @param size: Area size. I{(int)} 3657 @param col: Upper-left column coordinate. I{(int)} 3658 @param row: Upper-left row coordinate. I{(int)} 3659 @param width: Area width (number of columns). I{(int)} 3660 @param height: Area height (number of rows). I{(int)} 3661 @return: 3662 """ 3663 return None
3664 - def filter_kuwahara( ):
3665 """ 3666 Filters a data field with Kuwahara filter. 3667 3668 @return: 3669 """ 3670 return None
3671 - def area_filter_kuwahara( col , row , width , height ):
3672 """ 3673 Filters a rectangular part of a data field with a Kuwahara 3674 (edge-preserving smoothing) filter. 3675 3676 @param col: Upper-left column coordinate. I{(int)} 3677 @param row: Upper-left row coordinate. I{(int)} 3678 @param width: Area width (number of columns). I{(int)} 3679 @param height: Area height (number of rows). I{(int)} 3680 @return: 3681 """ 3682 return None
3683 - def filter_canny( threshold ):
3684 """ 3685 Filters a rectangular part of a data field with canny edge detector filter. 3686 3687 @param threshold: Slope detection threshold (range 0..1). I{(float)} 3688 @return: 3689 """ 3690 return None
3691 - def shade( target_field , theta , phi ):
3692 """ 3693 Shades a data field. 3694 3695 @param target_field: A data field to put the shade to. It will be resized to 3696 match B{C{data_field}}. I{(L{DataField})} 3697 @param theta: Shading angle (in radians, from north pole). I{(float)} 3698 @param phi: Shade orientation in xy plane (in radians, counterclockwise). I{(float)} 3699 @return: 3700 """ 3701 return None
3702 - def filter_harris( y_gradient , result , neighbourhood , alpha ):
3703 return None
3704 - def fractal_partitioning( xresult , yresult , interpolation ):
3705 """ 3706 Computes data for log-log plot by partitioning. 3707 3708 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3709 they will contain corresponding values at each position. 3710 3711 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3712 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3713 @param interpolation: Interpolation type. I{(InterpolationType)} 3714 @return: 3715 """ 3716 return None
3717 - def fractal_cubecounting( xresult , yresult , interpolation ):
3718 """ 3719 Computes data for log-log plot by cube counting. 3720 3721 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3722 they will contain corresponding values at each position. 3723 3724 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3725 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3726 @param interpolation: Interpolation type. I{(InterpolationType)} 3727 @return: 3728 """ 3729 return None
3730 - def fractal_triangulation( xresult , yresult , interpolation ):
3731 """ 3732 Computes data for log-log plot by triangulation. 3733 3734 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3735 they will contain corresponding values at each position. 3736 3737 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3738 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3739 @param interpolation: Interpolation type. I{(InterpolationType)} 3740 @return: 3741 """ 3742 return None
3743 - def fractal_psdf( xresult , yresult , interpolation ):
3744 """ 3745 Computes data for log-log plot by spectral density method. 3746 3747 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3748 they will contain corresponding values at each position. 3749 3750 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3751 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3752 @param interpolation: Interpolation type. I{(InterpolationType)} 3753 @return: 3754 """ 3755 return None
3756 - def fractal_correction( mask_field , interpolation ):
3757 """ 3758 Replaces data under mask with interpolated values using fractal 3759 interpolation. 3760 3761 @param mask_field: Mask of places to be corrected. I{(L{DataField})} 3762 @param interpolation: Interpolation type. I{(InterpolationType)} 3763 @return: 3764 """ 3765 return None
3766 - def grains_mark_curvature( grain_field , threshval , below ):
3767 """ 3768 Marks data that are above/below curvature threshold. 3769 3770 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 3771 @param threshval: Relative curvature threshold, in percents. I{(float)} 3772 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 3773 threshold are marked. I{(bool)} 3774 @return: 3775 """ 3776 return None
3777 - def grains_mark_watershed( grain_field , locate_steps , locate_thresh , locate_dropsize , wshed_steps , wshed_dropsize , prefilter , below ):
3778 """ 3779 Performs watershed algorithm. 3780 3781 @param grain_field: Result of marking (mask). I{(L{DataField})} 3782 @param locate_steps: Locating algorithm steps. I{(int)} 3783 @param locate_thresh: Locating algorithm threshold. I{(int)} 3784 @param locate_dropsize: Locating drop size. I{(float)} 3785 @param wshed_steps: Watershed steps. I{(int)} 3786 @param wshed_dropsize: Watershed drop size. I{(float)} 3787 @param prefilter: Use prefiltering. I{(bool)} 3788 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 3789 @return: 3790 """ 3791 return None
3792 - def grains_remove_grain( col , row ):
3793 """ 3794 Removes one grain at given position. 3795 3796 3797 @param col: Column inside a grain. I{(int)} 3798 @param row: Row inside a grain. I{(int)} 3799 @return: B{C{True}} if a grain was actually removed (i.e., (B{C{col}},B{C{row}}) was 3800 inside a grain). 3801 3802 """ 3803 return None
3804 - def grains_extract_grain( col , row ):
3805 """ 3806 Removes all grains except that one at given position. 3807 3808 If there is no grain at (B{C{col}}, B{C{row}}), all grains are removed. 3809 3810 3811 @param col: Column inside a grain. I{(int)} 3812 @param row: Row inside a grain. I{(int)} 3813 @return: B{C{True}} if a grain remained (i.e., (B{C{col}},B{C{row}}) was inside a grain). 3814 3815 """ 3816 return None
3817 - def grains_remove_by_number( number ):
3818 """ 3819 Removes grain identified by B{C{number}}. 3820 3821 Since: 2.35 3822 3823 @param number: Grain number was filled by L{DataField.number_grains}(). I{(int)} 3824 @return: 3825 """ 3826 return None
3827 - def grains_remove_by_size( size ):
3828 """ 3829 Removes all grains below specified area. 3830 3831 @param size: Grain area threshold, in square pixels. I{(int)} 3832 @return: 3833 """ 3834 return None
3835 - def grains_remove_by_height( grain_field , threshval , below ):
3836 """ 3837 Removes grains that are higher/lower than given threshold value. 3838 3839 @param grain_field: Field of marked grains (mask) I{(L{DataField})} 3840 @param threshval: Relative height threshold, in percents. I{(float)} 3841 @param below: If B{C{True}}, grains below threshold are removed, otherwise grains above 3842 threshold are removed. I{(bool)} 3843 @return: 3844 """ 3845 return None
3847 """ 3848 Removes all grains that touch field borders. 3849 3850 Since: 2.30 3851 3852 @return: 3853 """ 3854 return None
3855 - def UNIMPLEMENTED_grains_watershed_init( grain_field , locate_steps , locate_thresh , locate_dropsize , wshed_steps , wshed_dropsize , prefilter , below ):
3856 """ 3857 Initializes the watershed algorithm. 3858 3859 This iterator reports its state as B{C{WatershedStateType}}. 3860 3861 3862 @param grain_field: Result of marking (mask). I{(L{DataField})} 3863 @param locate_steps: Locating algorithm steps. I{(int)} 3864 @param locate_thresh: Locating algorithm threshold. I{(int)} 3865 @param locate_dropsize: Locating drop size. I{(float)} 3866 @param wshed_steps: Watershed steps. I{(int)} 3867 @param wshed_dropsize: Watershed drop size. I{(float)} 3868 @param prefilter: Use prefiltering. I{(bool)} 3869 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 3870 @return: A new watershed iterator. 3871 3872 """ 3873 return None
3874 - def grains_mark_height( grain_field , threshval , below ):
3875 """ 3876 Marks data that are above/below height threshold. 3877 3878 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 3879 @param threshval: Relative height threshold, in percents. I{(float)} 3880 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 3881 threshold are marked. I{(bool)} 3882 @return: 3883 """ 3884 return None
3885 - def grains_mark_slope( grain_field , threshval , below ):
3886 """ 3887 Marks data that are above/below slope threshold. 3888 3889 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 3890 @param threshval: Relative slope threshold, in percents. I{(float)} 3891 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 3892 threshold are marked. I{(bool)} 3893 @return: 3894 """ 3895 return None
3896 - def otsu_threshold( ):
3897 """ 3898 Finds Otsu's height threshold for a data field. 3899 3900 The Otsu's threshold is optimal in the sense that it minimises the 3901 inter-class variances of two classes of pixels: above and below theshold. 3902 3903 Since: 2.37 3904 3905 @return: 3906 """ 3907 return None
3908 - def grains_add( add_field ):
3909 """ 3910 Adds B{C{add_field}} grains to B{C{grain_field}}. 3911 3912 Note: This function is equivalent to 3913 <literal>L{DataField.max_of_fields}(grain_field, grain_field, add_field);</literal> 3914 and it will be probably removed someday. 3915 3916 @param add_field: Field of marked grains (mask) to be added. I{(L{DataField})} 3917 @return: 3918 """ 3919 return None
3920 - def grains_intersect( intersect_field ):
3921 """ 3922 Performs intersection betweet two grain fields, 3923 result is stored in B{C{grain_field}}. 3924 3925 Note: This function is equivalent to 3926 <literal>L{DataField.min_of_fields}(grain_field, grain_field, intersect_field);</literal> 3927 and it will be probably removed someday. 3928 3929 @param intersect_field: Field of marked grains (mask). I{(L{DataField})} 3930 @return: 3931 """ 3932 return None
3933 - def number_grains( grains ):
3934 """ 3935 Create a tuple of integer grain numbers in the data field representing a 3936 mask. 3937 3938 3939 @return: tuple of grain numbers for each piel 3940 3941 """ 3942 return None
3944 """ 3945 Numbers grains in a periodic mask data field. 3946 3947 This function differs from L{DataField.number_grains}() by the assumption 3948 of periodicity, i.e. grains can touch across the opposite field edges. 3949 3950 Since: 2.38 3951 3952 @param grains: Zero-filled array of integers of equal size to B{C{mask_field}} to put 3953 grain numbers to. Empty space will be left 0, pixels inside a 3954 grain will be set to grain number. Grains are numbered 3955 sequentially 1, 2, 3, ... I{(gint*)} 3956 @return: The number of last grain (note they are numbered from 1). 3957 3958 3959 """ 3960 return None
3961 - def UNIMPLEMENTED_get_grain_bounding_boxes( ngrains , grains , bboxes ):
3962 """ 3963 Find bounding boxes of all grains. 3964 3965 Since: 2.3 3966 3967 @param ngrains: The number of grains as returned by 3968 L{DataField.number_grains}(). I{(int)} 3969 @param grains: Grain numbers filled with L{DataField.number_grains}(). I{(const-gint*)} 3970 @param bboxes: Array of size at least 4*(B{C{ngrains}}+1) to fill with grain bounding 3971 boxes (as usual zero does not correspond to any grain, grains 3972 start from 1). The bounding boxes are stored as quadruples of 3973 indices: (xmin, ymin, width, height). It can be B{C{NULL}} to allocate 3974 a new array. I{(gint*)} 3975 @return: Either B{C{bboxes}} (if it was not B{C{NULL}}), or a newly allocated array 3976 of size 4(B{C{ngrains}} + 1). 3977 3978 3979 """ 3980 return None
3981 - def UNIMPLEMENTED_grains_get_distribution( grain_field , distribution , ngrains , grains , quantity , nstats ):
3982 """ 3983 Computes distribution of requested grain characteristics. 3984 3985 Puts number of grains vs. grain value data into B{C{distribution}}, units, scales 3986 and offsets of B{C{distribution}} are updated accordingly. 3987 3988 Note the B{C{i}}-th bin is [B{C{i}}*B{C{dx}}+B{C{off}},(B{C{i}}+1)*B{C{dx}}+B{C{off}}] so the central value 3989 you probably want to use for plotting is (B{C{i}}+0.5)*B{C{dx}}+B{C{off}} (where B{C{dx}} is 3990 the B{C{distribution}} data line pixel size, B{C{off}} is its offset). 3991 3992 3993 @param grain_field: Data field (mask) of marked grains. Note if you pass 3994 non-B{C{NULL}} B{C{grains}} all grain information is taken from it and 3995 B{C{grain_field}} can be even B{C{NULL}} then. I{(L{DataField})} 3996 @param distribution: Data line to store grain distribution to. I{(L{DataLine})} 3997 @param grains: Grain numbers filled with L{DataField.number_grains}() if you 3998 have it, or B{C{NULL}} (the function then finds grain numbers itself 3999 which is not efficient for repeated use on the same grain field). I{(const-gint*)} 4000 @param ngrains: The number of grains as returned by 4001 L{DataField.number_grains}(). Ignored in B{C{grains}} is B{C{NULL}}. I{(int)} 4002 @param quantity: The quantity to calculate. I{(GrainQuantity)} 4003 @param nstats: The number of samples to take on the distribution function. If 4004 nonpositive, a suitable resolution is determined automatically. I{(int)} 4005 @return: A data line with the distribution: B{C{distribution}} itself if it was 4006 not B{C{NULL}}, otherwise a newly created B{C{DataLine}} caller must 4007 destroy. If there are no grains, B{C{NULL}} is returned and 4008 B{C{distribution}} is not changed. 4009 4010 """ 4011 return None
4012 - def grains_get_values( values , ngrains , grains , quantity ):
4013 """ 4014 Obtains values of one grain quantity for all grains. 4015 4016 The zeroth value corresponds to the empty space between grains and isn't 4017 meaningful in general. 4018 4019 4020 @param quantity: Grain quantity. I{(GrainQuantity)} 4021 @return: tuple of values of the grain quantity 4022 4023 """ 4024 return None
4025 - def UNIMPLEMENTED_grains_get_quantities( values , quantities , nquantities , ngrains , grains ):
4026 """ 4027 Calculates multiple characteristics of grains simultaneously. 4028 4029 See L{DataField.grains_get_values}() for some discussion. This function 4030 is more efficient if several grain quantities need to be calculated since 4031 L{DataField.grains_get_values}() can do lot of repeated work in such case. 4032 4033 Since: 2.22 4034 4035 @param values: Array of B{C{nquantities}} pointers to blocks of length B{C{ngrains}}+1 to 4036 put the calculated grain values to. Each block corresponds to one 4037 requested quantity. B{C{NULL}} can be passed to allocate and return a 4038 new array. I{(gdouble**)} 4039 @param quantities: Array of B{C{nquantities}} items that specify the requested 4040 B{C{GrainQuantity}} to put to corresponding items in B{C{values}}. 4041 Quantities can repeat. I{(const-GrainQuantity*)} 4042 @param nquantities: The number of requested different grain values. I{(int)} 4043 @param grains: Grain numbers filled with L{DataField.number_grains}(). I{(const-gint*)} 4044 @param ngrains: The number of grains as returned by 4045 L{DataField.number_grains}(). I{(int)} 4046 @return: B{C{values}} itself if it was not B{C{NULL}}, otherwise a newly allocated 4047 array that caller has to free with g_free(), including the 4048 contained arrays. 4049 4050 4051 """ 4052 return None
4053 - def area_grains_tgnd( target_line , col , row , width , height , below , nstats ):
4054 """ 4055 Calculates threshold grain number distribution. 4056 4057 This function is a simple L{DataField.area_grains_tgnd_range}() that 4058 calculates the distribution in the full range. 4059 4060 @param target_line: A data line to store the distribution to. It will be 4061 resampled to the requested width. I{(L{DataLine})} 4062 @param col: Upper-left column coordinate. I{(int)} 4063 @param row: Upper-left row coordinate. I{(int)} 4064 @param width: Area width (number of columns). I{(int)} 4065 @param height: Area height (number of rows). I{(int)} 4066 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 4067 @param nstats: The number of samples to take on the distribution function. If 4068 nonpositive, a suitable resolution is determined automatically. I{(int)} 4069 @return: 4070 """ 4071 return None
4072 - def area_grains_tgnd_range( target_line , col , row , width , height , min , max , below , nstats ):
4073 """ 4074 Calculates threshold grain number distribution in given height range. 4075 4076 This is the number of grains for each of B{C{nstats}} equidistant height 4077 threshold levels. For large B{C{nstats}} this function is much faster than the 4078 equivalent number of L{DataField.grains_mark_height}() calls. 4079 4080 @param target_line: A data line to store the distribution to. It will be 4081 resampled to the requested width. I{(L{DataLine})} 4082 @param col: Upper-left column coordinate. I{(int)} 4083 @param row: Upper-left row coordinate. I{(int)} 4084 @param width: Area width (number of columns). I{(int)} 4085 @param height: Area height (number of rows). I{(int)} 4086 @param min: Minimum threshold value. I{(float)} 4087 @param max: Maximum threshold value. I{(float)} 4088 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 4089 @param nstats: The number of samples to take on the distribution function. If 4090 nonpositive, a suitable resolution is determined automatically. I{(int)} 4091 @return: 4092 """ 4093 return None
4094 - def grains_splash_water( minima , locate_steps , locate_dropsize ):
4095 return None
4097 """ 4098 Performs Euclidean distance transform of a data field with grains. 4099 4100 Each non-zero value will be replaced with Euclidean distance to the grain 4101 boundary, measured in pixels. 4102 4103 Since: 2.36 4104 4105 @return: 4106 """ 4107 return None
4108 - def fill_voids( nonsimple ):
4109 """ 4110 Fills voids in grains in a data field representing a mask. 4111 4112 Voids in grains are zero pixels in B{C{data_field}} from which no path exists 4113 through other zero pixels to the field boundary. The paths are considered 4114 in 8-connectivity because grains themselves are considered in 4115 4-connectivity. 4116 4117 Since: 2.37 4118 4119 @param nonsimple: Pass B{C{True}} to fill also voids that are not simple-connected 4120 (e.g. ring-like). This can result in grain merging if a small 4121 grain is contained within a void. Pass B{C{False}} to fill only 4122 simple-connected grains. I{(bool)} 4123 @return: B{C{True}} if any voids were filled at all, B{C{False}} if no change was 4124 made. 4125 4126 4127 """ 4128 return None
4129 - def UNIMPLEMENTED_waterpour( result , grains ):
4130 """ 4131 Performs the classical Vincent watershed segmentation of a data field. 4132 4133 The segmentation always results in the entire field being masked with the 4134 exception of thin (8-connectivity) lines separating the segments (grains). 4135 4136 Compared to L{DataField.grains_mark_watershed}(), this algorithm is very 4137 fast. However, when used alone, it typically results in a serious 4138 oversegmentation as each local minimum gives raise to a grain. Furthermore, 4139 the full segmentation means that also pixels which would be considered 4140 outside any grain in the topographical sense will be assigned to some 4141 catchment basin. Therefore, pre- or postprocessing is usually necessary, 4142 using the gradient image or a more sophisticated method. 4143 4144 The function does not assign pixels with value B{C{HUGE_VAL}} or larger to any 4145 segment. This can be used to pre-mark certain areas explicitly as 4146 boundaries. 4147 4148 Since the algorithm numbers the grains as a side effect, you can pass a 4149 B{C{grains}} array and get the grain numbers immediatelly, avoiding the 4150 relatively (although not drastically) expensive 4151 L{DataField.number_grains}() call. 4152 4153 Since: 2.37 4154 4155 @param result: Data field that will be filled with the resulting mask. It will be 4156 resized to the dimensions of B{C{data_field}} and its properties set 4157 accordingly. I{(L{DataField})} 4158 @param grains: Optionally, an array with the same number of items as B{C{data_field}}. 4159 If non-B{C{NULL}}, it will be filled with grain numbers in the same 4160 manner as L{DataField.number_grains}(). Pass B{C{NULL}} to ignore. I{(gint*)} 4161 @return: The number of segments (grains) in the result, excluding the 4162 separators, i.e. the same convention as in 4163 L{DataField.number_grains}() is used. 4164 4165 4166 """ 4167 return None
4168 - def mark_extrema( extrema , maxima ):
4169 return None
4170 - def hough_line( x_gradient , y_gradient , result , hwidth , overlapping ):
4171 return None
4172 - def hough_circle( x_gradient , y_gradient , result , radius ):
4173 return None
4174 - def hough_line_strenghten( x_gradient , y_gradient , hwidth , threshold ):
4175 return None
4176 - def hough_circle_strenghten( x_gradient , y_gradient , radius , threshold ):
4177 return None
4178 - def UNIMPLEMENTED_get_local_maxima_list( xdata , ydata , zdata , ndata , skip , threshold , subpixel ):
4179 return None
4180 - def hough_polar_line_to_datafield( rho , theta , px1 , px2 , py1 , py2 ):
4181 return None
4182 - def a_1dfft( iin , rout , iout , orientation , windowing , direction , interpolation , preserverms , level ):
4183 """ 4184 Transforms all rows or columns in a data field with Fast Fourier Transform. 4185 4186 If requested a windowing and/or leveling is applied to preprocess data to 4187 obtain reasonable results. 4188 4189 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4190 transform which can be somewhat faster than complex-to-complex 4191 transform. I{(L{DataField})} 4192 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4193 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4194 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4195 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4196 columns. I{(Orientation)} 4197 @param windowing: Windowing type. I{(WindowingType)} 4198 @param direction: FFT direction. I{(TransformDirection)} 4199 @param interpolation: Interpolation type. 4200 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4201 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4202 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4203 line (the number can be interpreted as the first polynomial degree 4204 to keep, but only the enumerated three values are available). I{(int)} 4205 @return: 4206 """ 4207 return None
4208 - def area_1dfft( iin , rout , iout , col , row , width , height , orientation , windowing , direction , interpolation , preserverms , level ):
4209 """ 4210 Transforms all rows or columns in a rectangular part of a data field with 4211 Fast Fourier Transform. 4212 4213 If requested a windowing and/or leveling is applied to preprocess data to 4214 obtain reasonable results. 4215 4216 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4217 transform which can be somewhat faster than complex-to-complex 4218 transform. I{(L{DataField})} 4219 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4220 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4221 @param col: Upper-left column coordinate. I{(int)} 4222 @param row: Upper-left row coordinate. I{(int)} 4223 @param width: Area width (number of columns), must be at least 2 for horizontal 4224 transforms. I{(int)} 4225 @param height: Area height (number of rows), must be at least 2 for vertical 4226 transforms. I{(int)} 4227 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4228 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4229 columns. I{(Orientation)} 4230 @param windowing: Windowing type. I{(WindowingType)} 4231 @param direction: FFT direction. I{(TransformDirection)} 4232 @param interpolation: Interpolation type. 4233 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4234 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4235 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4236 lines (the number can be interpreted as the first polynomial degree 4237 to keep, but only the enumerated three values are available). I{(int)} 4238 @return: 4239 """ 4240 return None
4241 - def a_1dfft_raw( iin , rout , iout , orientation , direction ):
4242 """ 4243 Transforms all rows or columns in a data field with Fast Fourier Transform. 4244 4245 No leveling, windowing nor scaling is performed. 4246 4247 Since 2.8 the dimensions need not to be from the set of sizes returned 4248 by L{gwy_fft_find_nice_size}(). 4249 4250 Since: 2.1 4251 4252 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4253 transform. I{(L{DataField})} 4254 @param rout: Real output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4255 @param iout: Imaginary output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4256 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4257 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4258 columns. I{(Orientation)} 4259 @param direction: FFT direction. I{(TransformDirection)} 4260 @return: 4261 """ 4262 return None
4263 - def a_2dfft( iin , rout , iout , windowing , direction , interpolation , preserverms , level ):
4264 """ 4265 Calculates 2D Fast Fourier Transform of a rectangular a data field. 4266 4267 If requested a windowing and/or leveling is applied to preprocess data to 4268 obtain reasonable results. 4269 4270 Lateral dimensions, offsets and units are unchanged. See 4271 L{DataField.fft_postprocess}() for that. 4272 4273 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4274 transform which can be somewhat faster than complex-to-complex 4275 transform. I{(L{DataField})} 4276 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4277 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4278 @param windowing: Windowing type. I{(WindowingType)} 4279 @param direction: FFT direction. I{(TransformDirection)} 4280 @param interpolation: Interpolation type. I{(InterpolationType)} 4281 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4282 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4283 plane (the number can be interpreted as the first polynomial degree 4284 to keep, but only the enumerated three values are available). I{(int)} 4285 @return: 4286 """ 4287 return None
4288 - def area_2dfft( iin , rout , iout , col , row , width , height , windowing , direction , interpolation , preserverms , level ):
4289 """ 4290 Calculates 2D Fast Fourier Transform of a rectangular area of a data field. 4291 4292 If requested a windowing and/or leveling is applied to preprocess data to 4293 obtain reasonable results. 4294 4295 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4296 transform which can be somewhat faster than complex-to-complex 4297 transform. I{(L{DataField})} 4298 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4299 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4300 @param col: Upper-left column coordinate. I{(int)} 4301 @param row: Upper-left row coordinate. I{(int)} 4302 @param width: Area width (number of columns), must be at least 2. I{(int)} 4303 @param height: Area height (number of rows), must be at least 2. I{(int)} 4304 @param windowing: Windowing type. I{(WindowingType)} 4305 @param direction: FFT direction. I{(TransformDirection)} 4306 @param interpolation: Interpolation type. 4307 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4308 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4309 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4310 plane (the number can be interpreted as the first polynomial degree 4311 to keep, but only the enumerated three values are available). I{(int)} 4312 @return: 4313 """ 4314 return None
4315 - def a_2dfft_raw( iin , rout , iout , direction ):
4316 """ 4317 Calculates 2D Fast Fourier Transform of a data field. 4318 4319 No leveling, windowing nor scaling is performed. 4320 4321 Since 2.8 the dimensions need not to be from the set of sizes returned 4322 by L{gwy_fft_find_nice_size}(). 4323 4324 Lateral dimensions, offsets and units are unchanged. See 4325 L{DataField.fft_postprocess}() for that. 4326 4327 Since: 2.1 4328 4329 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4330 transform. I{(L{DataField})} 4331 @param rout: Real output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4332 @param iout: Imaginary output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4333 @param direction: FFT direction. I{(TransformDirection)} 4334 @return: 4335 """ 4336 return None
4337 - def a_2dfft_humanize( ):
4338 """ 4339 Rearranges 2D FFT output to a human-friendly form. 4340 4341 Top-left, top-right, bottom-left and bottom-right sub-rectangles are swapped 4342 to obtain a humanized 2D FFT output with (0,0) in the centre. 4343 4344 More precisely, for even field dimensions the equally-sized blocks starting 4345 with the Nyquist frequency and with the zero frequency (constant component) 4346 will exchange places. For odd field dimensions, the block containing the 4347 zero frequency is one item larger and the constant component will actually 4348 end up in the exact centre. 4349 4350 Also note if both dimensions are even, this function is involutory and 4351 identical to L{DataField.2dfft_dehumanize}(). However, if any dimension 4352 is odd, L{DataField.2dfft_humanize}() and 4353 L{DataField.2dfft_dehumanize}() are different, therefore they must be 4354 paired properly. 4355 4356 @return: 4357 """ 4358 return None
4359 - def a_2dfft_dehumanize( ):
4360 """ 4361 Rearranges 2D FFT output back from the human-friendly form. 4362 4363 Top-left, top-right, bottom-left and bottom-right sub-rectangles are swapped 4364 to reshuffle a humanized 2D FFT output back into the natural positions. 4365 4366 See L{DataField.2dfft_humanize}() for discussion. 4367 4368 Since: 2.8 4369 4370 @return: 4371 """ 4372 return None
4373 - def fft_postprocess( humanize ):
4374 """ 4375 Updates units, dimensions and offsets for a 2D FFT-processed field. 4376 4377 The field is expected to have dimensions and units of the original 4378 direct-space data. The lateral units and resolutions are updated to 4379 correspond to its Fourier transform. 4380 4381 If B{C{humanize}} is B{C{True}} L{DataField.2dfft_humanize}() is applied to the 4382 field data and the lateral offsets are set accordingly. Otherwise the 4383 offsets are cleared. 4384 4385 Value units are kept intact. 4386 4387 Since: 2.38 4388 4389 @param humanize: B{C{True}} to rearrange data to have the frequency origin in the 4390 centre. I{(bool)} 4391 @return: 4392 """ 4393 return None
4394 - def fft_filter_1d( result_field , weights , orientation , interpolation ):
4395 """ 4396 Performs 1D FFT filtering of a data field. 4397 4398 @param result_field: A data field to store the result to. It will be resampled 4399 to B{C{data_field}}'s size. I{(L{DataField})} 4400 @param weights: Filter weights for the lower half of the spectrum (the other 4401 half is symmetric). Its size can be arbitrary, it will be 4402 interpolated. I{(L{DataLine})} 4403 @param orientation: Filter direction. I{(Orientation)} 4404 @param interpolation: The interpolation to use for resampling. I{(InterpolationType)} 4405 @return: 4406 """ 4407 return None
4408 - def UNIMPLEMENTED_cwt( interpolation , scale , wtype ):
4409 """ 4410 Computes a continuous wavelet transform (CWT) at given 4411 scale and using given wavelet. 4412 4413 @param interpolation: Interpolation type. 4414 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4415 @param scale: Wavelet scale. I{(float)} 4416 @param wtype: Wavelet type. I{(2DCWTWaveletType)} 4417 @return: 4418 """ 4419 return None
4420 - def area_fit_plane( mask , col , row , width , height , pa , pbx , pby ):
4421 """ 4422 Fits a plane through a rectangular part of a data field. 4423 4424 The coefficients can be used for plane leveling using the same relation 4425 as in L{DataField.fit_plane}(), counting indices from area top left 4426 corner. 4427 4428 @param mask: Mask of values to take values into account, or B{C{NULL}} for full 4429 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4430 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4431 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4432 for values inside (0.0, 1.0) is undefined (it may be specified 4433 in the future). I{(L{DataField})} 4434 @param col: Upper-left column coordinate. I{(int)} 4435 @param row: Upper-left row coordinate. I{(int)} 4436 @param width: Area width (number of columns). I{(int)} 4437 @param height: Area height (number of rows). I{(int)} 4438 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(float)} 4439 @param pbx: Where x plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4440 @param pby: Where y plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4441 @return: 4442 """ 4443 return None
4444 - def fit_plane( pa , pbx , pby ):
4445 """ 4446 Fits a plane through a data field. 4447 4448 The coefficients can be used for plane leveling using relation 4449 data[i] := data[i] - (pa + pby*i + pbx*j); 4450 4451 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(float)} 4452 @param pbx: Where x plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4453 @param pby: Where y plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4454 @return: 4455 """ 4456 return None
4457 - def UNIMPLEMENTED_fit_facet_plane( mfield , masking , pa , pbx , pby ):
4458 """ 4459 Calculates the inclination of a plane close to the dominant plane in a data 4460 field. 4461 4462 The dominant plane is determined by taking into account larger local slopes 4463 with exponentially smaller weight. 4464 4465 This is the basis of so-called facet levelling algorithm. Usually, the 4466 plane found by this method is subtracted using L{DataField.plane_level}() 4467 and the entire process is repeated until it converges. A convergence 4468 criterion may be sufficiently small values of the x and y plane 4469 coefficients. Note that since L{DataField.plane_level}() uses pixel-based 4470 lateral coordinates, the coefficients must be divided by 4471 L{DataField.get_xmeasure}(data_field) and 4472 L{DataField.get_ymeasure}(data_field) to obtain physical plane 4473 coefficients. 4474 4475 Since: 2.37 4476 4477 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. 4478 @param masking: Masking mode to use. I{(MaskingType)} 4479 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(gdouble*)} 4480 @param pbx: Where x plane coefficient should be stored. I{(gdouble*)} 4481 @param pby: Where y plane coefficient should be stored. I{(gdouble*)} 4482 @return: B{C{True}} if any plane was actually fitted; B{C{False}} if there was an 4483 insufficient number of unmasked pixels. 4484 4485 4486 """ 4487 return None
4488 - def plane_level( a , bx , by ):
4489 """ 4490 Subtracts plane from a data field. 4491 4492 See L{DataField.fit_plane}() for details. 4493 4494 @param a: Constant coefficient. I{(float)} 4495 @param bx: X plane coefficient. I{(float)} 4496 @param by: Y plane coefficient. I{(float)} 4497 @return: 4498 """ 4499 return None
4500 - def plane_rotate( xangle , yangle , interpolation ):
4501 """ 4502 Performs rotation of plane along x and y axis. 4503 4504 @param xangle: Rotation angle in x direction (rotation along y axis, in radians). I{(float)} 4505 @param yangle: Rotation angle in y direction (rotation along x axis, in radians). I{(float)} 4506 @param interpolation: Interpolation type (can be only of two-point type). I{(InterpolationType)} 4507 @return: 4508 """ 4509 return None
4510 - def fit_lines( col , row , width , height , degree , exclude , orientation ):
4511 """ 4512 Independently levels profiles on each row/column in a data field. 4513 4514 Lines that have no intersection with area selected by B{C{ulcol}}, B{C{ulrow}}, 4515 B{C{brcol}}, B{C{brrow}} are always leveled as a whole. Lines that have intersection 4516 with selected area, are leveled using polynomial coefficients computed only 4517 from data inside (or outside for B{C{exclude}} = B{C{True}}) the area. 4518 4519 @param col: Upper-left column coordinate. I{(int)} 4520 @param row: Upper-left row coordinate. I{(int)} 4521 @param width: Area width (number of columns). I{(int)} 4522 @param height: Area height (number of rows). I{(int)} 4523 @param degree: Fitted polynomial degree. I{(int)} 4524 @param exclude: If B{C{True}}, outside of area selected by B{C{ulcol}}, B{C{ulrow}}, B{C{brcol}}, 4525 B{C{brrow}} will be used for polynomial coefficients computation, 4526 instead of inside. I{(bool)} 4527 @param orientation: Line orientation. I{(Orientation)} 4528 @return: 4529 """ 4530 return None
4531 - def fit_polynom( col_degree , row_degree , coeffs ):
4532 """ 4533 Fits a two-dimensional polynomial to a data field. 4534 4535 4536 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4537 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4538 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4539 coefficients to, or B{C{NULL}} (a fresh array is allocated then), 4540 see L{DataField.area_fit_polynom}() for details. I{(gdouble*)} 4541 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4542 with coefficients. 4543 4544 """ 4545 return None
4546 - def area_fit_polynom( col , row , width , height , col_degree , row_degree , coeffs ):
4547 """ 4548 Fits a two-dimensional polynomial to a rectangular part of a data field. 4549 4550 The coefficients are stored by row into B{C{coeffs}}, like data in a datafield. 4551 Row index is y-degree, column index is x-degree. 4552 4553 Note naive x^n y^m polynomial fitting is numerically unstable, therefore 4554 this method works only up to B{C{col_degree}} = B{C{row_degree}} = 6. 4555 4556 4557 @param col: Upper-left column coordinate. I{(int)} 4558 @param row: Upper-left row coordinate. I{(int)} 4559 @param width: Area width (number of columns). I{(int)} 4560 @param height: Area height (number of rows). I{(int)} 4561 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4562 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4563 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4564 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4565 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4566 with coefficients. 4567 4568 """ 4569 return None
4570 - def subtract_polynom( col_degree , row_degree , coeffs ):
4571 """ 4572 Subtracts a two-dimensional polynomial from a data field. 4573 4574 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4575 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4576 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4577 see L{DataField.area_fit_polynom}() for details. I{(const-gdouble*)} 4578 @return: 4579 """ 4580 return None
4581 - def area_subtract_polynom( col , row , width , height , col_degree , row_degree , coeffs ):
4582 """ 4583 Subtracts a two-dimensional polynomial from a rectangular part of a data 4584 field. 4585 4586 @param col: Upper-left column coordinate. I{(int)} 4587 @param row: Upper-left row coordinate. I{(int)} 4588 @param width: Area width (number of columns). I{(int)} 4589 @param height: Area height (number of rows). I{(int)} 4590 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4591 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4592 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4593 see L{DataField.area_fit_polynom}() for details. I{(const-gdouble*)} 4594 @return: 4595 """ 4596 return None
4597 - def UNIMPLEMENTED_fit_legendre( col_degree , row_degree , coeffs ):
4598 """ 4599 Fits two-dimensional Legendre polynomial to a data field. 4600 4601 See L{DataField.area_fit_legendre}() for details. 4602 4603 4604 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4605 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4606 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4607 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4608 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4609 with coefficients. 4610 4611 """ 4612 return None
4613 - def UNIMPLEMENTED_area_fit_legendre( col , row , width , height , col_degree , row_degree , coeffs ):
4614 """ 4615 Fits two-dimensional Legendre polynomial to a rectangular part of a data 4616 field. 4617 4618 The B{C{col_degree}} and B{C{row_degree}} parameters limit the maximum powers of x and 4619 y exactly as if simple powers were fitted, therefore if you do not intend to 4620 interpret contents of B{C{coeffs}} youself, the only difference is that this 4621 method is much more numerically stable. 4622 4623 The coefficients are organized exactly like in 4624 L{DataField.area_fit_polynom}(), but they are not coefficients of 4625 x^n y^m, instead they are coefficients of P_n(x) P_m(x), where P are 4626 Legendre polynomials. The polynomials are evaluated in coordinates where 4627 first row (column) corresponds to -1.0, and the last row (column) to 1.0. 4628 4629 Note the polynomials are normal Legendre polynomials that are not exactly 4630 orthogonal on a discrete point set (if their degrees are equal mod 2). 4631 4632 4633 @param col: Upper-left column coordinate. I{(int)} 4634 @param row: Upper-left row coordinate. I{(int)} 4635 @param width: Area width (number of columns). I{(int)} 4636 @param height: Area height (number of rows). I{(int)} 4637 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4638 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4639 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4640 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4641 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4642 with coefficients. 4643 4644 """ 4645 return None
4646 - def subtract_legendre( col_degree , row_degree , coeffs ):
4647 """ 4648 Subtracts a two-dimensional Legendre polynomial fit from a data field. 4649 4650 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4651 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4652 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4653 see L{DataField.area_fit_legendre}() for details. I{(const-gdouble*)} 4654 @return: 4655 """ 4656 return None
4657 - def area_subtract_legendre( col , row , width , height , col_degree , row_degree , coeffs ):
4658 """ 4659 Subtracts a two-dimensional Legendre polynomial fit from a rectangular part 4660 of a data field. 4661 4662 Due to the transform of coordinates to [-1,1] x [-1,1], this method can be 4663 used on an area of dimensions different than the area the coefficients were 4664 calculated for. 4665 4666 @param col: Upper-left column coordinate. I{(int)} 4667 @param row: Upper-left row coordinate. I{(int)} 4668 @param width: Area width (number of columns). I{(int)} 4669 @param height: Area height (number of rows). I{(int)} 4670 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4671 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4672 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4673 see L{DataField.area_fit_legendre}() for details. I{(const-gdouble*)} 4674 @return: 4675 """ 4676 return None
4677 - def UNIMPLEMENTED_fit_poly_max( max_degree , coeffs ):
4678 """ 4679 Fits two-dimensional polynomial with limited total degree to a data field. 4680 4681 See L{DataField.area_fit_poly_max}() for details. 4682 4683 4684 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4685 in x^n y^m terms. I{(int)} 4686 @param coeffs: An array of size (B{C{max_degree}}+1)*(B{C{max_degree}}+2)/2 to store the 4687 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4688 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4689 with coefficients. 4690 4691 """ 4692 return None
4693 - def UNIMPLEMENTED_area_fit_poly_max( col , row , width , height , max_degree , coeffs ):
4694 """ 4695 Fits two-dimensional polynomial with limited total degree to a rectangular 4696 part of a data field. 4697 4698 See L{DataField.area_fit_legendre}() for description. This function 4699 differs by limiting the total maximum degree, while 4700 L{DataField.area_fit_legendre}() limits the maximum degrees in horizontal 4701 and vertical directions independently. 4702 4703 4704 @param col: Upper-left column coordinate. I{(int)} 4705 @param row: Upper-left row coordinate. I{(int)} 4706 @param width: Area width (number of columns). I{(int)} 4707 @param height: Area height (number of rows). I{(int)} 4708 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4709 in x^n y^m terms. I{(int)} 4710 @param coeffs: An array of size (B{C{max_degree}}+1)*(B{C{max_degree}}+2)/2 to store the 4711 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4712 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4713 with coefficients. 4714 4715 """ 4716 return None
4717 - def subtract_poly_max( max_degree , coeffs ):
4718 """ 4719 Subtracts a two-dimensional polynomial with limited total degree from 4720 a data field. 4721 4722 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4723 in x^n y^m terms. I{(int)} 4724 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+2)/2 with 4725 coefficients, see L{DataField.area_fit_poly_max}() for details. I{(const-gdouble*)} 4726 @return: 4727 """ 4728 return None
4729 - def area_subtract_poly_max( col , row , width , height , max_degree , coeffs ):
4730 """ 4731 Subtracts a two-dimensional polynomial with limited total degree from a 4732 rectangular part of a data field. 4733 4734 Due to the transform of coordinates to [-1,1] x [-1,1], this method can be 4735 used on an area of dimensions different than the area the coefficients were 4736 calculated for. 4737 4738 @param col: Upper-left column coordinate. I{(int)} 4739 @param row: Upper-left row coordinate. I{(int)} 4740 @param width: Area width (number of columns). I{(int)} 4741 @param height: Area height (number of rows). I{(int)} 4742 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4743 in x^n y^m terms. I{(int)} 4744 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+2)/2 with 4745 coefficients, see L{DataField.area_fit_poly_max}() for details. I{(const-gdouble*)} 4746 @return: 4747 """ 4748 return None
4749 - def fit_poly( mask_field , nterms , term_powers , exclude , coeffs ):
4750 """ 4751 Fit a given set of polynomial terms to a data field. 4752 4753 Since: 2.11 4754 4755 @param mask_field: Mask of values to take values into account, or B{C{NULL}} for full 4756 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4757 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4758 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4759 for values inside (0.0, 1.0) is undefined (it may be specified 4760 in the future). I{(L{DataField})} 4761 @param nterms: The number of polynomial terms to take into account (half the 4762 number of items in B{C{term_powers}}). I{(int)} 4763 @param term_powers: Array of size 2*B{C{nterms}} describing the terms to fit. Each 4764 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4765 @param exclude: Interpret values B{C{w}} in the mask as 1.0-B{C{w}}. I{(bool)} 4766 @param coeffs: Array of size B{C{nterms}} to store the coefficients to, or B{C{NULL}} to 4767 allocate a new array. I{(gdouble*)} 4768 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4769 with coefficients. 4770 4771 4772 """ 4773 return None
4774 - def area_fit_poly( mask_field , col , row , width , height , nterms , term_powers , exclude , coeffs ):
4775 """ 4776 Fit a given set of polynomial terms to a rectangular part of a data field. 4777 4778 The polynomial coefficients correspond to normalized coordinates that 4779 are always from the interval [-1,1] where -1 corresponds to the left/topmost 4780 pixel and 1 corresponds to the bottom/rightmost pixel of the area. 4781 4782 Since: 2.11 4783 4784 @param mask_field: Mask of values to take values into account, or B{C{NULL}} for full 4785 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4786 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4787 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4788 for values inside (0.0, 1.0) is undefined (it may be specified 4789 in the future). I{(L{DataField})} 4790 @param col: Upper-left column coordinate. I{(int)} 4791 @param row: Upper-left row coordinate. I{(int)} 4792 @param width: Area width (number of columns). I{(int)} 4793 @param height: Area height (number of rows). I{(int)} 4794 @param nterms: The number of polynomial terms to take into account (half the 4795 number of items in B{C{term_powers}}). I{(int)} 4796 @param term_powers: Array of size 2*B{C{nterms}} describing the terms to fit. Each 4797 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4798 @param exclude: Interpret values B{C{w}} in the mask as 1.0-B{C{w}}. I{(bool)} 4799 @param coeffs: Array of size B{C{nterms}} to store the coefficients to, or B{C{NULL}} to 4800 allocate a new array. I{(gdouble*)} 4801 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4802 with coefficients. 4803 4804 4805 """ 4806 return None
4807 - def subtract_poly( nterms , term_powers , coeffs ):
4808 """ 4809 Subtract a given set of polynomial terms from a data field. 4810 4811 Since: 2.11 4812 4813 @param nterms: The number of polynomial terms to take into account (half the 4814 number of items in B{C{term_powers}}). I{(int)} 4815 @param term_powers: Array of size 2*B{C{nterms}} describing the fitter terms. Each 4816 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4817 @param coeffs: Array of size B{C{nterms}} to store with the coefficients. I{(const-gdouble*)} 4818 @return: 4819 """ 4820 return None
4821 - def area_subtract_poly( col , row , width , height , nterms , term_powers , coeffs ):
4822 """ 4823 Subtract a given set of polynomial terms from a rectangular part of a data 4824 field. 4825 4826 Since: 2.11 4827 4828 @param col: Upper-left column coordinate. I{(int)} 4829 @param row: Upper-left row coordinate. I{(int)} 4830 @param width: Area width (number of columns). I{(int)} 4831 @param height: Area height (number of rows). I{(int)} 4832 @param nterms: The number of polynomial terms to take into account (half the 4833 number of items in B{C{term_powers}}). I{(int)} 4834 @param term_powers: Array of size 2*B{C{nterms}} describing the fitted terms. Each 4835 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4836 @param coeffs: Array of size B{C{nterms}} to store with the coefficients. I{(const-gdouble*)} 4837 @return: 4838 """ 4839 return None
4840 - def UNIMPLEMENTED_area_fit_local_planes( size , col , row , width , height , nresults , types , results ):
4841 """ 4842 Fits a plane through neighbourhood of each sample in a rectangular part 4843 of a data field. 4844 4845 The sample is always in the origin of its local (x,y) coordinate system, 4846 even if the neighbourhood is not centered about it (e.g. because sample 4847 is on the edge of data field). Z-coordinate is however not centered, 4848 that is B{C{PLANE_FIT_A}} is normal mean value. 4849 4850 4851 @param size: Neighbourhood size (must be at least 2). It is centered around 4852 each pixel, unless B{C{size}} is even when it sticks to the right. I{(int)} 4853 @param col: Upper-left column coordinate. I{(int)} 4854 @param row: Upper-left row coordinate. I{(int)} 4855 @param width: Area width (number of columns). I{(int)} 4856 @param height: Area height (number of rows). I{(int)} 4857 @param nresults: The number of requested quantities. I{(int)} 4858 @param types: The types of requested quantities. I{(const-PlaneFitQuantity*)} 4859 @param results: An array to store quantities to, may be B{C{NULL}} to allocate a new 4860 one which must be freed by caller then. If any item is B{C{NULL}}, 4861 a new data field is allocated for it, existing data fields 4862 are resized to B{C{width}} x B{C{height}}. I{(DataField**)} 4863 @return: An array of data fields with requested quantities, that is 4864 B{C{results}} unless it was B{C{NULL}} and a new array was allocated. 4865 4866 """ 4867 return None
4868 - def area_local_plane_quantity( size , col , row , width , height , type , result ):
4869 """ 4870 Convenience function to get just one quantity from 4871 L{DataField.area_fit_local_planes}(). 4872 4873 4874 @param size: Neighbourhood size. I{(int)} 4875 @param col: Upper-left column coordinate. I{(int)} 4876 @param row: Upper-left row coordinate. I{(int)} 4877 @param width: Area width (number of columns). I{(int)} 4878 @param height: Area height (number of rows). I{(int)} 4879 @param type: The type of requested quantity. I{(PlaneFitQuantity)} 4880 @param result: A data field to store result to, or B{C{NULL}} to allocate a new one. I{(L{DataField})} 4881 @return: B{C{result}} if it isn't B{C{NULL}}, otherwise a newly allocated data field. 4882 4883 """ 4884 return None
4885 - def UNIMPLEMENTED_fit_local_planes( size , nresults , types , results ):
4886 """ 4887 Fits a plane through neighbourhood of each sample in a data field. 4888 4889 See L{DataField.area_fit_local_planes}() for details. 4890 4891 4892 @param size: Neighbourhood size. I{(int)} 4893 @param nresults: The number of requested quantities. I{(int)} 4894 @param types: The types of requested quantities. I{(const-PlaneFitQuantity*)} 4895 @param results: An array to store quantities to. I{(DataField**)} 4896 @return: An array of data fields with requested quantities. 4897 4898 """ 4899 return None
4900 - def local_plane_quantity( size , type , result ):
4901 """ 4902 Convenience function to get just one quantity from 4903 L{DataField.fit_local_planes}(). 4904 4905 4906 @param size: Neighbourhood size. I{(int)} 4907 @param type: The type of requested quantity. I{(PlaneFitQuantity)} 4908 @param result: A data field to store result to, or B{C{NULL}} to allocate a new one. I{(L{DataField})} 4909 @return: B{C{result}} if it isn't B{C{NULL}}, otherwise a newly allocated data field. 4910 4911 """ 4912 return None
4913 - def get_max( ):
4914 """ 4915 Finds the maximum value of a data field. 4916 4917 This quantity is cached. 4918 4919 4920 @return: The maximum value. 4921 4922 """ 4923 return None
4924 - def get_min( ):
4925 """ 4926 Finds the minimum value of a data field. 4927 4928 This quantity is cached. 4929 4930 4931 @return: The minimum value. 4932 4933 """ 4934 return None
4935 - def get_min_max( min , max ):
4936 """ 4937 Finds minimum and maximum values of a data field. 4938 4939 @param min: Location to store minimum to. I{(float)} 4940 @param max: Location to store maximum to. I{(float)} 4941 @return: 4942 """ 4943 return None
4944 - def get_avg( ):
4945 """ 4946 Computes average value of a data field. 4947 4948 This quantity is cached. 4949 4950 4951 @return: The average value. 4952 4953 """ 4954 return None
4955 - def get_rms( ):
4956 """ 4957 Computes root mean square value of a data field. 4958 4959 This quantity is cached. 4960 4961 4962 @return: The root mean square value. 4963 4964 """ 4965 return None
4966 - def get_sum( ):
4967 """ 4968 Sums all values in a data field. 4969 4970 This quantity is cached. 4971 4972 4973 @return: The sum of all values. 4974 4975 """ 4976 return None
4977 - def get_median( ):
4978 """ 4979 Computes median value of a data field. 4980 4981 This quantity is cached. 4982 4983 4984 @return: The median value. 4985 4986 """ 4987 return None
4988 - def get_surface_area( ):
4989 """ 4990 Computes surface area of a data field. 4991 4992 This quantity is cached. 4993 4994 4995 @return: The surface area. 4996 4997 """ 4998 return None
4999 - def get_variation( ):
5000 """ 5001 Computes the total variation of a data field. 5002 5003 See L{DataField.area_get_variation}() for the definition. 5004 5005 This quantity is cached. 5006 5007 Since: 2.38 5008 5009 @return: The variation. 5010 5011 5012 """ 5013 return None
5014 - def area_get_max( mask , col , row , width , height ):
5015 """ 5016 Finds the maximum value in a rectangular part of a data field. 5017 5018 5019 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5020 @param col: Upper-left column coordinate. I{(int)} 5021 @param row: Upper-left row coordinate. I{(int)} 5022 @param width: Area width (number of columns). I{(int)} 5023 @param height: Area height (number of rows). I{(int)} 5024 @return: The maximum value. When the number of samples to calculate 5025 maximum of is zero, -B{C{G_MAXDOUBLE}} is returned. 5026 5027 """ 5028 return None
5029 - def area_get_min( mask , col , row , width , height ):
5030 """ 5031 Finds the minimum value in a rectangular part of a data field. 5032 5033 5034 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5035 @param col: Upper-left column coordinate. I{(int)} 5036 @param row: Upper-left row coordinate. I{(int)} 5037 @param width: Area width (number of columns). I{(int)} 5038 @param height: Area height (number of rows). I{(int)} 5039 @return: The minimum value. When the number of samples to calculate 5040 minimum of is zero, -B{C{G_MAXDOUBLE}} is returned. 5041 5042 """ 5043 return None
5044 - def UNIMPLEMENTED_area_get_min_max( mask , col , row , width , height , min , max ):
5045 """ 5046 Finds minimum and maximum values in a rectangular part of a data field. 5047 5048 This function is equivalent to calling 5049 B{C{L{DataField.area_get_min_max_mask}}}() 5050 with masking mode B{C{MASK_INCLUDE}}. 5051 5052 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5053 @param col: Upper-left column coordinate. I{(int)} 5054 @param row: Upper-left row coordinate. I{(int)} 5055 @param width: Area width (number of columns). I{(int)} 5056 @param height: Area height (number of rows). I{(int)} 5057 @param min: Location to store minimum to. I{(gdouble*)} 5058 @param max: Location to store maximum to. I{(gdouble*)} 5059 @return: 5060 """ 5061 return None
5062 - def UNIMPLEMENTED_area_get_min_max_mask( mask , mode , col , row , width , height , min , max ):
5063 """ 5064 Finds minimum and maximum values in a rectangular part of a data field. 5065 5066 Since: 2.18 5067 5068 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5069 @param mode: Masking mode to use. See the introduction for description of 5070 masking modes. I{(MaskingType)} 5071 @param col: Upper-left column coordinate. I{(int)} 5072 @param row: Upper-left row coordinate. I{(int)} 5073 @param width: Area width (number of columns). I{(int)} 5074 @param height: Area height (number of rows). I{(int)} 5075 @param min: Location to store minimum to. I{(gdouble*)} 5076 @param max: Location to store maximum to. I{(gdouble*)} 5077 @return: 5078 """ 5079 return None
5080 - def area_get_avg( mask , col , row , width , height ):
5081 """ 5082 Computes average value of a rectangular part of a data field. 5083 5084 This function is equivalent to calling B{C{L{DataField.area_get_avg_mask}}}() 5085 with masking mode B{C{MASK_INCLUDE}}. 5086 5087 5088 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5089 @param col: Upper-left column coordinate. I{(int)} 5090 @param row: Upper-left row coordinate. I{(int)} 5091 @param width: Area width (number of columns). I{(int)} 5092 @param height: Area height (number of rows). I{(int)} 5093 @return: The average value. 5094 5095 """ 5096 return None
5097 - def area_get_avg_mask( mask , mode , col , row , width , height ):
5098 """ 5099 Computes average value of a rectangular part of a data field. 5100 5101 Since: 2.18 5102 5103 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5104 @param mode: Masking mode to use. See the introduction for description of 5105 masking modes. I{(MaskingType)} 5106 @param col: Upper-left column coordinate. I{(int)} 5107 @param row: Upper-left row coordinate. I{(int)} 5108 @param width: Area width (number of columns). I{(int)} 5109 @param height: Area height (number of rows). I{(int)} 5110 @return: The average value. 5111 5112 5113 """ 5114 return None
5115 - def area_get_rms( mask , col , row , width , height ):
5116 """ 5117 Computes root mean square value of a rectangular part of a data field. 5118 5119 5120 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5121 @param col: Upper-left column coordinate. I{(int)} 5122 @param row: Upper-left row coordinate. I{(int)} 5123 @param width: Area width (number of columns). I{(int)} 5124 @param height: Area height (number of rows). I{(int)} 5125 @return: The root mean square value. 5126 5127 This function is equivalent to calling B{C{L{DataField.area_get_rms_mask}}}() 5128 with masking mode B{C{MASK_INCLUDE}}. 5129 5130 """ 5131 return None
5132 - def area_get_rms_mask( mask , mode , col , row , width , height ):
5133 """ 5134 Computes root mean square value of deviations of a rectangular part of a 5135 data field. 5136 5137 Since: 2.18 5138 5139 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5140 @param mode: Masking mode to use. See the introduction for description of 5141 masking modes. I{(MaskingType)} 5142 @param col: Upper-left column coordinate. I{(int)} 5143 @param row: Upper-left row coordinate. I{(int)} 5144 @param width: Area width (number of columns). I{(int)} 5145 @param height: Area height (number of rows). I{(int)} 5146 @return: The root mean square value of deviations from the mean value. 5147 5148 5149 """ 5150 return None
5151 - def area_get_grainwise_rms( mask , mode , col , row , width , height ):
5152 """ 5153 Computes grain-wise root mean square value of deviations of a rectangular 5154 part of a data field. 5155 5156 Grain-wise means that the mean value is determined for each grain (i.e. 5157 cotinguous part of the mask or inverted mask) separately and the deviations 5158 are calculated from these mean values. 5159 5160 Since: 2.29 5161 5162 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5163 @param mode: Masking mode to use. See the introduction for description of 5164 masking modes. I{(MaskingType)} 5165 @param col: Upper-left column coordinate. I{(int)} 5166 @param row: Upper-left row coordinate. I{(int)} 5167 @param width: Area width (number of columns). I{(int)} 5168 @param height: Area height (number of rows). I{(int)} 5169 @return: The root mean square value of deviations from the mean value. 5170 5171 5172 """ 5173 return None
5174 - def area_get_sum( mask , col , row , width , height ):
5175 """ 5176 Sums values of a rectangular part of a data field. 5177 5178 This function is equivalent to calling B{C{L{DataField.area_get_sum_mask}}}() 5179 with masking mode B{C{MASK_INCLUDE}}. 5180 5181 5182 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5183 @param col: Upper-left column coordinate. I{(int)} 5184 @param row: Upper-left row coordinate. I{(int)} 5185 @param width: Area width (number of columns). I{(int)} 5186 @param height: Area height (number of rows). I{(int)} 5187 @return: The sum of all values inside area. 5188 5189 """ 5190 return None
5191 - def area_get_sum_mask( mask , mode , col , row , width , height ):
5192 """ 5193 Sums values of a rectangular part of a data field. 5194 5195 Since: 2.18 5196 5197 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5198 @param mode: Masking mode to use. See the introduction for description of 5199 masking modes. I{(MaskingType)} 5200 @param col: Upper-left column coordinate. I{(int)} 5201 @param row: Upper-left row coordinate. I{(int)} 5202 @param width: Area width (number of columns). I{(int)} 5203 @param height: Area height (number of rows). I{(int)} 5204 @return: The sum of all values inside area. 5205 5206 5207 """ 5208 return None
5209 - def area_get_median( mask , col , row , width , height ):
5210 """ 5211 Computes median value of a data field area. 5212 5213 This function is equivalent to calling 5214 B{C{L{DataField.area_get_median_mask}}}() 5215 with masking mode B{C{MASK_INCLUDE}}. 5216 5217 5218 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5219 @param col: Upper-left column coordinate. I{(int)} 5220 @param row: Upper-left row coordinate. I{(int)} 5221 @param width: Area width (number of columns). I{(int)} 5222 @param height: Area height (number of rows). I{(int)} 5223 @return: The median value. 5224 5225 """ 5226 return None
5227 - def area_get_median_mask( mask , mode , col , row , width , height ):
5228 """ 5229 Computes median value of a data field area. 5230 5231 Since: 2.18 5232 5233 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5234 @param mode: Masking mode to use. See the introduction for description of 5235 masking modes. I{(MaskingType)} 5236 @param col: Upper-left column coordinate. I{(int)} 5237 @param row: Upper-left row coordinate. I{(int)} 5238 @param width: Area width (number of columns). I{(int)} 5239 @param height: Area height (number of rows). I{(int)} 5240 @return: The median value. 5241 5242 5243 """ 5244 return None
5245 - def area_get_surface_area( mask , col , row , width , height ):
5246 return None
5247 - def area_get_surface_area_mask( mask , mode , col , row , width , height ):
5248 """ 5249 Computes surface area of a rectangular part of a data field. 5250 5251 This quantity makes sense only if the lateral dimensions and values of 5252 B{C{data_field}} are the same physical quantities. 5253 5254 Since: 2.18 5255 5256 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5257 @param mode: Masking mode to use. See the introduction for description of 5258 masking modes. I{(MaskingType)} 5259 @param col: Upper-left column coordinate. I{(int)} 5260 @param row: Upper-left row coordinate. I{(int)} 5261 @param width: Area width (number of columns). I{(int)} 5262 @param height: Area height (number of rows). I{(int)} 5263 @return: The surface area. 5264 5265 5266 """ 5267 return None
5268 - def area_get_variation( mask , mode , col , row , width , height ):
5269 """ 5270 Computes the total variation of a rectangular part of a data field. 5271 5272 The total variation is estimated as the integral of the absolute value of 5273 local gradient. 5274 5275 Since: 2.38 5276 5277 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5278 @param mode: Masking mode to use. See the introduction for description of 5279 masking modes. I{(MaskingType)} 5280 @param col: Upper-left column coordinate. I{(int)} 5281 @param row: Upper-left row coordinate. I{(int)} 5282 @param width: Area width (number of columns). I{(int)} 5283 @param height: Area height (number of rows). I{(int)} 5284 @return: The variation. 5285 5286 5287 """ 5288 return None
5289 - def area_get_volume( basis , mask , col , row , width , height ):
5290 """ 5291 Computes volume of a rectangular part of a data field. 5292 5293 Since: 2.3 5294 5295 @param basis: The basis or background for volume calculation if not B{C{NULL}}. 5296 The height of each vertex is then the difference between 5297 B{C{data_field}} value and B{C{basis}} value. Value B{C{NULL}} is the same 5298 as passing all zeroes for the basis. I{(L{DataField})} 5299 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5300 @param col: Upper-left column coordinate. I{(int)} 5301 @param row: Upper-left row coordinate. I{(int)} 5302 @param width: Area width (number of columns). I{(int)} 5303 @param height: Area height (number of rows). I{(int)} 5304 @return: The volume. 5305 5306 5307 """ 5308 return None
5309 - def UNIMPLEMENTED_get_autorange( _from , to ):
5310 """ 5311 Computes value range with outliers cut-off. 5312 5313 The purpose of this function is to find a range is suitable for false color 5314 mapping. The precise method how it is calculated is unspecified and may be 5315 subject to changes. 5316 5317 However, it is guaranteed minimum <= B{C{from}} <= B{C{to}} <= maximum. 5318 5319 This quantity is cached. 5320 5321 @param _from: Location to store range start. I{(gdouble*)} 5322 @param to: Location to store range end. I{(gdouble*)} 5323 @return: 5324 """ 5325 return None
5326 - def get_stats( avg , ra , rms , skew , kurtosis ):
5327 """ 5328 Computes basic statistical quantities of a data field. 5329 5330 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(float)} 5331 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(float)} 5332 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5333 or B{C{NULL}}. I{(float)} 5334 @param skew: Where skew (symmetry of height distribution) should be stored, or 5335 B{C{NULL}}. I{(float)} 5336 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5337 stored, or B{C{NULL}}. I{(float)} 5338 @return: 5339 """ 5340 return None
5341 - def area_get_stats( mask , col , row , width , height , avg , ra , rms , skew , kurtosis ):
5342 """ 5343 Computes basic statistical quantities of a rectangular part of a data field. 5344 5345 This function is equivalent to calling B{C{L{DataField.area_get_stats_mask}}}() 5346 with masking mode B{C{MASK_INCLUDE}}. 5347 5348 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5349 @param col: Upper-left column coordinate. I{(int)} 5350 @param row: Upper-left row coordinate. I{(int)} 5351 @param width: Area width (number of columns). I{(int)} 5352 @param height: Area height (number of rows). I{(int)} 5353 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(float)} 5354 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(float)} 5355 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5356 or B{C{NULL}}. I{(float)} 5357 @param skew: Where skew (symmetry of height distribution) should be stored, or 5358 B{C{NULL}}. I{(float)} 5359 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5360 stored, or B{C{NULL}}. I{(float)} 5361 @return: 5362 """ 5363 return None
5364 - def UNIMPLEMENTED_area_get_stats_mask( mask , mode , col , row , width , height , avg , ra , rms , skew , kurtosis ):
5365 """ 5366 Computes basic statistical quantities of a rectangular part of a data field. 5367 5368 Since: 2.18 5369 5370 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5371 @param mode: Masking mode to use. See the introduction for description of 5372 masking modes. I{(MaskingType)} 5373 @param col: Upper-left column coordinate. I{(int)} 5374 @param row: Upper-left row coordinate. I{(int)} 5375 @param width: Area width (number of columns). I{(int)} 5376 @param height: Area height (number of rows). I{(int)} 5377 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(gdouble*)} 5378 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(gdouble*)} 5379 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5380 or B{C{NULL}}. I{(gdouble*)} 5381 @param skew: Where skew (symmetry of height distribution) should be stored, or 5382 B{C{NULL}}. I{(gdouble*)} 5383 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5384 stored, or B{C{NULL}}. I{(gdouble*)} 5385 @return: 5386 """ 5387 return None
5388 - def area_count_in_range( mask , col , row , width , height , below , above , nbelow , nabove ):
5389 """ 5390 Counts data samples in given range. 5391 5392 No assertion is made about the values of B{C{above}} and B{C{below}}, in other words 5393 B{C{above}} may be larger than B{C{below}}. To count samples in an open interval 5394 instead of a closed interval, exchange B{C{below}} and B{C{above}} and then subtract 5395 the B{C{nabove}} and B{C{nbelow}} from B{C{width}}*B{C{height}} to get the complementary counts. 5396 5397 With this trick the common task of counting positive values can be 5398 realized: 5399 <informalexample><programlisting> 5400 L{DataField.area_count_in_range}(data_field, NULL, 5401 col, row, width, height, 5402 0.0, 0.0, &amp;count, NULL); 5403 count = width*height - count; 5404 </programlisting></informalexample> 5405 5406 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5407 @param col: Upper-left column coordinate. I{(int)} 5408 @param row: Upper-left row coordinate. I{(int)} 5409 @param width: Area width (number of columns). I{(int)} 5410 @param height: Area height (number of rows). I{(int)} 5411 @param below: Upper bound to compare data to. The number of samples less 5412 than or equal to B{C{below}} is stored in B{C{nbelow}}. I{(float)} 5413 @param above: Lower bound to compare data to. The number of samples greater 5414 than or equal to B{C{above}} is stored in B{C{nabove}}. I{(float)} 5415 @param nbelow: Location to store the number of samples less than or equal 5416 to B{C{below}}, or B{C{NULL}}. I{(int)} 5417 @param nabove: Location to store the number of samples greater than or equal 5418 to B{C{above}}, or B{C{NULL}}. I{(int)} 5419 @return: 5420 """ 5421 return None
5422 - def area_dh( mask , target_line , col , row , width , height , nstats ):
5423 """ 5424 Calculates distribution of heights in a rectangular part of data field. 5425 5426 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5427 @param target_line: A data line to store the distribution to. It will be 5428 resampled to requested width. I{(L{DataLine})}