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 -class ColorButton:
1255 - def __init__( ):
1256 """ 1257 Creates a new color button. This returns a widget in the form of 1258 a small button containing a swatch representing the current selected 1259 color. When the button is clicked, a color-selection dialog will open, 1260 allowing the user to select a color. The swatch will be updated to reflect 1261 the new color when the user finishes. 1262 1263 1264 @return: a new color button. 1265 1266 """ 1267 return None
1268 - def set_color( color ):
1269 """ 1270 Sets the current color to be B{C{color}}. 1271 1272 @param color: A B{C{RGBA}} to set the current color with. I{(L{RGBA})} 1273 @return: 1274 """ 1275 return None
1276 - def get_color( color ):
1277 """ 1278 Sets B{C{color}} to be the current color in the B{C{ColorButton}} widget. 1279 1280 @param color: a B{C{RGBA}} to fill in with the current color. I{(L{RGBA})} 1281 @return: 1282 """ 1283 return None
1284 - def set_use_alpha( use_alpha ):
1285 """ 1286 Sets whether or not the color button should use the alpha channel. 1287 1288 @param use_alpha: B{C{True}} if color button should use alpha channel, B{C{False}} if not. I{(bool)} 1289 @return: 1290 """ 1291 return None
1292 - def get_use_alpha( ):
1293 """ 1294 Does the color selection dialog use the alpha channel? 1295 1296 1297 @return: B{C{True}} if the color sample uses alpha channel, B{C{False}} if not. 1298 1299 """ 1300 return None
1301 -class Container:
1302 - def __init__( ):
1303 """ 1304 Creates a new B{C{Container}}. 1305 1306 1307 @return: The container, as a B{C{GObject}}. 1308 1309 """ 1310 return None
1311 - def get_n_items( ):
1312 """ 1313 Gets the number of items in a container. 1314 1315 1316 @return: The number of items. 1317 1318 """ 1319 return None
1320 - def value_type( key ):
1321 """ 1322 Returns the type of value in B{C{container}} identified by B{C{key}}. 1323 1324 1325 @param key: A B{C{GQuark}} key. I{(int)} 1326 @return: The value type as B{C{GType}}; 0 if there is no such value. 1327 1328 """ 1329 return None
1330 - def contains( key ):
1331 """ 1332 Returns B{C{True}} if B{C{container}} contains a value identified by B{C{key}}. 1333 1334 1335 @param key: A B{C{GQuark}} key. I{(int)} 1336 @return: Whether B{C{container}} contains something identified by B{C{key}}. 1337 1338 """ 1339 return None
1340 - def get_value( key ):
1341 """ 1342 Returns the value in B{C{container}} identified by B{C{key}}. 1343 1344 1345 @param key: A B{C{GQuark}} key. I{(int)} 1346 @return: The value as a B{C{GValue}}. 1347 1348 """ 1349 return None
1350 - def UNIMPLEMENTED_gis_value( key , value ):
1351 """ 1352 Get-if-set a generic value from a container. 1353 1354 1355 @param key: A B{C{GQuark}} key. I{(int)} 1356 @param value: Pointer to a B{C{GValue}} to update. If item does not exist, 1357 it is left untouched. I{(GValue*)} 1358 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1359 such value in the container. 1360 1361 """ 1362 return None
1363 - def remove( key ):
1364 """ 1365 Removes a value identified by B{C{key}} from a container. 1366 1367 1368 @param key: A B{C{GQuark}} key. I{(int)} 1369 @return: B{C{True}} if there was such a value and was removed. 1370 1371 """ 1372 return None
1373 - def remove_by_prefix( prefix ):
1374 """ 1375 Removes a values whose key start with B{C{prefix}} from container B{C{container}}. 1376 1377 B{C{prefix}} can be B{C{NULL}}, all values are then removed. 1378 1379 1380 @param prefix: A nul-terminated id prefix. I{(string)} 1381 @return: The number of values removed. 1382 1383 """ 1384 return None
1385 - def transfer( dest , source_prefix , dest_prefix , force ):
1386 """ 1387 Copies a items from one place in container to another place. 1388 1389 The copies are shallow, objects are not physically duplicated, only 1390 referenced in B{C{dest}}. 1391 1392 1393 @param dest: Destination container. It may be the same container as B{C{source}}, but 1394 B{C{source_prefix}} and B{C{dest_prefix}} may not overlap then. I{(L{Container})} 1395 @param source_prefix: Prefix in B{C{source}} to take values from. I{(string)} 1396 @param dest_prefix: Prefix in B{C{dest}} to put values to. I{(string)} 1397 @param force: B{C{True}} to replace existing values in B{C{dest}}. I{(bool)} 1398 @return: The number of actually transferred items. 1399 1400 """ 1401 return None
1402 - def rename( key , newkey , force ):
1403 """ 1404 Makes a value in B{C{container}} identified by B{C{key}} to be identified by B{C{newkey}}. 1405 1406 When B{C{force}} is B{C{True}} existing value at B{C{newkey}} is removed from B{C{container}}. 1407 When it's B{C{False}}, an existing value B{C{newkey}} inhibits the rename and B{C{False}} 1408 is returned. 1409 1410 1411 @param key: The current key. I{(int)} 1412 @param newkey: A new key for the value. I{(int)} 1413 @param force: Whether to replace existing value at B{C{newkey}}. I{(bool)} 1414 @return: Whether the rename succeeded. 1415 1416 """ 1417 return None
1418 - def UNIMPLEMENTED_foreach( prefix , function , user_data ):
1419 """ 1420 Calls B{C{function}} on each B{C{container}} item whose identifier starts with 1421 B{C{prefix}}. 1422 1423 The function is called B{C{function}}(B{C{GQuark}} key, B{C{GValue}} *value, user_data). 1424 1425 1426 @param prefix: A nul-terminated id prefix. I{(string)} 1427 @param function: The function called on the items. I{(GHFunc)} 1428 @param user_data: The user data passed to B{C{function}}. I{(gpointer)} 1429 @return: The number of items B{C{function}} was called on. 1430 1431 """ 1432 return None
1433 - def keys( ):
1434 """ 1435 Gets all quark keys of a container. 1436 1437 Since: 2.7 1438 1439 @return: A newly allocated array with quark keys of all B{C{container}} items, 1440 in no particular order. The number of items can be obtained 1441 with L{Container.get_n_items}(). If there are no items, B{C{NULL}} 1442 is returned. 1443 1444 1445 """ 1446 return None
1447 - def keys_by_name( ):
1448 """ 1449 Gets all string keys of a container. 1450 1451 Since: 2.7 1452 1453 @return: A newly allocated array with string keys of all B{C{container}} items, 1454 in no particular order. The number of items can be obtained 1455 with L{Container.get_n_items}(). If there are no items, B{C{NULL}} 1456 is returned. Unlike the array the strings are owned by GLib and 1457 must not be freed. 1458 1459 1460 """ 1461 return None
1462 - def set_boolean( key , value ):
1463 """ 1464 Stores a boolean into B{C{container}}, identified by B{C{key}}. 1465 1466 @param key: A B{C{GQuark}} key. I{(int)} 1467 @param value: A boolean. I{(bool)} 1468 @return: 1469 """ 1470 return None
1471 - def get_boolean( key ):
1472 """ 1473 Returns the boolean in B{C{container}} identified by B{C{key}}. 1474 1475 1476 @param key: A B{C{GQuark}} key. I{(int)} 1477 @return: The boolean as B{C{gboolean}}. 1478 1479 """ 1480 return None
1481 - def UNIMPLEMENTED_gis_boolean( key , value ):
1482 """ 1483 Get-if-set a boolean from a container. 1484 1485 1486 @param key: A B{C{GQuark}} key. I{(int)} 1487 @param value: Pointer to the boolean to update. I{(gboolean*)} 1488 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1489 such boolean in the container. 1490 1491 """ 1492 return None
1493 - def set_uchar( key , value ):
1494 """ 1495 Stores an unsigned character into B{C{container}}, identified by B{C{key}}. 1496 1497 @param key: A B{C{GQuark}} key. I{(int)} 1498 @param value: An unsigned character. I{(guchar)} 1499 @return: 1500 """ 1501 return None
1502 - def get_uchar( key ):
1503 """ 1504 Returns the unsigned character in B{C{container}} identified by B{C{key}}. 1505 1506 1507 @param key: A B{C{GQuark}} key. I{(int)} 1508 @return: The character as B{C{guchar}}. 1509 1510 """ 1511 return None
1512 - def UNIMPLEMENTED_gis_uchar( key , value ):
1513 """ 1514 Get-if-set an unsigned char from a container. 1515 1516 1517 @param key: A B{C{GQuark}} key. I{(int)} 1518 @param value: Pointer to the unsigned char to update. I{(guchar*)} 1519 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1520 such unsigned char in the container. 1521 1522 """ 1523 return None
1524 - def set_int32( key , value ):
1525 """ 1526 Stores a 32bit integer into B{C{container}}, identified by B{C{key}}. 1527 1528 @param key: A B{C{GQuark}} key. I{(int)} 1529 @param value: A 32bit integer. I{(int)} 1530 @return: 1531 """ 1532 return None
1533 - def get_int32( key ):
1534 """ 1535 Returns the 32bit integer in B{C{container}} identified by B{C{key}}. 1536 1537 1538 @param key: A B{C{GQuark}} key. I{(int)} 1539 @return: The integer as B{C{guint32}}. 1540 1541 """ 1542 return None
1543 - def UNIMPLEMENTED_gis_int32( key , value ):
1544 """ 1545 Get-if-set a 32bit integer from a container. 1546 1547 1548 @param key: A B{C{GQuark}} key. I{(int)} 1549 @param value: Pointer to the 32bit integer to update. I{(int)} 1550 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1551 such 32bit integer in the container. 1552 1553 """ 1554 return None
1555 - def set_enum( key , value ):
1556 """ 1557 Stores an enum into B{C{container}}, identified by B{C{key}}. 1558 1559 Note enums are treated as 32bit integers. 1560 1561 @param key: A B{C{GQuark}} key. I{(int)} 1562 @param value: An enum integer. I{(int)} 1563 @return: 1564 """ 1565 return None
1566 - def get_enum( key ):
1567 """ 1568 Returns the enum in B{C{container}} identified by B{C{key}}. 1569 1570 Note enums are treated as 32bit integers. 1571 1572 1573 @param key: A B{C{GQuark}} key. I{(int)} 1574 @return: The enum as B{C{gint}}. 1575 1576 """ 1577 return None
1578 - def UNIMPLEMENTED_gis_enum( key , value ):
1579 """ 1580 Get-if-set an enum from a container. 1581 1582 Note enums are treated as 32bit integers. 1583 1584 1585 @param key: A B{C{GQuark}} key. I{(int)} 1586 @param value: Pointer to the enum to update. I{(int)} 1587 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1588 such enum in the container. 1589 1590 """ 1591 return None
1592 - def set_int64( key , value ):
1593 """ 1594 Stores a 64bit integer into B{C{container}}, identified by B{C{key}}. 1595 1596 @param key: A B{C{GQuark}} key. I{(int)} 1597 @param value: A 64bit integer. I{(gint64)} 1598 @return: 1599 """ 1600 return None
1601 - def get_int64( key ):
1602 """ 1603 Returns the 64bit integer in B{C{container}} identified by B{C{key}}. 1604 1605 1606 @param key: A B{C{GQuark}} key. I{(int)} 1607 @return: The 64bit integer as B{C{guint64}}. 1608 1609 """ 1610 return None
1611 - def UNIMPLEMENTED_gis_int64( key , value ):
1612 """ 1613 Get-if-set a 64bit integer from a container. 1614 1615 1616 @param key: A B{C{GQuark}} key. I{(int)} 1617 @param value: Pointer to the 64bit integer to update. I{(int)} 1618 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1619 such 64bit integer in the container. 1620 1621 """ 1622 return None
1623 - def set_double( key , value ):
1624 """ 1625 Stores a double into B{C{container}}, identified by B{C{key}}. 1626 1627 @param key: A B{C{GQuark}} key. I{(int)} 1628 @param value: A double. I{(float)} 1629 @return: 1630 """ 1631 return None
1632 - def get_double( key ):
1633 """ 1634 Returns the double in B{C{container}} identified by B{C{key}}. 1635 1636 1637 @param key: A B{C{GQuark}} key. I{(int)} 1638 @return: The double as B{C{gdouble}}. 1639 1640 """ 1641 return None
1642 - def UNIMPLEMENTED_gis_double( key , value ):
1643 """ 1644 Get-if-set a double from a container. 1645 1646 1647 @param key: A B{C{GQuark}} key. I{(int)} 1648 @param value: Pointer to the double to update. I{(float)} 1649 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1650 such double in the container. 1651 1652 """ 1653 return None
1654 - def set_string( key , value ):
1655 """ 1656 Set string for key to given value 1657 1658 1659 @param value: new string I{(string)} 1660 @return: 1661 """ 1662 return None
1663 - def set_const_string( key , value ):
1664 """ 1665 Stores a string into B{C{container}}, identified by B{C{key}}. 1666 1667 The container makes a copy of the string, so it can be used on static 1668 strings. 1669 1670 Since: 2.38 1671 1672 @param key: A B{C{GQuark}} key. I{(int)} 1673 @param value: A nul-terminated string. I{(string)} 1674 @return: 1675 """ 1676 return None
1677 - def get_string( key ):
1678 """ 1679 Returns the string in B{C{container}} identified by B{C{key}}. 1680 1681 The returned string must be treated as constant and never freed or modified. 1682 1683 1684 @param key: A B{C{GQuark}} key. I{(int)} 1685 @return: The string. 1686 1687 """ 1688 return None
1689 - def UNIMPLEMENTED_gis_string( key , value ):
1690 """ 1691 Get-if-set a string from a container. 1692 1693 The string eventually stored in B{C{value}} must be treated as constant and 1694 never freed or modified. 1695 1696 1697 @param key: A B{C{GQuark}} key. I{(int)} 1698 @param value: Pointer to the string pointer to update. I{(const-guchar**)} 1699 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1700 such string in the container. 1701 1702 """ 1703 return None
1704 - def set_object( key , value ):
1705 """ 1706 Stores an object into B{C{container}}, identified by B{C{key}}. 1707 1708 The container claims ownership on the object, i.e. its reference count is 1709 incremented. 1710 1711 The object must implement B{C{Serializable}} interface to allow serialization 1712 of the container. 1713 1714 @param key: A B{C{GQuark}} key. I{(int)} 1715 @param value: An object to store into container. I{(gpointer)} 1716 @return: 1717 """ 1718 return None
1719 - def get_object( key ):
1720 """ 1721 Get object of given key from container. 1722 1723 1724 @return: object of given key 1725 1726 """ 1727 return None
1728 - def gis_object( key , value ):
1729 """ 1730 Get-if-set an object from a container. 1731 1732 The object eventually stored in B{C{value}} doesn't have its reference count 1733 increased, use g_object_ref() if you want to access it even when 1734 B{C{container}} may cease to exist. 1735 1736 1737 @param key: A B{C{GQuark}} key. I{(int)} 1738 @param value: Pointer to the object pointer to update. I{(gpointer)} 1739 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 1740 such object in the container. 1741 1742 """ 1743 return None
1745 """ 1746 Creates a text representation of B{C{container}} contents. 1747 1748 Note only simple data types are supported as serialization of compound 1749 objects is not controllable. 1750 1751 1752 @return: A pointer array, each item containing string with one container 1753 item representation (name, type, value). The array is sorted by name. 1754 1755 """ 1756 return None
1757 - def contains_by_name( name ):
1758 """ 1759 Expands to B{C{True}} if container B{C{c}} contains a value identified by name B{C{n}}. 1760 1761 @param n: A nul-terminated name (id). 1762 @return: 1763 """ 1764 return None
1765 - def remove_by_name( name ):
1766 """ 1767 Removes a value identified by name B{C{n}} from container B{C{c}}. 1768 1769 Expands to B{C{True}} if there was such a value and was removed. 1770 1771 @param n: A nul-terminated name (id). 1772 @return: 1773 """ 1774 return None
1775 - def rename_by_name( name , new_name , delete ):
1776 """ 1777 Makes a value in container B{C{c}} identified by name B{C{n}} to be identified by 1778 new name B{C{nn}}. 1779 1780 See L{Container.rename}() for details. 1781 1782 @param n: A nul-terminated name (id). 1783 @param nn: A nul-terminated name (id). 1784 @param f: Whether to delete existing value at B{C{newkey}}. 1785 @return: 1786 """ 1787 return None
1788 - def set_boolean_by_name( name , value ):
1789 """ 1790 Stores a boolean into container B{C{c}}, identified by name B{C{n}}. 1791 1792 @param n: A nul-terminated name (id). 1793 @param v: A boolean. 1794 @return: 1795 """ 1796 return None
1797 - def set_double_by_name( name , value ):
1798 """ 1799 Stores a double into container B{C{c}}, identified by name B{C{n}}. 1800 1801 @param n: A nul-terminated name (id). 1802 @param v: A double integer. 1803 @return: 1804 """ 1805 return None
1806 - def set_enum_by_name( name , value ):
1807 """ 1808 Stores an enum into container B{C{c}}, identified by name B{C{n}}. 1809 1810 Note enums are treated as 32bit integers. 1811 1812 @param n: A nul-terminated name (id). 1813 @param v: An enum. 1814 @return: 1815 """ 1816 return None
1817 - def set_int32_by_name( name , value ):
1818 """ 1819 Stores a 32bit integer into container B{C{c}}, identified by name B{C{n}}. 1820 1821 @param n: A nul-terminated name (id). 1822 @param v: A 32bit integer. 1823 @return: 1824 """ 1825 return None
1826 - def set_int64_by_name( name , value ):
1827 """ 1828 Stores a 64bit integer into container B{C{c}}, identified by name B{C{n}}. 1829 1830 @param n: A nul-terminated name (id). 1831 @param v: A 64bit integer. 1832 @return: 1833 """ 1834 return None
1835 - def set_object_by_name( name , value ):
1836 """ 1837 Stores an object into container B{C{c}}, identified by name B{C{n}}. 1838 1839 See L{Container.set_object}() for details. 1840 1841 @param n: A nul-terminated name (id). 1842 @param v: An object to store into container. 1843 @return: 1844 """ 1845 return None
1846 - def set_uchar_by_name( name , value ):
1847 """ 1848 Stores an unsigned character into container B{C{c}}, identified by name B{C{n}}. 1849 1850 @param n: A nul-terminated name (id). 1851 @param v: An unsigned character. 1852 @return: 1853 """ 1854 return None
1855 - def set_string_by_name( name , value ):
1856 """ 1857 Stores a string into container B{C{c}}, identified by name B{C{n}}. 1858 1859 The container takes ownership of the string, so it can't be used on 1860 static strings, use g_strdup() to duplicate them first. 1861 1862 @param n: A nul-terminated name (id). 1863 @param v: A nul-terminated string. 1864 @return: 1865 """ 1866 return None
1867 - def get_boolean_by_name( name ):
1868 """ 1869 Gets the boolean in container B{C{c}} identified by name B{C{n}}. 1870 1871 @param n: A nul-terminated name (id). 1872 @return: 1873 """ 1874 return None
1875 - def get_double_by_name( name ):
1876 """ 1877 Gets the double in container B{C{c}} identified by name B{C{n}}. 1878 1879 @param n: A nul-terminated name (id). 1880 @return: 1881 """ 1882 return None
1883 - def get_enum_by_name( name ):
1884 """ 1885 Gets the enum in container B{C{c}} identified by name B{C{n}}. 1886 1887 Note enums are treated as 32bit integers. 1888 1889 @param n: A nul-terminated name (id). 1890 @return: 1891 """ 1892 return None
1893 - def get_int32_by_name( name ):
1894 """ 1895 Gets the 32bit integer in container B{C{c}} identified by name B{C{n}}. 1896 1897 @param n: A nul-terminated name (id). 1898 @return: 1899 """ 1900 return None
1901 - def get_int64_by_name( name ):
1902 """ 1903 Gets the 64bit integer in container B{C{c}} identified by name B{C{n}}. 1904 1905 @param n: A nul-terminated name (id). 1906 @return: 1907 """ 1908 return None
1909 - def get_object_by_name( name ):
1910 """ 1911 Gets the object in container B{C{c}} identified by name B{C{n}}. 1912 1913 The returned object doesn't have its reference count increased, use 1914 g_object_ref() if you want to access it even when B{C{container}} may cease 1915 to exist. 1916 1917 @param n: A nul-terminated name (id). 1918 @return: 1919 """ 1920 return None
1921 - def get_uchar_by_name( name ):
1922 """ 1923 Gets the unsigned character in container B{C{c}} identified by name B{C{n}}. 1924 1925 @param n: A nul-terminated name (id). 1926 @return: 1927 """ 1928 return None
1929 - def get_value_by_name( name ):
1930 """ 1931 Gets the value in container B{C{c}} identified by name B{C{n}}. 1932 1933 @param n: A nul-terminated name (id). 1934 @return: 1935 """ 1936 return None
1937 - def get_string_by_name( name ):
1938 """ 1939 Gets the string in container B{C{c}} identified by name B{C{n}}. 1940 1941 The returned string must be treated as constant and never freed or modified. 1942 1943 @param n: A nul-terminated name (id). 1944 @return: 1945 """ 1946 return None
1947 - def get_object( key ):
1948 """ 1949 Get object of given key from container. 1950 1951 1952 @return: object of given key 1953 1954 """ 1955 return None
1956 - def set_string( key , value ):
1957 """ 1958 Set string for key to given value 1959 1960 1961 @param value: new string I{(some_type)} 1962 @return: 1963 """ 1964 return None
1965 -class Curve:
1966 - def __init__( ):
1967 """ 1968 Creates B{C{Curve}} widget. By default, the widget will have 3 curves. 1969 1970 1971 @return: new B{C{Curve}} widget. 1972 1973 """ 1974 return None
1975 - def reset( ):
1976 """ 1977 Removes all control points, resetting the curves to their initial state. 1978 1979 1980 @return: 1981 """ 1982 return None
1983 - def set_range( min_x , max_x , min_y , max_y ):
1984 return None
1985 - def set_curve_type( type ):
1986 return None
1987 - def set_channels( num_channels , colors ):
1988 return None
1989 - def UNIMPLEMENTED_set_control_points( channel_data , prune ):
1990 return None
1991 - def UNIMPLEMENTED_get_control_points( channel_data , triplets ):
1992 return None
1993 -class DataField:
1994 - def __init__( xres , yres , xreal , yreal , nullme ):
1995 """ 1996 Creates a new data field. 1997 1998 1999 @param yres: Y-resolution, i.e., the number of rows. I{(int)} 2000 @param xreal: Real horizontal physical dimension. I{(float)} 2001 @param yreal: Real vertical physical dimension. I{(float)} 2002 @param nullme: Whether the data field should be initialized to zeroes. If B{C{False}}, 2003 the data will not be initialized. I{(bool)} 2004 @return: A newly created data field. 2005 2006 """ 2007 return None
2008 - def sum_fields( operand1 , operand2 ):
2009 """ 2010 Sums two data fields. 2011 2012 @param operand1: First data field operand. I{(L{DataField})} 2013 @param operand2: Second data field operand. I{(L{DataField})} 2014 @return: 2015 """ 2016 return None
2017 - def subtract_fields( operand1 , operand2 ):
2018 """ 2019 Subtracts one data field from another. 2020 2021 @param operand1: First data field operand. I{(L{DataField})} 2022 @param operand2: Second data field operand. I{(L{DataField})} 2023 @return: 2024 """ 2025 return None
2026 - def divide_fields( operand1 , operand2 ):
2027 """ 2028 Divides one data field with another. 2029 2030 @param operand1: First data field operand. I{(L{DataField})} 2031 @param operand2: Second data field operand. I{(L{DataField})} 2032 @return: 2033 """ 2034 return None
2035 - def multiply_fields( operand1 , operand2 ):
2036 """ 2037 Multiplies two data fields. 2038 2039 @param operand1: First data field operand. I{(L{DataField})} 2040 @param operand2: Second data field operand. I{(L{DataField})} 2041 @return: 2042 """ 2043 return None
2044 - def min_of_fields( operand1 , operand2 ):
2045 """ 2046 Finds point-wise maxima of two data fields. 2047 2048 @param operand1: First data field operand. I{(L{DataField})} 2049 @param operand2: Second data field operand. I{(L{DataField})} 2050 @return: 2051 """ 2052 return None
2053 - def max_of_fields( operand1 , operand2 ):
2054 """ 2055 Finds point-wise minima of two data fields. 2056 2057 @param operand1: First data field operand. I{(L{DataField})} 2058 @param operand2: Second data field operand. I{(L{DataField})} 2059 @return: 2060 """ 2061 return None
2062 - def hypot_of_fields( operand1 , operand2 ):
2063 """ 2064 Finds point-wise hypotenuse of two data fields. 2065 2066 Since: 2.31 2067 2068 @param operand1: First data field operand. I{(L{DataField})} 2069 @param operand2: Second data field operand. I{(L{DataField})} 2070 @return: 2071 """ 2072 return None
2073 - def check_compatibility( data_field2 , check ):
2074 """ 2075 Checks whether two data fields are compatible. 2076 2077 2078 @param data_field2: Another data field. I{(L{DataField})} 2079 @param check: The compatibility tests to perform. I{(DataCompatibilityFlags)} 2080 @return: Zero if all tested properties are compatible. Flags corresponding 2081 to failed tests if data fields are not compatible. 2082 2083 """ 2084 return None
2085 - def extend( left , right , up , down , exterior , fill_value , keep_offsets ):
2086 """ 2087 Creates a new data field by extending another data field using the specified 2088 method of exterior handling. 2089 2090 Since: 2.36 2091 2092 @param left: Number of pixels to extend to the left (towards lower column indices). I{(int)} 2093 @param right: Number of pixels to extend to the right (towards higher column 2094 indices). I{(int)} 2095 @param up: Number of pixels to extend up (towards lower row indices). I{(int)} 2096 @param down: Number of pixels to extend down (towards higher row indices). I{(int)} 2097 @param exterior: Exterior pixels handling. I{(ExteriorType)} 2098 @param fill_value: The value to use with B{C{EXTERIOR_FIXED_VALUE}} exterior. I{(float)} 2099 @param keep_offsets: B{C{True}} to set the X and Y offsets of the new field 2100 using B{C{field}} offsets. B{C{False}} to set offsets 2101 of the new field to zeroes. I{(bool)} 2102 @return: A newly created data field. 2103 2104 2105 """ 2106 return None
2107 - def correct_laplace_iteration( mask_field , buffer_field , corrfactor , error ):
2108 """ 2109 Performs one interation of Laplace data correction. 2110 2111 Tries to remove all the points in mask off the data by using 2112 iterative method similar to solving heat flux equation. 2113 2114 Use this function repeatedly until reasonable B{C{error}} is reached. 2115 2116 @param mask_field: Mask of places to be corrected. I{(L{DataField})} 2117 @param buffer_field: Initialized to same size as mask and data. I{(L{DataField})} 2118 @param error: Maximum change within last step. I{(float)} 2119 @param corrfactor: Correction factor within step. I{(float)} 2120 @return: 2121 """ 2122 return None
2123 - def correct_average( mask_field ):
2124 """ 2125 Fills data under mask with average value. 2126 2127 Simply puts average value of all the B{C{data_field}} values into 2128 points in B{C{data_field}} lying under points where B{C{mask_field}} values 2129 are nonzero. 2130 2131 @param mask_field: Mask of places to be corrected. I{(L{DataField})} 2132 @return: 2133 """ 2134 return None
2135 - def mask_outliers( mask_field , thresh ):
2136 """ 2137 Creates mask of data that are above or below B{C{thresh}}*sigma from average 2138 height. 2139 2140 Sigma denotes root-mean square deviation of heights. This criterium 2141 corresponds to the usual Gaussian distribution outliers detection if 2142 B{C{thresh}} is 3. 2143 2144 @param mask_field: A data field to be filled with mask. I{(L{DataField})} 2145 @param thresh: Threshold value. I{(float)} 2146 @return: 2147 """ 2148 return None
2149 - def mask_outliers2( mask_field , thresh_low , thresh_high ):
2150 """ 2151 Creates mask of data that are above or below multiples of rms from average 2152 height. 2153 2154 Data that are below B{C{mean}}-B{C{thresh_low}}*B{C{sigma}} or above 2155 B{C{mean}}+B{C{thresh_high}}*B{C{sigma}} are marked as outliers, where B{C{sigma}} denotes the 2156 root-mean square deviation of heights. 2157 2158 Since: 2.26 2159 2160 @param mask_field: A data field to be filled with mask. I{(L{DataField})} 2161 @param thresh_low: Lower threshold value. I{(float)} 2162 @param thresh_high: Upper threshold value. I{(float)} 2163 @return: 2164 """ 2165 return None
2166 - def UNIMPLEMENTED_distort( dest , invtrans , user_data , interp , exterior , fill_value ):
2167 """ 2168 Distorts a data field in the horizontal plane. 2169 2170 Note the transform function B{C{invtrans}} is the inverse transform, in other 2171 words it calculates the old coordinates from the new coordinates (the 2172 transform would not be uniquely defined the other way round). 2173 2174 Since: 2.5 2175 2176 @param dest: Destination data field. I{(L{DataField})} 2177 @param invtrans: Inverse transform function, that is the transformation from 2178 new coordinates to old coordinates. It gets 2179 (B{C{j}}+0.5, B{C{i}}+0.5), where B{C{i}} and B{C{j}} are the new row and column 2180 indices, passed as the input coordinates. The output coordinates 2181 should follow the same convention. Unless a special exterior 2182 handling is required, the transform function does not need to 2183 concern itself with coordinates being outside of the data. I{(CoordTransform2DFunc)} 2184 @param user_data: Pointer passed as B{C{user_data}} to B{C{invtrans}}. I{(gpointer)} 2185 @param interp: Interpolation type to use. I{(InterpolationType)} 2186 @param exterior: Exterior pixels handling. I{(ExteriorType)} 2187 @param fill_value: The value to use with B{C{EXTERIOR_FIXED_VALUE}}. I{(float)} 2188 @return: 2189 """ 2190 return None
2191 - def affine( dest , invtrans , interp , exterior , fill_value ):
2192 """ 2193 Performs an affine transformation of a data field in the horizontal plane. 2194 2195 Note the transform B{C{invtrans}} is the inverse transform, in other 2196 words it calculates the old coordinates from the new coordinates. This 2197 way even degenerate (non-invertible) transforms can be meaningfully used. 2198 Also note that the (column, row) coordinate system is left-handed. 2199 2200 Since: 2.34 2201 2202 @param dest: Destination data field. I{(L{DataField})} 2203 @param invtrans: Inverse transform, that is the transformation from 2204 new pixel coordinates to old pixel coordinates, represented as 2205 (B{C{j}}+0.5, B{C{i}}+0.5), where B{C{i}} and B{C{j}} are the row and column 2206 indices. It is represented as a six-element array [B{C{axx}}, B{C{axy}}, 2207 B{C{ayx}}, B{C{ayy}}, B{C{bx}}, B{C{by}}] where B{C{axy}} is the coefficient from B{C{x}} to 2208 B{C{y}}. I{(const-gdouble*)} 2209 @param interp: Interpolation type to use. I{(InterpolationType)} 2210 @param exterior: Exterior pixels handling. I{(ExteriorType)} 2211 @param fill_value: The value to use with B{C{EXTERIOR_FIXED_VALUE}}. I{(float)} 2212 @return: 2213 """ 2214 return None
2215 - def get_correlation_score( kernel_field , col , row , kernel_col , kernel_row , kernel_width , kernel_height ):
2216 """ 2217 Calculates a correlation score in one point. 2218 2219 Correlation window size is given 2220 by B{C{kernel_col}}, B{C{kernel_row}}, B{C{kernel_width}}, B{C{kernel_height}}, 2221 postion of the correlation window on data is given by 2222 B{C{col}}, B{C{row}}. 2223 2224 If anything fails (data too close to boundary, etc.), 2225 function returns -1.0 (none correlation).. 2226 2227 2228 @param kernel_field: Kernel to correlate data field with. I{(L{DataField})} 2229 @param col: Upper-left column position in the data field. I{(int)} 2230 @param row: Upper-left row position in the data field. I{(int)} 2231 @param kernel_col: Upper-left column position in kernel field. I{(int)} 2232 @param kernel_row: Upper-left row position in kernel field. I{(int)} 2233 @param kernel_width: Width of kernel field area. I{(int)} 2234 @param kernel_height: Heigh of kernel field area. I{(int)} 2235 @return: Correlation score (between -1.0 and 1.0). Value 1.0 denotes 2236 maximum correlation, -1.0 none correlation. 2237 2238 """ 2239 return None
2240 - def crosscorrelate( data_field2 , x_dist , y_dist , score , search_width , search_height , window_width , window_height ):
2241 """ 2242 Algorithm for matching two different images of the same object under changes. 2243 2244 It does not use any special features 2245 for matching. It simply searches for all points (with their neighbourhood) 2246 of B{C{data_field1}} within B{C{data_field2}}. Parameters B{C{search_width}} and 2247 B{C{search_height}} 2248 determine maimum area where to search for points. The area is cenetered 2249 in the B{C{data_field2}} at former position of points at B{C{data_field1}}. 2250 2251 @param data_field2: A data field. I{(L{DataField})} 2252 @param x_dist: A data field to store x-distances to. I{(L{DataField})} 2253 @param y_dist: A data field to store y-distances to. I{(L{DataField})} 2254 @param score: Data field to store correlation scores to. I{(L{DataField})} 2255 @param search_width: Search area width. I{(int)} 2256 @param search_height: Search area height. I{(int)} 2257 @param window_width: Correlation window width. This parameter is not actually 2258 used. Pass zero. I{(int)} 2259 @param window_height: Correlation window height. This parameter is not actually 2260 used. Pass zero. I{(int)} 2261 @return: 2262 """ 2263 return None
2264 - def UNIMPLEMENTED_crosscorrelate_init( data_field2 , x_dist , y_dist , score , search_width , search_height , window_width , window_height ):
2265 """ 2266 Initializes a cross-correlation iterator. 2267 2268 This iterator reports its state as B{C{ComputationStateType}}. 2269 2270 2271 @param data_field2: A data field. I{(L{DataField})} 2272 @param x_dist: A data field to store x-distances to, or B{C{NULL}}. I{(L{DataField})} 2273 @param y_dist: A data field to store y-distances to, or B{C{NULL}}. I{(L{DataField})} 2274 @param score: Data field to store correlation scores to, or B{C{NULL}}. I{(L{DataField})} 2275 @param search_width: Search area width. I{(int)} 2276 @param search_height: Search area height. I{(int)} 2277 @param window_width: Correlation window width. I{(int)} 2278 @param window_height: Correlation window height. I{(int)} 2279 @return: A new cross-correlation iterator. 2280 2281 """ 2282 return None
2283 - def correlate( kernel_field , score , method ):
2284 """ 2285 Computes correlation score for all positions in a data field. 2286 2287 Correlation score is compute for all points in data field B{C{data_field}} 2288 and full size of correlation kernel B{C{kernel_field}}. 2289 2290 The points in B{C{score}} correspond to centers of kernel. More precisely, the 2291 point ((B{C{kxres}}-1)/2, (B{C{kyres}}-1)/2) in B{C{score}} corresponds to kernel field 2292 top left corner coincident with data field top left corner. Points outside 2293 the area where the kernel field fits into the data field completely are 2294 set to -1 for B{C{CORRELATION_NORMAL}}. 2295 2296 @param kernel_field: Correlation kernel. I{(L{DataField})} 2297 @param score: Data field to store correlation scores to. I{(L{DataField})} 2298 @param method: Correlation score calculation method. I{(CorrelationType)} 2299 @return: 2300 """ 2301 return None
2302 - def UNIMPLEMENTED_correlate_init( kernel_field , score ):
2303 """ 2304 Creates a new correlation iterator. 2305 2306 This iterator reports its state as B{C{ComputationStateType}}. 2307 2308 2309 @param kernel_field: Kernel to correlate data field with. I{(L{DataField})} 2310 @param score: Data field to store correlation scores to. I{(L{DataField})} 2311 @return: A new correlation iterator. 2312 2313 """ 2314 return None
2315 - def invalidate( ):
2316 """ 2317 Invalidates cached data field stats. 2318 2319 User code should rarely need this macro, as all B{C{DataField}} methods do 2320 proper invalidation when they change data, as well as 2321 L{DataField.get_data}() does. 2322 2323 However, if you get raw data with L{DataField.get_data}() and then mix 2324 direct changes to it with calls to methods like L{DataField.get_max}(), 2325 you may need to explicitely invalidate cached values to let 2326 L{DataField.get_max}() know it has to recompute the maximum. 2327 2328 @return: 2329 """ 2330 return None
2331 - def new_alike( nullme ):
2332 """ 2333 Creates a new data field similar to an existing one. 2334 2335 Use L{DataField.duplicate}() if you want to copy a data field including 2336 data. 2337 2338 2339 @param nullme: Whether the data field should be initialized to zeroes. If B{C{False}}, 2340 the data will not be initialized. I{(bool)} 2341 @return: A newly created data field. 2342 2343 """ 2344 return None
2345 - def data_changed( ):
2346 """ 2347 Emits signal "data-changed" on a data field. 2348 2349 @return: 2350 """ 2351 return None
2352 - def new_resampled( xres , yres , interpolation ):
2353 """ 2354 Creates a new data field by resampling an existing one. 2355 2356 This method is equivalent to L{DataField.duplicate}() followed by 2357 L{DataField.resample}(), but it is more efficient. 2358 2359 2360 @param xres: Desired X resolution. I{(int)} 2361 @param yres: Desired Y resolution. I{(int)} 2362 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2363 @return: A newly created data field. 2364 2365 """ 2366 return None
2367 - def resample( xres , yres , interpolation ):
2368 """ 2369 Resamples a data field using given interpolation method 2370 2371 This method may invalidate raw data buffer returned by 2372 L{DataField.get_data}(). 2373 2374 @param xres: Desired X resolution. I{(int)} 2375 @param yres: Desired Y resolution. I{(int)} 2376 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2377 @return: 2378 """ 2379 return None
2380 - def resize( ulcol , ulrow , brcol , brrow ):
2381 """ 2382 Resizes (crops) a data field. 2383 2384 Crops a data field to a rectangle between upper-left and bottom-right 2385 points, recomputing real size. 2386 2387 This method may invalidate raw data buffer returned by 2388 L{DataField.get_data}(). 2389 2390 @param ulcol: Upper-left column coordinate. I{(int)} 2391 @param ulrow: Upper-left row coordinate. I{(int)} 2392 @param brcol: Bottom-right column coordinate + 1. I{(int)} 2393 @param brrow: Bottom-right row coordinate + 1. I{(int)} 2394 @return: 2395 """ 2396 return None
2397 - def area_extract( col , row , width , height ):
2398 """ 2399 Extracts a rectangular part of a data field to a new data field. 2400 2401 2402 @param row: Upper-left row coordinate. I{(int)} 2403 @param col: Upper-left column coordinate. I{(int)} 2404 @param width: Area width (number of columns). I{(int)} 2405 @param height: Area height (number of rows). I{(int)} 2406 @return: The extracted area as a newly created data field. 2407 2408 """ 2409 return None
2410 - def copy( dest , nondata_too ):
2411 """ 2412 Copies the contents of an already allocated data field to a data field 2413 of the same size. 2414 2415 @param dest: Destination data field. I{(L{DataField})} 2416 @param nondata_too: Whether non-data (units) should be compied too. I{(bool)} 2417 @return: 2418 """ 2419 return None
2420 - def area_copy( dest , col , row , width , height , destcol , destrow ):
2421 """ 2422 Copies a rectangular area from one data field to another. 2423 2424 The area starts at (B{C{col}}, B{C{row}}) in B{C{src}} and its dimension is B{C{width}}*B{C{height}}. 2425 It is copied to B{C{dest}} starting from (B{C{destcol}}, B{C{destrow}}). 2426 2427 The source area has to be completely contained in B{C{src}}. No assumptions are 2428 made about destination position, however, parts of the source area sticking 2429 out the destination data field B{C{dest}} are cut off. 2430 2431 If B{C{src}} is equal to B{C{dest}}, the areas may not overlap. 2432 2433 @param dest: Destination data field. I{(L{DataField})} 2434 @param col: Area upper-left column coordinate in B{C{src}}. I{(int)} 2435 @param row: Area upper-left row coordinate B{C{src}}. I{(int)} 2436 @param width: Area width (number of columns), pass -1 for full B{C{src}} widdth. I{(int)} 2437 @param height: Area height (number of rows), pass -1 for full B{C{src}} height. I{(int)} 2438 @param destcol: Destination column in B{C{dest}}. I{(int)} 2439 @param destrow: Destination row in B{C{dest}}. I{(int)} 2440 @return: 2441 """ 2442 return None
2443 - def get_data( ):
2444 """ 2445 Create a tuple of data which the datafield contains. Content of the tuple is NOT reference to original datafield but its copy. 2446 2447 2448 @return: tuple of raw numeric data from DataField 2449 2450 """ 2451 return None
2452 - def get_xres( ):
2453 """ 2454 Gets X resolution (number of columns) of a data field. 2455 2456 2457 @return: X resolution. 2458 2459 """ 2460 return None
2461 - def get_yres( ):
2462 """ 2463 Gets Y resolution (number of rows) of the field. 2464 2465 2466 @return: Y resolution. 2467 2468 """ 2469 return None
2470 - def get_xreal( ):
2471 """ 2472 Gets the X real (physical) size of a data field. 2473 2474 2475 @return: X real size value. 2476 2477 """ 2478 return None
2479 - def get_yreal( ):
2480 """ 2481 Gets the Y real (physical) size of a data field. 2482 2483 2484 @return: Y real size value. 2485 2486 """ 2487 return None
2488 - def set_xreal( xreal ):
2489 """ 2490 Sets X real (physical) size value of a data field. 2491 2492 @param xreal: New X real size value. I{(float)} 2493 @return: 2494 """ 2495 return None
2496 - def set_yreal( yreal ):
2497 """ 2498 Sets Y real (physical) size value of a data field. 2499 2500 @param yreal: New Y real size value. I{(float)} 2501 @return: 2502 """ 2503 return None
2504 - def get_xoffset( ):
2505 """ 2506 Gets the X offset of data field origin. 2507 2508 2509 @return: X offset value. 2510 2511 """ 2512 return None
2513 - def get_yoffset( ):
2514 """ 2515 Gets the Y offset of data field origin. 2516 2517 2518 @return: Y offset value. 2519 2520 """ 2521 return None
2522 - def set_xoffset( xoff ):
2523 """ 2524 Sets the X offset of a data field origin. 2525 2526 Note offsets don't affect any calculation, nor functions like 2527 L{DataField.rotj}(). 2528 2529 @param xoff: New X offset value. I{(float)} 2530 @return: 2531 """ 2532 return None
2533 - def set_yoffset( yoff ):
2534 """ 2535 Sets the Y offset of a data field origin. 2536 2537 Note offsets don't affect any calculation, nor functions like 2538 L{DataField.rtoi}(). 2539 2540 @param yoff: New Y offset value. I{(float)} 2541 @return: 2542 """ 2543 return None
2544 - def get_si_unit_xy( ):
2545 """ 2546 Returns lateral SI unit of a data field. 2547 2548 2549 @return: SI unit corresponding to the lateral (XY) dimensions of the data 2550 field. Its reference count is not incremented. 2551 2552 """ 2553 return None
2554 - def get_si_unit_z( ):
2555 """ 2556 Returns value SI unit of a data field. 2557 2558 2559 @return: SI unit corresponding to the "height" (Z) dimension of the data 2560 field. Its reference count is not incremented. 2561 2562 """ 2563 return None
2564 - def set_si_unit_xy( si_unit ):
2565 """ 2566 Sets the SI unit corresponding to the lateral (XY) dimensions of a data 2567 field. 2568 2569 It does not assume a reference on B{C{si_unit}}, instead it adds its own 2570 reference. 2571 2572 @param si_unit: SI unit to be set. I{(L{SIUnit})} 2573 @return: 2574 """ 2575 return None
2576 - def set_si_unit_z( si_unit ):
2577 """ 2578 Sets the SI unit corresponding to the "height" (Z) dimension of a data 2579 field. 2580 2581 It does not assume a reference on B{C{si_unit}}, instead it adds its own 2582 reference. 2583 2584 @param si_unit: SI unit to be set. I{(L{SIUnit})} 2585 @return: 2586 """ 2587 return None
2588 - def UNIMPLEMENTED_get_value_format_xy( style , format ):
2589 """ 2590 Finds value format good for displaying coordinates of a data field. 2591 2592 2593 @param style: Unit format style. I{(SIUnitFormatStyle)} 2594 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 2595 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 2596 is returned, otherwise (modified) B{C{format}} itself is returned. 2597 2598 """ 2599 return None
2600 - def UNIMPLEMENTED_get_value_format_z( style , format ):
2601 """ 2602 Finds value format good for displaying values of a data field. 2603 2604 2605 @param style: Unit format style. I{(SIUnitFormatStyle)} 2606 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 2607 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 2608 is returned, otherwise (modified) B{C{format}} itself is returned. 2609 2610 """ 2611 return None
2612 - def copy_units_to_data_line( data_line ):
2613 """ 2614 Sets lateral and value units of a data line to match a data field. 2615 2616 @param data_line: A data line to set units of. I{(L{DataLine})} 2617 @return: 2618 """ 2619 return None
2620 - def itor( row ):
2621 """ 2622 Transforms vertical pixel coordinate to real (physical) Y coordinate. 2623 2624 That is it maps range [0..y-resolution] to range [0..real-y-size]. 2625 It is not suitable for conversion of matrix indices to physical coordinates, 2626 you have to use L{DataField.itor}(B{C{data_field}}, B{C{row}} + 0.5) for that. 2627 2628 2629 @param row: Vertical pixel coordinate. I{(float)} 2630 @return: Real Y coordinate. 2631 2632 """ 2633 return None
2634 - def jtor( col ):
2635 """ 2636 Transforms horizontal pixel coordinate to real (physical) X coordinate. 2637 2638 That is it maps range [0..x-resolution] to range [0..real-x-size]. 2639 It is not suitable for conversion of matrix indices to physical coordinates, 2640 you have to use L{DataField.jtor}(B{C{data_field}}, B{C{col}} + 0.5) for that. 2641 2642 2643 @param col: Horizontal pixel coordinate. I{(float)} 2644 @return: Real X coordinate. 2645 2646 """ 2647 return None
2648 - def rtoi( realy ):
2649 """ 2650 Transforms real (physical) Y coordinate to row. 2651 2652 That is it maps range [0..real-y-size] to range [0..y-resolution]. 2653 2654 2655 @param realy: Real (physical) Y coordinate. I{(float)} 2656 @return: Vertical pixel coodinate. 2657 2658 """ 2659 return None
2660 - def rtoj( realx ):
2661 """ 2662 Transforms real (physical) X coordinate to column. 2663 2664 That is it maps range [0..real-x-size] to range [0..x-resolution]. 2665 2666 2667 @param realx: Real (physical) X coodinate. I{(float)} 2668 @return: Horizontal pixel coordinate. 2669 2670 """ 2671 return None
2672 - def get_val( col , row ):
2673 """ 2674 Gets value at given position in a data field. 2675 2676 Do not access data with this function inside inner loops, it's slow. 2677 Get the raw data buffer with L{DataField.get_data_const}() and access it 2678 directly instead. 2679 2680 2681 @param col: Column index. I{(int)} 2682 @param row: Row index. I{(int)} 2683 @return: Value at (B{C{col}}, B{C{row}}). 2684 2685 """ 2686 return None
2687 - def set_val( col , row , value ):
2688 """ 2689 Sets value at given position in a data field. 2690 2691 Do not set data with this function inside inner loops, it's slow. Get the 2692 raw data buffer with L{DataField.get_data}() and write to it directly 2693 instead. 2694 2695 @param col: Column index. I{(int)} 2696 @param row: Row index. I{(int)} 2697 @param value: Value to set. I{(float)} 2698 @return: 2699 """ 2700 return None
2701 - def get_dval( x , y , interpolation ):
2702 """ 2703 Gets interpolated value at arbitrary data field point indexed by pixel 2704 coordinates. 2705 2706 Note pixel values are centered in pixels, so to get the same 2707 value as L{DataField.get_val}(B{C{data_field}}, B{C{j}}, B{C{i}}) returns, 2708 it's necessary to add 0.5: 2709 L{DataField.get_dval}(B{C{data_field}}, B{C{j}}+0.5, B{C{i}}+0.5, B{C{interpolation}}). 2710 2711 See also L{DataField.get_dval_real}() that does the same, but takes 2712 real coordinates. 2713 2714 2715 @param x: Horizontal position in pixel units, in range [0, x-resolution]. I{(float)} 2716 @param y: Vertical postition in pixel units, in range [0, y-resolution]. I{(float)} 2717 @param interpolation: Interpolation method to be used. I{(InterpolationType)} 2718 @return: Interpolated value at position (B{C{x}},B{C{y}}). 2719 2720 """ 2721 return None
2722 - def get_dval_real( x , y , interpolation ):
2723 """ 2724 Gets interpolated value at arbitrary data field point indexed by real 2725 coordinates. 2726 2727 See also L{DataField.get_dval}() that does the same, but takes pixel 2728 coordinates. 2729 2730 2731 @param x: X postion in real coordinates. I{(float)} 2732 @param y: Y postition in real coordinates. I{(float)} 2733 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2734 @return: Value at position (B{C{x}},B{C{y}}). 2735 2736 """ 2737 return None
2738 - def rotate( angle , interpolation ):
2739 """ 2740 Rotates a data field by a given angle. 2741 2742 Values that get outside of data field by the rotation are lost. 2743 Undefined values from outside of data field that get inside are set to 2744 data field minimum value. 2745 2746 @param angle: Rotation angle (in radians). I{(float)} 2747 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2748 @return: 2749 """ 2750 return None
2751 - def invert( x , y , z ):
2752 """ 2753 Reflects amd/or inverts a data field. 2754 2755 In the case of value reflection, it's inverted about the mean value. 2756 2757 @param x: B{C{True}} to reflect about X axis (i.e., vertically). I{(bool)} 2758 @param y: B{C{True}} to reflect about Y axis (i.e., horizontally). I{(bool)} 2759 @param z: B{C{True}} to invert in Z direction (i.e., invert values). I{(bool)} 2760 @return: 2761 """ 2762 return None
2763 - def fill( value ):
2764 """ 2765 Fills a data field with given value. 2766 2767 @param value: Value to be entered. I{(float)} 2768 @return: 2769 """ 2770 return None
2771 - def clear( ):
2772 """ 2773 Fills a data field with zeroes. 2774 2775 @return: 2776 """ 2777 return None
2778 - def multiply( value ):
2779 """ 2780 Multiplies all values in a data field by given value. 2781 2782 @param value: Value to multiply B{C{data_field}} with. I{(float)} 2783 @return: 2784 """ 2785 return None
2786 - def add( value ):
2787 """ 2788 Adds given value to all values in a data field. 2789 2790 @param value: Value to be added to data field values. I{(float)} 2791 @return: 2792 """ 2793 return None
2794 - def area_fill( col , row , width , height , value ):
2795 """ 2796 Fills a rectangular part of a data field with given value. 2797 2798 @param col: Upper-left column coordinate. I{(int)} 2799 @param row: Upper-left row coordinate. I{(int)} 2800 @param width: Area width (number of columns). I{(int)} 2801 @param height: Area height (number of rows). I{(int)} 2802 @param value: Value to be entered I{(float)} 2803 @return: 2804 """ 2805 return None
2806 - def area_clear( col , row , width , height ):
2807 """ 2808 Fills a rectangular part of a data field with zeroes. 2809 2810 @param col: Upper-left column coordinate. I{(int)} 2811 @param row: Upper-left row coordinate. I{(int)} 2812 @param width: Area width (number of columns). I{(int)} 2813 @param height: Area height (number of rows). I{(int)} 2814 @return: 2815 """ 2816 return None
2817 - def area_multiply( col , row , width , height , value ):
2818 """ 2819 Multiplies values in a rectangular part of a data field by given value 2820 2821 @param col: Upper-left column coordinate. I{(int)} 2822 @param row: Upper-left row coordinate. I{(int)} 2823 @param width: Area width (number of columns). I{(int)} 2824 @param height: Area height (number of rows). I{(int)} 2825 @param value: Value to multiply area with. I{(float)} 2826 @return: 2827 """ 2828 return None
2829 - def area_add( col , row , width , height , value ):
2830 """ 2831 Adds given value to all values in a rectangular part of a data field. 2832 2833 @param col: Upper-left column coordinate. I{(int)} 2834 @param row: Upper-left row coordinate. I{(int)} 2835 @param width: Area width (number of columns). I{(int)} 2836 @param height: Area height (number of rows). I{(int)} 2837 @param value: Value to be added to area values. I{(float)} 2838 @return: 2839 """ 2840 return None
2841 - def get_profile( data_line , scol , srow , ecol , erow , res , thickness , interpolation ):
2842 """ 2843 Extracts a possibly averaged profile from data field to a data line. 2844 2845 2846 @param data_line: A data line. It will be resized to B{C{res}} samples. It is 2847 possible to pass B{C{NULL}} to instantiate and return a new 2848 B{C{DataLine}}. I{(L{DataLine})} 2849 @param scol: The column the line starts at (inclusive). I{(int)} 2850 @param srow: The row the line starts at (inclusive). I{(int)} 2851 @param ecol: The column the line ends at (inclusive). I{(int)} 2852 @param erow: The row the line ends at (inclusive). I{(int)} 2853 @param res: Requested resolution of data line (the number of samples to take). 2854 If nonpositive, data line resolution is chosen to match B{C{data_field}}'s. I{(int)} 2855 @param thickness: Thickness of line to be averaged. I{(int)} 2856 @param interpolation: Interpolation type to use. I{(InterpolationType)} 2857 @return: B{C{data_line}} itself if it was not B{C{NULL}}, otherwise a newly created 2858 data line. 2859 2860 """ 2861 return None
2862 - def get_row( data_line , row ):
2863 """ 2864 Extracts a data field row into a data line. 2865 2866 @param data_line: A data line. It will be resized to width ot B{C{data_field}}. I{(L{DataLine})} 2867 @param row: Row index. I{(int)} 2868 @return: 2869 """ 2870 return None
2871 - def get_column( data_line , col ):
2872 """ 2873 Extracts a data field column into a data line. 2874 2875 @param data_line: A data line. It will be resized to height of B{C{data_field}}. I{(L{DataLine})} 2876 @param col: Column index. I{(int)} 2877 @return: 2878 """ 2879 return None
2880 - def set_row( data_line , row ):
2881 """ 2882 Sets a row in the data field to values of a data line. 2883 2884 Data line length must be equal to width of data field. 2885 2886 @param data_line: A data line. I{(L{DataLine})} 2887 @param row: Row index. I{(int)} 2888 @return: 2889 """ 2890 return None
2891 - def set_column( data_line , col ):
2892 """ 2893 Sets a column in the data field to values of a data line. 2894 2895 Data line length must be equal to height of data field. 2896 2897 @param data_line: A data line. I{(L{DataLine})} 2898 @param col: Column index. I{(int)} 2899 @return: 2900 """ 2901 return None
2902 - def get_row_part( data_line , row , _from , to ):
2903 """ 2904 Extracts part of a data field row into a data line. 2905 2906 @param data_line: A data line. It will be resized to the row part width. I{(L{DataLine})} 2907 @param row: Row index. I{(int)} 2908 @param _from: Start column index. I{(int)} 2909 @param to: End column index + 1. I{(int)} 2910 @return: 2911 """ 2912 return None
2913 - def get_column_part( data_line , col , _from , to ):
2914 """ 2915 Extracts part of a data field column into a data line. 2916 2917 @param data_line: A data line. It will be resized to the column part height. I{(L{DataLine})} 2918 @param col: Column index. I{(int)} 2919 @param _from: Start row index. I{(int)} 2920 @param to: End row index + 1. I{(int)} 2921 @return: 2922 """ 2923 return None
2924 - def set_row_part( data_line , row , _from , to ):
2925 """ 2926 Puts a data line into a data field row. 2927 2928 If data line length differs from B{C{to}}-B{C{from}}, it is resampled to this length. 2929 2930 @param data_line: A data line. I{(L{DataLine})} 2931 @param row: Row index. I{(int)} 2932 @param _from: Start row index. I{(int)} 2933 @param to: End row index + 1. I{(int)} 2934 @return: 2935 """ 2936 return None
2937 - def set_column_part( data_line , col , _from , to ):
2938 """ 2939 Puts a data line into data field column. 2940 2941 If data line length differs from B{C{to}}-B{C{from}}, it is resampled to this length. 2942 2943 @param data_line: A data line. I{(L{DataLine})} 2944 @param col: Column index. I{(int)} 2945 @param _from: Start row index. I{(int)} 2946 @param to: End row index + 1. I{(int)} 2947 @return: 2948 """ 2949 return None
2950 - def get_xder( col , row ):
2951 """ 2952 Computes central derivative in X direction. 2953 2954 On border points, one-side derivative is returned. 2955 2956 2957 @param col: Column index. I{(int)} 2958 @param row: Row index. I{(int)} 2959 @return: Derivative in X direction. 2960 2961 """ 2962 return None
2963 - def get_yder( col , row ):
2964 """ 2965 Computes central derivative in Y direction. 2966 2967 On border points, one-side derivative is returned. 2968 2969 Note the derivative is for legacy reasons calulcated for the opposite 2970 y direction than is usual elsewhere in Gwyddion, i.e. if values increase 2971 with increasing row number, the returned value is negative. 2972 2973 2974 @param col: Column index. I{(int)} 2975 @param row: Row index. I{(int)} 2976 @return: Derivative in Y direction 2977 2978 """ 2979 return None
2980 - def get_angder( col , row , theta ):
2981 """ 2982 Computes derivative in direction specified by given angle. 2983 2984 2985 @param col: Column index. I{(int)} 2986 @param row: Row index. I{(int)} 2987 @param theta: Angle defining the direction (in radians, counterclockwise). I{(float)} 2988 @return: Derivative in direction given by angle B{C{theta}}. 2989 2990 """ 2991 return None
2992 - def xdwt( wt_coefs , direction , minsize ):
2993 """ 2994 Performs steps of the X-direction image wavelet decomposition. 2995 2996 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 2997 B{C{minsize}} = B{C{dfield}}->xres/2 to perform one step of decomposition 2998 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 2999 3000 3001 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 3002 @param direction: Transform direction. I{(TransformDirection)} 3003 @param minsize: size of minimal transform result block I{(int)} 3004 @return: 3005 """ 3006 return None
3007 - def ydwt( wt_coefs , direction , minsize ):
3008 """ 3009 Performs steps of the Y-direction image wavelet decomposition. 3010 3011 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 3012 B{C{minsize}} = B{C{dfield}}->yres/2 to perform one step of decomposition 3013 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 3014 3015 3016 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 3017 @param direction: Transform direction. I{(TransformDirection)} 3018 @param minsize: size of minimal transform result block I{(int)} 3019 @return: 3020 """ 3021 return None
3022 - def dwt( wt_coefs , direction , minsize ):
3023 """ 3024 Performs steps of the 2D image wavelet decomposition. 3025 3026 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 3027 B{C{minsize}} = B{C{dfield}}->xres/2 to perform one step of decomposition 3028 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 3029 3030 3031 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 3032 @param direction: Transform direction. I{(TransformDirection)} 3033 @param minsize: size of minimal transform result block I{(int)} 3034 @return: 3035 """ 3036 return None
3037 - def dwt_mark_anisotropy( mask , wt_coefs , ratio , lowlimit ):
3038 return None
3039 - def elliptic_area_fill( col , row , width , height , value ):
3040 """ 3041 Fills an elliptic region of a data field with given value. 3042 3043 The elliptic region is defined by its bounding box which must be completely 3044 contained in the data field. 3045 3046 3047 @param col: Upper-left bounding box column coordinate. I{(int)} 3048 @param row: Upper-left bounding box row coordinate. I{(int)} 3049 @param width: Bounding box width (number of columns). I{(int)} 3050 @param height: Bounding box height (number of rows). I{(int)} 3051 @param value: Value to be entered. I{(float)} 3052 @return: The number of filled values. 3053 3054 """ 3055 return None
3056 - def elliptic_area_extract( col , row , width , height , data ):
3057 """ 3058 Extracts values from an elliptic region of a data field. 3059 3060 The elliptic region is defined by its bounding box which must be completely 3061 contained in the data field. 3062 3063 3064 @param col: Upper-left bounding box column coordinate. I{(int)} 3065 @param row: Upper-left bounding box row coordinate. I{(int)} 3066 @param width: Bounding box width (number of columns). I{(int)} 3067 @param height: Bounding box height (number of rows). I{(int)} 3068 @param data: Location to store the extracted values to. Its size has to be 3069 sufficient to contain all the extracted values. As a conservative 3070 estimate B{C{width}}*B{C{height}} can be used, or the 3071 size can be calculated with L{DataField.get_elliptic_area_size}(). I{(gdouble*)} 3072 @return: The number of extracted values. 3073 3074 """ 3075 return None
3076 - def elliptic_area_unextract( col , row , width , height , data ):
3077 """ 3078 Puts values back to an elliptic region of a data field. 3079 3080 The elliptic region is defined by its bounding box which must be completely 3081 contained in the data field. 3082 3083 This method does the reverse of L{DataField.elliptic_area_extract}() 3084 allowing to implement pixel-wise filters on elliptic areas. Values from 3085 B{C{data}} are put back to the same positions 3086 L{DataField.elliptic_area_extract}() took them from. 3087 3088 @param col: Upper-left bounding box column coordinate. I{(int)} 3089 @param row: Upper-left bounding box row coordinate. I{(int)} 3090 @param width: Bounding box width (number of columns). I{(int)} 3091 @param height: Bounding box height (number of rows). I{(int)} 3092 @param data: The values to put back. It must be the same array as in previous 3093 L{DataField.elliptic_area_extract}(). I{(const-gdouble*)} 3094 @return: 3095 """ 3096 return None
3097 - def circular_area_fill( col , row , radius , value ):
3098 """ 3099 Fills an elliptic region of a data field with given value. 3100 3101 3102 @param col: Row index of circular area centre. I{(int)} 3103 @param row: Column index of circular area centre. I{(int)} 3104 @param radius: Circular area radius (in pixels). Any value is allowed, although 3105 to get areas that do not deviate from true circles after 3106 pixelization too much, half-integer values are recommended, 3107 integer values are NOT recommended. I{(float)} 3108 @param value: Value to be entered. I{(float)} 3109 @return: The number of filled values. 3110 3111 """ 3112 return None
3113 - def circular_area_extract( col , row , radius , data ):
3114 """ 3115 Extracts values from a circular region of a data field. 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). See 3121 L{DataField.circular_area_extract_with_pos}() for caveats. I{(float)} 3122 @param data: Location to store the extracted values to. See 3123 L{DataField.circular_area_extract_with_pos}(). I{(gdouble*)} 3124 @return: The number of extracted values. It can be zero when the inside of 3125 the circle does not intersect with the data field. 3126 3127 """ 3128 return None
3129 - def UNIMPLEMENTED_circular_area_extract_with_pos( col , row , radius , data , xpos , ypos ):
3130 """ 3131 Extracts values with positions from a circular region of a data field. 3132 3133 The row and column indices stored to B{C{xpos}} and B{C{ypos}} are relative to the 3134 area centre, i.e. to (B{C{col}}, B{C{row}}). The central pixel will therefore have 3135 0 at the corresponding position in both B{C{xpos}} and B{C{ypos}}. 3136 3137 Since: 2.2 3138 3139 @param col: Row index of circular area centre. I{(int)} 3140 @param row: Column index of circular area centre. I{(int)} 3141 @param radius: Circular area radius (in pixels). Any value is allowed, although 3142 to get areas that do not deviate from true circles after 3143 pixelization too much, half-integer values are recommended, 3144 integer radii are NOT recommended. I{(float)} 3145 @param data: Location to store the extracted values to. Its size has to be 3146 sufficient to contain all the extracted values. As a conservative 3147 estimate (2*floor(B{C{radius}})+1)^2 can be used, or the size can be 3148 calculated with L{DataField.get_circular_area_size}(). I{(gdouble*)} 3149 @param xpos: Location to store relative column indices of values in B{C{data}} to, 3150 the size requirements are the same as for B{C{data}}. I{(int)} 3151 @param ypos: Location to store relative tow indices of values in B{C{data}} to, 3152 the size requirements are the same as for B{C{data}}. I{(int)} 3153 @return: The number of extracted values. It can be zero when the inside of 3154 the circle does not intersect with the data field. 3155 3156 3157 """ 3158 return None
3159 - def circular_area_unextract( col , row , radius , data ):
3160 """ 3161 Puts values back to a circular region of a data field. 3162 3163 This method does the reverse of L{DataField.circular_area_extract}() 3164 allowing to implement pixel-wise filters on circular areas. Values from 3165 B{C{data}} are put back to the same positions 3166 L{DataField.circular_area_extract}() took them from. 3167 3168 @param col: Row index of circular area centre. I{(int)} 3169 @param row: Column index of circular area centre. I{(int)} 3170 @param radius: Circular area radius (in pixels). I{(float)} 3171 @param data: The values to put back. It must be the same array as in previous 3172 L{DataField.circular_area_unextract}(). I{(const-gdouble*)} 3173 @return: 3174 """ 3175 return None
3176 - def normalize( ):
3177 """ 3178 Normalizes data in a data field to range 0.0 to 1.0. 3179 3180 It is equivalent to L{DataField.renormalize}(B{C{data_field}}, 1.0, 0.0); 3181 3182 If B{C{data_field}} is filled with only one value, it is changed to 0.0. 3183 3184 @return: 3185 """ 3186 return None
3187 - def renormalize( range , offset ):
3188 """ 3189 Transforms data in a data field with first linear function to given range. 3190 3191 When B{C{range}} is positive, the new data range is (B{C{offset}}, B{C{offset}}+B{C{range}}); 3192 when B{C{range}} is negative, the new data range is (B{C{offset}}-B{C{range}}, B{C{offset}}). 3193 In neither case the data are flipped, negative range only means different 3194 selection of boundaries. 3195 3196 When B{C{range}} is zero, this method is equivalent to 3197 L{DataField.fill}(B{C{data_field}}, B{C{offset}}). 3198 3199 @param range: New data interval size. I{(float)} 3200 @param offset: New data interval offset. I{(float)} 3201 @return: 3202 """ 3203 return None
3204 - def threshold( threshval , bottom , top ):
3205 """ 3206 Tresholds values of a data field. 3207 3208 Values smaller than B{C{threshold}} are set to value B{C{bottom}}, values higher 3209 than B{C{threshold}} or equal to it are set to value B{C{top}} 3210 3211 3212 @param threshval: Threshold value. I{(float)} 3213 @param bottom: Lower replacement value. I{(float)} 3214 @param top: Upper replacement value. I{(float)} 3215 @return: The total number of values above threshold. 3216 3217 """ 3218 return None
3219 - def area_threshold( col , row , width , height , threshval , bottom , top ):
3220 """ 3221 Tresholds values of a rectangular part of a data field. 3222 3223 Values smaller than B{C{threshold}} are set to value B{C{bottom}}, values higher 3224 than B{C{threshold}} or equal to it are set to value B{C{top}} 3225 3226 3227 @param col: Upper-left column coordinate. I{(int)} 3228 @param row: Upper-left row coordinate. I{(int)} 3229 @param width: Area width (number of columns). I{(int)} 3230 @param height: Area height (number of rows). I{(int)} 3231 @param threshval: Threshold value. I{(float)} 3232 @param bottom: Lower replacement value. I{(float)} 3233 @param top: Upper replacement value. I{(float)} 3234 @return: The total number of values above threshold. 3235 3236 """ 3237 return None
3238 - def clamp( bottom , top ):
3239 """ 3240 Limits data field values to a range. 3241 3242 3243 @param bottom: Lower limit value. I{(float)} 3244 @param top: Upper limit value. I{(float)} 3245 @return: The number of changed values, i.e., values that were outside 3246 [B{C{bottom}}, B{C{top}}]. 3247 3248 """ 3249 return None
3250 - def area_clamp( col , row , width , height , bottom , top ):
3251 """ 3252 Limits values in a rectangular part of a data field to a range. 3253 3254 3255 @param col: Upper-left column coordinate. I{(int)} 3256 @param row: Upper-left row coordinate. I{(int)} 3257 @param width: Area width (number of columns). I{(int)} 3258 @param height: Area height (number of rows). I{(int)} 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_gather( result , buffer , hsize , vsize , average , col , row , width , height ):
3267 """ 3268 Sums or averages values in reactangular areas around each sample in a data 3269 field. 3270 3271 When the gathered area extends out of calculation area, only samples from 3272 their intersection are taken into the local sum (or average). 3273 3274 There are no restrictions on values of B{C{hsize}} and B{C{vsize}} with regard to 3275 B{C{width}} and B{C{height}}, but they have to be positive. 3276 3277 The result is calculated by the means of two-dimensional rolling sums. 3278 One one hand it means the calculation time depends linearly on 3279 (B{C{width}} + B{C{hsize}})*(B{C{height}} + B{C{vsize}}) instead of 3280 B{C{width}}*B{C{hsize}}*B{C{height}}*B{C{vsize}}. On the other hand it means absolute rounding 3281 errors of all output values are given by the largest input values, that is 3282 relative precision of results small in absolute value may be poor. 3283 3284 @param result: A data field to put the result to, it may be B{C{data_field}} itself. I{(L{DataField})} 3285 @param buffer: A data field to use as a scratch area, its size must be at least 3286 B{C{width}}*B{C{height}}. May be B{C{NULL}} to allocate a private temporary 3287 buffer. I{(L{DataField})} 3288 @param col: Upper-left column coordinate. I{(int)} 3289 @param row: Upper-left row coordinate. I{(int)} 3290 @param width: Area width (number of columns). I{(int)} 3291 @param height: Area height (number of rows). I{(int)} 3292 @param hsize: Horizontal size of gathered area. The area is centered around 3293 each sample if B{C{hsize}} is odd, it extends one pixel more to the 3294 right if B{C{hsize}} is even. I{(int)} 3295 @param vsize: Vertical size of gathered area. The area is centered around 3296 each sample if B{C{vsize}} is odd, it extends one pixel more down 3297 if B{C{vsize}} is even. I{(int)} 3298 @param average: B{C{True}} to divide resulting sums by the number of involved samples 3299 to get averages instead of sums. I{(bool)} 3300 @return: 3301 """ 3302 return None
3303 - def convolve( kernel_field ):
3304 """ 3305 Convolves a data field with given kernel. 3306 3307 @param kernel_field: Kenrel field to convolve B{C{data_field}} with. I{(L{DataField})} 3308 @return: 3309 """ 3310 return None
3311 - def area_convolve( kernel_field , col , row , width , height ):
3312 """ 3313 Convolves a rectangular part of a data field with given kernel. 3314 3315 @param kernel_field: Kenrel field to convolve B{C{data_field}} with. I{(L{DataField})} 3316 @param col: Upper-left column coordinate. I{(int)} 3317 @param row: Upper-left row coordinate. I{(int)} 3318 @param width: Area width (number of columns). I{(int)} 3319 @param height: Area height (number of rows). I{(int)} 3320 @return: 3321 """ 3322 return None
3323 - def convolve_1d( kernel_line , orientation ):
3324 """ 3325 Convolves a data field with given linear kernel. 3326 3327 Since: 2.4 3328 3329 @param kernel_line: Kenrel line to convolve B{C{data_field}} with. I{(L{DataLine})} 3330 @param orientation: Filter orientation (see L{DataField.area_convolve_1d}()). I{(Orientation)} 3331 @return: 3332 """ 3333 return None
3334 - def area_convolve_1d( kernel_line , orientation , col , row , width , height ):
3335 """ 3336 Convolves a rectangular part of a data field with given linear kernel. 3337 3338 For large separable kernels it can be more efficient to use a sequence of 3339 horizontal and vertical convolutions instead one 2D convolution. 3340 3341 Since: 2.4 3342 3343 @param kernel_line: Kernel line to convolve B{C{data_field}} with. I{(L{DataLine})} 3344 @param orientation: Filter orientation (B{C{ORIENTATION_HORIZONTAL}} for 3345 row-wise convolution, B{C{ORIENTATION_VERTICAL}} for 3346 column-wise convolution). I{(Orientation)} 3347 @param col: Upper-left column coordinate. I{(int)} 3348 @param row: Upper-left row coordinate. I{(int)} 3349 @param width: Area width (number of columns). I{(int)} 3350 @param height: Area height (number of rows). I{(int)} 3351 @return: 3352 """ 3353 return None
3354 - def filter_median( size ):
3355 """ 3356 Filters a data field with median filter. 3357 3358 @param size: Size of area to take median of. I{(int)} 3359 @return: 3360 """ 3361 return None
3362 - def area_filter_median( size , col , row , width , height ):
3363 """ 3364 Filters a rectangular part of a data field with median filter. 3365 3366 @param size: Size of area to take median of. I{(int)} 3367 @param col: Upper-left column coordinate. I{(int)} 3368 @param row: Upper-left row coordinate. I{(int)} 3369 @param width: Area width (number of columns). I{(int)} 3370 @param height: Area height (number of rows). I{(int)} 3371 @return: 3372 """ 3373 return None
3374 - def filter_mean( size ):
3375 """ 3376 Filters a data field with mean filter of size B{C{size}}. 3377 3378 @param size: Averaged area size. I{(int)} 3379 @return: 3380 """ 3381 return None
3382 - def area_filter_mean( size , col , row , width , height ):
3383 """ 3384 Filters a rectangular part of a data field with mean filter of size B{C{size}}. 3385 3386 This method is a simple L{DataField.area_gather}() wrapper. 3387 3388 @param size: Averaged area size. I{(int)} 3389 @param col: Upper-left column coordinate. I{(int)} 3390 @param row: Upper-left row coordinate. I{(int)} 3391 @param width: Area width (number of columns). I{(int)} 3392 @param height: Area height (number of rows). I{(int)} 3393 @return: 3394 """ 3395 return None
3396 - def filter_conservative( size ):
3397 """ 3398 Filters a data field with conservative denoise filter. 3399 3400 @param size: Filtered area size. I{(int)} 3401 @return: 3402 """ 3403 return None
3404 - def area_filter_conservative( size , col , row , width , height ):
3405 """ 3406 Filters a rectangular part of a data field with conservative denoise filter. 3407 3408 @param size: Filtered area size. I{(int)} 3409 @param col: Upper-left column coordinate. I{(int)} 3410 @param row: Upper-left row coordinate. I{(int)} 3411 @param width: Area width (number of columns). I{(int)} 3412 @param height: Area height (number of rows). I{(int)} 3413 @return: 3414 """ 3415 return None
3416 - def filter_laplacian( ):
3417 """ 3418 Filters a data field with Laplacian filter. 3419 3420 @return: 3421 """ 3422 return None
3423 - def area_filter_laplacian( col , row , width , height ):
3424 """ 3425 Filters a rectangular part of a data field with Laplacian filter. 3426 3427 @param col: Upper-left column coordinate. I{(int)} 3428 @param row: Upper-left row coordinate. I{(int)} 3429 @param width: Area width (number of columns). I{(int)} 3430 @param height: Area height (number of rows). I{(int)} 3431 @return: 3432 """ 3433 return None
3435 """ 3436 Filters a data field with Laplacian of Gaussians filter. 3437 3438 Since: 2.23 3439 3440 @return: 3441 """ 3442 return None
3443 - def area_filter_laplacian_of_gaussians( col , row , width , height ):
3444 """ 3445 Filters a rectangular part of a data field 3446 with Laplacian of Gaussians filter. 3447 3448 Since: 2.23 3449 3450 @param col: Upper-left column coordinate. I{(int)} 3451 @param row: Upper-left row coordinate. I{(int)} 3452 @param width: Area width (number of columns). I{(int)} 3453 @param height: Area height (number of rows). I{(int)} 3454 @return: 3455 """ 3456 return None
3457 - def filter_sobel( orientation ):
3458 """ 3459 Filters a data field with a directional Sobel filter. 3460 3461 @param orientation: Filter orientation. I{(Orientation)} 3462 @return: 3463 """ 3464 return None
3465 - def area_filter_sobel( orientation , col , row , width , height ):
3466 """ 3467 Filters a rectangular part of a data field with a directional Sobel filter. 3468 3469 @param orientation: Filter orientation. I{(Orientation)} 3470 @param col: Upper-left column coordinate. I{(int)} 3471 @param row: Upper-left row coordinate. I{(int)} 3472 @param width: Area width (number of columns). I{(int)} 3473 @param height: Area height (number of rows). I{(int)} 3474 @return: 3475 """ 3476 return None
3477 - def filter_sobel_total( ):
3478 """ 3479 Filters a data field with total Sobel filter. 3480 3481 Since: 2.31 3482 3483 @return: 3484 """ 3485 return None
3486 - def filter_prewitt( orientation ):
3487 """ 3488 Filters a data field with Prewitt filter. 3489 3490 @param orientation: Filter orientation. I{(Orientation)} 3491 @return: 3492 """ 3493 return None
3494 - def area_filter_prewitt( orientation , col , row , width , height ):
3495 """ 3496 Filters a rectangular part of a data field with a directional Prewitt 3497 filter. 3498 3499 @param orientation: Filter orientation. I{(Orientation)} 3500 @param col: Upper-left column coordinate. I{(int)} 3501 @param row: Upper-left row coordinate. I{(int)} 3502 @param width: Area width (number of columns). I{(int)} 3503 @param height: Area height (number of rows). I{(int)} 3504 @return: 3505 """ 3506 return None
3507 - def filter_prewitt_total( ):
3508 """ 3509 Filters a data field with total Prewitt filter. 3510 3511 Since: 2.31 3512 3513 @return: 3514 """ 3515 return None
3516 - def filter_slope( xder , yder ):
3517 """ 3518 Calculates x and y derivaties for an entire field. 3519 3520 The derivatives are calculated as the simple symmetrical differences (in 3521 physical units, not pixel-wise), except at the edges where the differences 3522 are one-sided. 3523 3524 Since: 2.37 3525 3526 @param xder: Data field where the x-derivarive is to be stored, or B{C{NULL}} if you 3527 are only interested in the y-derivarive. I{(L{DataField})} 3528 @param yder: Data field where the y-derivarive is to be stored, or B{C{NULL}} if you 3529 are only interested in the x-derivarive. I{(L{DataField})} 3530 @return: 3531 """ 3532 return None
3533 - def filter_dechecker( ):
3534 """ 3535 Filters a data field with 5x5 checker pattern removal filter. 3536 3537 Since: 2.1 3538 3539 @return: 3540 """ 3541 return None
3542 - def area_filter_dechecker( col , row , width , height ):
3543 """ 3544 Filters a rectangular part of a data field with 5x5 checker pattern removal 3545 filter. 3546 3547 Since: 2.1 3548 3549 @param col: Upper-left column coordinate. I{(int)} 3550 @param row: Upper-left row coordinate. I{(int)} 3551 @param width: Area width (number of columns). I{(int)} 3552 @param height: Area height (number of rows). I{(int)} 3553 @return: 3554 """ 3555 return None
3556 - def filter_gaussian( sigma ):
3557 """ 3558 Filters a data field with a Gaussian filter. 3559 3560 Since: 2.4 3561 3562 @param sigma: The sigma parameter of the Gaussian. I{(float)} 3563 @return: 3564 """ 3565 return None
3566 - def area_filter_gaussian( sigma , col , row , width , height ):
3567 """ 3568 Filters a rectangular part of a data field with a Gaussian filter. 3569 3570 The Gausian is normalized, i.e. it is sum-preserving. 3571 3572 Since: 2.4 3573 3574 @param sigma: The sigma parameter of the Gaussian. I{(float)} 3575 @param col: Upper-left column coordinate. I{(int)} 3576 @param row: Upper-left row coordinate. I{(int)} 3577 @param width: Area width (number of columns). I{(int)} 3578 @param height: Area height (number of rows). I{(int)} 3579 @return: 3580 """ 3581 return None
3582 - def filter_minimum( size ):
3583 """ 3584 Filters a data field with minimum filter. 3585 3586 @param size: Neighbourhood size for minimum search. I{(int)} 3587 @return: 3588 """ 3589 return None
3590 - def area_filter_minimum( size , col , row , width , height ):
3591 """ 3592 Filters a rectangular part of a data field with minimum filter. 3593 3594 This operation is often called erosion filter. 3595 3596 @param size: Neighbourhood size for minimum search. I{(int)} 3597 @param col: Upper-left column coordinate. I{(int)} 3598 @param row: Upper-left row coordinate. I{(int)} 3599 @param width: Area width (number of columns). I{(int)} 3600 @param height: Area height (number of rows). I{(int)} 3601 @return: 3602 """ 3603 return None
3604 - def filter_maximum( size ):
3605 """ 3606 Filters a data field with maximum filter. 3607 3608 @param size: Neighbourhood size for maximum search. I{(int)} 3609 @return: 3610 """ 3611 return None
3612 - def area_filter_maximum( size , col , row , width , height ):
3613 """ 3614 Filters a rectangular part of a data field with maximum filter. 3615 3616 This operation is often called dilation filter. 3617 3618 @param size: Neighbourhood size for maximum search. I{(int)} 3619 @param col: Upper-left column coordinate. I{(int)} 3620 @param row: Upper-left row coordinate. I{(int)} 3621 @param width: Area width (number of columns). I{(int)} 3622 @param height: Area height (number of rows). I{(int)} 3623 @return: 3624 """ 3625 return None
3626 - def filter_rms( size ):
3627 """ 3628 Filters a data field with RMS filter. 3629 3630 @param size: Area size. I{(int)} 3631 @return: 3632 """ 3633 return None
3634 - def area_filter_rms( size , col , row , width , height ):
3635 """ 3636 Filters a rectangular part of a data field with RMS filter of size B{C{size}}. 3637 3638 RMS filter computes root mean square in given area. 3639 3640 @param size: Area size. I{(int)} 3641 @param col: Upper-left column coordinate. I{(int)} 3642 @param row: Upper-left row coordinate. I{(int)} 3643 @param width: Area width (number of columns). I{(int)} 3644 @param height: Area height (number of rows). I{(int)} 3645 @return: 3646 """ 3647 return None
3648 - def filter_kuwahara( ):
3649 """ 3650 Filters a data field with Kuwahara filter. 3651 3652 @return: 3653 """ 3654 return None
3655 - def area_filter_kuwahara( col , row , width , height ):
3656 """ 3657 Filters a rectangular part of a data field with a Kuwahara 3658 (edge-preserving smoothing) filter. 3659 3660 @param col: Upper-left column coordinate. I{(int)} 3661 @param row: Upper-left row coordinate. I{(int)} 3662 @param width: Area width (number of columns). I{(int)} 3663 @param height: Area height (number of rows). I{(int)} 3664 @return: 3665 """ 3666 return None
3667 - def filter_canny( threshold ):
3668 """ 3669 Filters a rectangular part of a data field with canny edge detector filter. 3670 3671 @param threshold: Slope detection threshold (range 0..1). I{(float)} 3672 @return: 3673 """ 3674 return None
3675 - def shade( target_field , theta , phi ):
3676 """ 3677 Shades a data field. 3678 3679 @param target_field: A data field to put the shade to. It will be resized to 3680 match B{C{data_field}}. I{(L{DataField})} 3681 @param theta: Shading angle (in radians, from north pole). I{(float)} 3682 @param phi: Shade orientation in xy plane (in radians, counterclockwise). I{(float)} 3683 @return: 3684 """ 3685 return None
3686 - def filter_harris( y_gradient , result , neighbourhood , alpha ):
3687 return None
3688 - def fractal_partitioning( xresult , yresult , interpolation ):
3689 """ 3690 Computes data for log-log plot by partitioning. 3691 3692 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3693 they will contain corresponding values at each position. 3694 3695 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3696 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3697 @param interpolation: Interpolation type. I{(InterpolationType)} 3698 @return: 3699 """ 3700 return None
3701 - def fractal_cubecounting( xresult , yresult , interpolation ):
3702 """ 3703 Computes data for log-log plot by cube counting. 3704 3705 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3706 they will contain corresponding values at each position. 3707 3708 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3709 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3710 @param interpolation: Interpolation type. I{(InterpolationType)} 3711 @return: 3712 """ 3713 return None
3714 - def fractal_triangulation( xresult , yresult , interpolation ):
3715 """ 3716 Computes data for log-log plot by triangulation. 3717 3718 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3719 they will contain corresponding values at each position. 3720 3721 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3722 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3723 @param interpolation: Interpolation type. I{(InterpolationType)} 3724 @return: 3725 """ 3726 return None
3727 - def fractal_psdf( xresult , yresult , interpolation ):
3728 """ 3729 Computes data for log-log plot by spectral density method. 3730 3731 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3732 they will contain corresponding values at each position. 3733 3734 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3735 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3736 @param interpolation: Interpolation type. I{(InterpolationType)} 3737 @return: 3738 """ 3739 return None
3740 - def fractal_correction( mask_field , interpolation ):
3741 """ 3742 Replaces data under mask with interpolated values using fractal 3743 interpolation. 3744 3745 @param mask_field: Mask of places to be corrected. I{(L{DataField})} 3746 @param interpolation: Interpolation type. I{(InterpolationType)} 3747 @return: 3748 """ 3749 return None
3750 - def grains_mark_curvature( grain_field , threshval , below ):
3751 """ 3752 Marks data that are above/below curvature threshold. 3753 3754 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 3755 @param threshval: Relative curvature threshold, in percents. I{(float)} 3756 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 3757 threshold are marked. I{(bool)} 3758 @return: 3759 """ 3760 return None
3761 - def grains_mark_watershed( grain_field , locate_steps , locate_thresh , locate_dropsize , wshed_steps , wshed_dropsize , prefilter , below ):
3762 """ 3763 Performs watershed algorithm. 3764 3765 @param grain_field: Result of marking (mask). I{(L{DataField})} 3766 @param locate_steps: Locating algorithm steps. I{(int)} 3767 @param locate_thresh: Locating algorithm threshold. I{(int)} 3768 @param locate_dropsize: Locating drop size. I{(float)} 3769 @param wshed_steps: Watershed steps. I{(int)} 3770 @param wshed_dropsize: Watershed drop size. I{(float)} 3771 @param prefilter: Use prefiltering. I{(bool)} 3772 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 3773 @return: 3774 """ 3775 return None
3776 - def grains_remove_grain( col , row ):
3777 """ 3778 Removes one grain at given position. 3779 3780 3781 @param col: Column inside a grain. I{(int)} 3782 @param row: Row inside a grain. I{(int)} 3783 @return: B{C{True}} if a grain was actually removed (i.e., (B{C{col}},B{C{row}}) was 3784 inside a grain). 3785 3786 """ 3787 return None
3788 - def grains_extract_grain( col , row ):
3789 """ 3790 Removes all grains except that one at given position. 3791 3792 If there is no grain at (B{C{col}}, B{C{row}}), all grains are removed. 3793 3794 3795 @param col: Column inside a grain. I{(int)} 3796 @param row: Row inside a grain. I{(int)} 3797 @return: B{C{True}} if a grain remained (i.e., (B{C{col}},B{C{row}}) was inside a grain). 3798 3799 """ 3800 return None
3801 - def grains_remove_by_number( number ):
3802 """ 3803 Removes grain identified by B{C{number}}. 3804 3805 Since: 2.35 3806 3807 @param number: Grain number was filled by L{DataField.number_grains}(). I{(int)} 3808 @return: 3809 """ 3810 return None
3811 - def grains_remove_by_size( size ):
3812 """ 3813 Removes all grains below specified area. 3814 3815 @param size: Grain area threshold, in square pixels. I{(int)} 3816 @return: 3817 """ 3818 return None
3819 - def grains_remove_by_height( grain_field , threshval , below ):
3820 """ 3821 Removes grains that are higher/lower than given threshold value. 3822 3823 @param grain_field: Field of marked grains (mask) I{(L{DataField})} 3824 @param threshval: Relative height threshold, in percents. I{(float)} 3825 @param below: If B{C{True}}, grains below threshold are removed, otherwise grains above 3826 threshold are removed. I{(bool)} 3827 @return: 3828 """ 3829 return None
3831 """ 3832 Removes all grains that touch field borders. 3833 3834 Since: 2.30 3835 3836 @return: 3837 """ 3838 return None
3839 - def UNIMPLEMENTED_grains_watershed_init( grain_field , locate_steps , locate_thresh , locate_dropsize , wshed_steps , wshed_dropsize , prefilter , below ):
3840 """ 3841 Initializes the watershed algorithm. 3842 3843 This iterator reports its state as B{C{WatershedStateType}}. 3844 3845 3846 @param grain_field: Result of marking (mask). I{(L{DataField})} 3847 @param locate_steps: Locating algorithm steps. I{(int)} 3848 @param locate_thresh: Locating algorithm threshold. I{(int)} 3849 @param locate_dropsize: Locating drop size. I{(float)} 3850 @param wshed_steps: Watershed steps. I{(int)} 3851 @param wshed_dropsize: Watershed drop size. I{(float)} 3852 @param prefilter: Use prefiltering. I{(bool)} 3853 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 3854 @return: A new watershed iterator. 3855 3856 """ 3857 return None
3858 - def grains_mark_height( grain_field , threshval , below ):
3859 """ 3860 Marks data that are above/below height threshold. 3861 3862 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 3863 @param threshval: Relative height threshold, in percents. I{(float)} 3864 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 3865 threshold are marked. I{(bool)} 3866 @return: 3867 """ 3868 return None
3869 - def grains_mark_slope( grain_field , threshval , below ):
3870 """ 3871 Marks data that are above/below slope threshold. 3872 3873 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 3874 @param threshval: Relative slope threshold, in percents. I{(float)} 3875 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 3876 threshold are marked. I{(bool)} 3877 @return: 3878 """ 3879 return None
3880 - def otsu_threshold( ):
3881 """ 3882 Finds Otsu's height threshold for a data field. 3883 3884 The Otsu's threshold is optimal in the sense that it minimises the 3885 inter-class variances of two classes of pixels: above and below theshold. 3886 3887 Since: 2.37 3888 3889 @return: 3890 """ 3891 return None
3892 - def grains_add( add_field ):
3893 """ 3894 Adds B{C{add_field}} grains to B{C{grain_field}}. 3895 3896 Note: This function is equivalent to 3897 <literal>L{DataField.max_of_fields}(grain_field, grain_field, add_field);</literal> 3898 and it will be probably removed someday. 3899 3900 @param add_field: Field of marked grains (mask) to be added. I{(L{DataField})} 3901 @return: 3902 """ 3903 return None
3904 - def grains_intersect( intersect_field ):
3905 """ 3906 Performs intersection betweet two grain fields, 3907 result is stored in B{C{grain_field}}. 3908 3909 Note: This function is equivalent to 3910 <literal>L{DataField.min_of_fields}(grain_field, grain_field, intersect_field);</literal> 3911 and it will be probably removed someday. 3912 3913 @param intersect_field: Field of marked grains (mask). I{(L{DataField})} 3914 @return: 3915 """ 3916 return None
3917 - def number_grains( grains ):
3918 """ 3919 Create a tuple of integer grain numbers in the data field representing a 3920 mask. 3921 3922 3923 @return: tuple of grain numbers for each piel 3924 3925 """ 3926 return None
3928 """ 3929 Numbers grains in a periodic mask data field. 3930 3931 This function differs from L{DataField.number_grains}() by the assumption 3932 of periodicity, i.e. grains can touch across the opposite field edges. 3933 3934 Since: 2.38 3935 3936 @param grains: Zero-filled array of integers of equal size to B{C{mask_field}} to put 3937 grain numbers to. Empty space will be left 0, pixels inside a 3938 grain will be set to grain number. Grains are numbered 3939 sequentially 1, 2, 3, ... I{(gint*)} 3940 @return: The number of last grain (note they are numbered from 1). 3941 3942 3943 """ 3944 return None
3945 - def UNIMPLEMENTED_get_grain_bounding_boxes( ngrains , grains , bboxes ):
3946 """ 3947 Find bounding boxes of all grains. 3948 3949 Since: 2.3 3950 3951 @param ngrains: The number of grains as returned by 3952 L{DataField.number_grains}(). I{(int)} 3953 @param grains: Grain numbers filled with L{DataField.number_grains}(). I{(const-gint*)} 3954 @param bboxes: Array of size at least 4*(B{C{ngrains}}+1) to fill with grain bounding 3955 boxes (as usual zero does not correspond to any grain, grains 3956 start from 1). The bounding boxes are stored as quadruples of 3957 indices: (xmin, ymin, width, height). It can be B{C{NULL}} to allocate 3958 a new array. I{(gint*)} 3959 @return: Either B{C{bboxes}} (if it was not B{C{NULL}}), or a newly allocated array 3960 of size 4(B{C{ngrains}} + 1). 3961 3962 3963 """ 3964 return None
3965 - def UNIMPLEMENTED_grains_get_distribution( grain_field , distribution , ngrains , grains , quantity , nstats ):
3966 """ 3967 Computes distribution of requested grain characteristics. 3968 3969 Puts number of grains vs. grain value data into B{C{distribution}}, units, scales 3970 and offsets of B{C{distribution}} are updated accordingly. 3971 3972 3973 @param grain_field: Data field (mask) of marked grains. Note if you pass 3974 non-B{C{NULL}} B{C{grains}} all grain information is taken from it and 3975 B{C{grain_field}} can be even B{C{NULL}} then. I{(L{DataField})} 3976 @param distribution: Data line to store grain distribution to. I{(L{DataLine})} 3977 @param grains: Grain numbers filled with L{DataField.number_grains}() if you 3978 have it, or B{C{NULL}} (the function then finds grain numbers itself 3979 which is not efficient for repeated use on the same grain field). I{(const-gint*)} 3980 @param ngrains: The number of grains as returned by 3981 L{DataField.number_grains}(). Ignored in B{C{grains}} is B{C{NULL}}. I{(int)} 3982 @param quantity: The quantity to calculate. I{(GrainQuantity)} 3983 @param nstats: The number of samples to take on the distribution function. If 3984 nonpositive, a suitable resolution is determined automatically. I{(int)} 3985 @return: A data line with the distribution: B{C{distribution}} itself if it was 3986 not B{C{NULL}}, otherwise a newly created B{C{DataLine}} caller must 3987 destroy. If there are no grains, B{C{NULL}} is returned and 3988 B{C{distribution}} is not changed. 3989 3990 """ 3991 return None
3992 - def grains_get_values( values , ngrains , grains , quantity ):
3993 """ 3994 Obtains values of one grain quantity for all grains. 3995 3996 The zeroth value corresponds to the empty space between grains and isn't 3997 meaningful in general. 3998 3999 4000 @param quantity: Grain quantity. I{(GrainQuantity)} 4001 @return: tuple of values of the grain quantity 4002 4003 """ 4004 return None
4005 - def UNIMPLEMENTED_grains_get_quantities( values , quantities , nquantities , ngrains , grains ):
4006 """ 4007 Calculates multiple characteristics of grains simultaneously. 4008 4009 See L{DataField.grains_get_values}() for some discussion. This function 4010 is more efficient if several grain quantities need to be calculated since 4011 L{DataField.grains_get_values}() can do lot of repeated work in such case. 4012 4013 Since: 2.22 4014 4015 @param values: Array of B{C{nquantities}} pointers to blocks of length B{C{ngrains}}+1 to 4016 put the calculated grain values to. Each block corresponds to one 4017 requested quantity. B{C{NULL}} can be passed to allocate and return a 4018 new array. I{(gdouble**)} 4019 @param quantities: Array of B{C{nquantities}} items that specify the requested 4020 B{C{GrainQuantity}} to put to corresponding items in B{C{values}}. 4021 Quantities can repeat. I{(const-GrainQuantity*)} 4022 @param nquantities: The number of requested different grain values. I{(int)} 4023 @param grains: Grain numbers filled with L{DataField.number_grains}(). I{(const-gint*)} 4024 @param ngrains: The number of grains as returned by 4025 L{DataField.number_grains}(). I{(int)} 4026 @return: B{C{values}} itself if it was not B{C{NULL}}, otherwise a newly allocated 4027 array that caller has to free with g_free(), including the 4028 contained arrays. 4029 4030 4031 """ 4032 return None
4033 - def area_grains_tgnd( target_line , col , row , width , height , below , nstats ):
4034 """ 4035 Calculates threshold grain number distribution. 4036 4037 This function is a simple L{DataField.area_grains_tgnd_range}() that 4038 calculates the distribution in the full range. 4039 4040 @param target_line: A data line to store the distribution to. It will be 4041 resampled to the requested width. I{(L{DataLine})} 4042 @param col: Upper-left column coordinate. I{(int)} 4043 @param row: Upper-left row coordinate. I{(int)} 4044 @param width: Area width (number of columns). I{(int)} 4045 @param height: Area height (number of rows). I{(int)} 4046 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 4047 @param nstats: The number of samples to take on the distribution function. If 4048 nonpositive, a suitable resolution is determined automatically. I{(int)} 4049 @return: 4050 """ 4051 return None
4052 - def area_grains_tgnd_range( target_line , col , row , width , height , min , max , below , nstats ):
4053 """ 4054 Calculates threshold grain number distribution in given height range. 4055 4056 This is the number of grains for each of B{C{nstats}} equidistant height 4057 threshold levels. For large B{C{nstats}} this function is much faster than the 4058 equivalent number of L{DataField.grains_mark_height}() calls. 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 min: Minimum threshold value. I{(float)} 4067 @param max: Maximum threshold value. I{(float)} 4068 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 4069 @param nstats: The number of samples to take on the distribution function. If 4070 nonpositive, a suitable resolution is determined automatically. I{(int)} 4071 @return: 4072 """ 4073 return None
4074 - def grains_splash_water( minima , locate_steps , locate_dropsize ):
4075 return None
4077 """ 4078 Performs Euclidean distance transform of a data field with grains. 4079 4080 Each non-zero value will be replaced with Euclidean distance to the grain 4081 boundary, measured in pixels. 4082 4083 Since: 2.36 4084 4085 @return: 4086 """ 4087 return None
4088 - def fill_voids( nonsimple ):
4089 """ 4090 Fills voids in grains in a data field representing a mask. 4091 4092 Voids in grains are zero pixels in B{C{data_field}} from which no path exists 4093 through other zero pixels to the field boundary. The paths are considered 4094 in 8-connectivity because grains themselves are considered in 4095 4-connectivity. 4096 4097 Since: 2.37 4098 4099 @param nonsimple: Pass B{C{True}} to fill also voids that are not simple-connected 4100 (e.g. ring-like). This can result in grain merging if a small 4101 grain is contained within a void. Pass B{C{False}} to fill only 4102 simple-connected grains. I{(bool)} 4103 @return: B{C{True}} if any voids were filled at all, B{C{False}} if no change was 4104 made. 4105 4106 4107 """ 4108 return None
4109 - def UNIMPLEMENTED_waterpour( result , grains ):
4110 """ 4111 Performs the classical Vincent watershed segmentation of a data field. 4112 4113 The segmentation always results in the entire field being masked with the 4114 exception of thin (8-connectivity) lines separating the segments (grains). 4115 4116 Compared to L{DataField.grains_mark_watershed}(), this algorithm is very 4117 fast. However, when used alone, it typically results in a serious 4118 oversegmentation as each local minimum gives raise to a grain. Furthermore, 4119 the full segmentation means that also pixels which would be considered 4120 outside any grain in the topographical sense will be assigned to some 4121 catchment basin. Therefore, pre- or postprocessing is usually necessary, 4122 using the gradient image or a more sophisticated method. 4123 4124 The function does not assign pixels with value B{C{HUGE_VAL}} or larger to any 4125 segment. This can be used to pre-mark certain areas explicitly as 4126 boundaries. 4127 4128 Since the algorithm numbers the grains as a side effect, you can pass a 4129 B{C{grains}} array and get the grain numbers immediatelly, avoiding the 4130 relatively (although not drastically) expensive 4131 L{DataField.number_grains}() call. 4132 4133 Since: 2.37 4134 4135 @param result: Data field that will be filled with the resulting mask. It will be 4136 resized to the dimensions of B{C{data_field}} and its properties set 4137 accordingly. I{(L{DataField})} 4138 @param grains: Optionally, an array with the same number of items as B{C{data_field}}. 4139 If non-B{C{NULL}}, it will be filled with grain numbers in the same 4140 manner as L{DataField.number_grains}(). Pass B{C{NULL}} to ignore. I{(gint*)} 4141 @return: The number of segments (grains) in the result, excluding the 4142 separators, i.e. the same convention as in 4143 L{DataField.number_grains}() is used. 4144 4145 4146 """ 4147 return None
4148 - def mark_extrema( extrema , maxima ):
4149 return None
4150 - def hough_line( x_gradient , y_gradient , result , hwidth , overlapping ):
4151 return None
4152 - def hough_circle( x_gradient , y_gradient , result , radius ):
4153 return None
4154 - def hough_line_strenghten( x_gradient , y_gradient , hwidth , threshold ):
4155 return None
4156 - def hough_circle_strenghten( x_gradient , y_gradient , radius , threshold ):
4157 return None
4158 - def UNIMPLEMENTED_get_local_maxima_list( xdata , ydata , zdata , ndata , skip , threshold , subpixel ):
4159 return None
4160 - def hough_polar_line_to_datafield( rho , theta , px1 , px2 , py1 , py2 ):
4161 return None
4162 - def a_1dfft( iin , rout , iout , orientation , windowing , direction , interpolation , preserverms , level ):
4163 """ 4164 Transforms all rows or columns in a data field with Fast Fourier Transform. 4165 4166 If requested a windowing and/or leveling is applied to preprocess data to 4167 obtain reasonable results. 4168 4169 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4170 transform which can be somewhat faster than complex-to-complex 4171 transform. I{(L{DataField})} 4172 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4173 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4174 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4175 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4176 columns. I{(Orientation)} 4177 @param windowing: Windowing type. I{(WindowingType)} 4178 @param direction: FFT direction. I{(TransformDirection)} 4179 @param interpolation: Interpolation type. 4180 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4181 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4182 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4183 line (the number can be interpreted as the first polynomial degree 4184 to keep, but only the enumerated three values are available). I{(int)} 4185 @return: 4186 """ 4187 return None
4188 - def area_1dfft( iin , rout , iout , col , row , width , height , orientation , windowing , direction , interpolation , preserverms , level ):
4189 """ 4190 Transforms all rows or columns in a rectangular part of a data field with 4191 Fast Fourier Transform. 4192 4193 If requested a windowing and/or leveling is applied to preprocess data to 4194 obtain reasonable results. 4195 4196 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4197 transform which can be somewhat faster than complex-to-complex 4198 transform. I{(L{DataField})} 4199 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4200 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4201 @param col: Upper-left column coordinate. I{(int)} 4202 @param row: Upper-left row coordinate. I{(int)} 4203 @param width: Area width (number of columns), must be at least 2 for horizontal 4204 transforms. I{(int)} 4205 @param height: Area height (number of rows), must be at least 2 for vertical 4206 transforms. I{(int)} 4207 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4208 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4209 columns. I{(Orientation)} 4210 @param windowing: Windowing type. I{(WindowingType)} 4211 @param direction: FFT direction. I{(TransformDirection)} 4212 @param interpolation: Interpolation type. 4213 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4214 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4215 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4216 lines (the number can be interpreted as the first polynomial degree 4217 to keep, but only the enumerated three values are available). I{(int)} 4218 @return: 4219 """ 4220 return None
4221 - def a_1dfft_raw( iin , rout , iout , orientation , direction ):
4222 """ 4223 Transforms all rows or columns in a data field with Fast Fourier Transform. 4224 4225 No leveling, windowing nor scaling is performed. 4226 4227 Since 2.8 the dimensions need not to be from the set of sizes returned 4228 by L{gwy_fft_find_nice_size}(). 4229 4230 Since: 2.1 4231 4232 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4233 transform. I{(L{DataField})} 4234 @param rout: Real output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4235 @param iout: Imaginary output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4236 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4237 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4238 columns. I{(Orientation)} 4239 @param direction: FFT direction. I{(TransformDirection)} 4240 @return: 4241 """ 4242 return None
4243 - def a_2dfft( iin , rout , iout , windowing , direction , interpolation , preserverms , level ):
4244 """ 4245 Calculates 2D Fast Fourier Transform of a rectangular a data field. 4246 4247 If requested a windowing and/or leveling is applied to preprocess data to 4248 obtain reasonable results. 4249 4250 Lateral dimensions, offsets and units are unchanged. See 4251 L{DataField.fft_postprocess}() for that. 4252 4253 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4254 transform which can be somewhat faster than complex-to-complex 4255 transform. I{(L{DataField})} 4256 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4257 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4258 @param windowing: Windowing type. I{(WindowingType)} 4259 @param direction: FFT direction. I{(TransformDirection)} 4260 @param interpolation: Interpolation type. I{(InterpolationType)} 4261 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4262 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4263 plane (the number can be interpreted as the first polynomial degree 4264 to keep, but only the enumerated three values are available). I{(int)} 4265 @return: 4266 """ 4267 return None
4268 - def area_2dfft( iin , rout , iout , col , row , width , height , windowing , direction , interpolation , preserverms , level ):
4269 """ 4270 Calculates 2D Fast Fourier Transform of a rectangular area of a data field. 4271 4272 If requested a windowing and/or leveling is applied to preprocess data to 4273 obtain reasonable results. 4274 4275 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4276 transform which can be somewhat faster than complex-to-complex 4277 transform. I{(L{DataField})} 4278 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4279 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4280 @param col: Upper-left column coordinate. I{(int)} 4281 @param row: Upper-left row coordinate. I{(int)} 4282 @param width: Area width (number of columns), must be at least 2. I{(int)} 4283 @param height: Area height (number of rows), must be at least 2. I{(int)} 4284 @param windowing: Windowing type. I{(WindowingType)} 4285 @param direction: FFT direction. I{(TransformDirection)} 4286 @param interpolation: Interpolation type. 4287 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4288 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4289 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4290 plane (the number can be interpreted as the first polynomial degree 4291 to keep, but only the enumerated three values are available). I{(int)} 4292 @return: 4293 """ 4294 return None
4295 - def a_2dfft_raw( iin , rout , iout , direction ):
4296 """ 4297 Calculates 2D Fast Fourier Transform of a data field. 4298 4299 No leveling, windowing nor scaling is performed. 4300 4301 Since 2.8 the dimensions need not to be from the set of sizes returned 4302 by L{gwy_fft_find_nice_size}(). 4303 4304 Lateral dimensions, offsets and units are unchanged. See 4305 L{DataField.fft_postprocess}() for that. 4306 4307 Since: 2.1 4308 4309 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4310 transform. I{(L{DataField})} 4311 @param rout: Real output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4312 @param iout: Imaginary output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4313 @param direction: FFT direction. I{(TransformDirection)} 4314 @return: 4315 """ 4316 return None
4317 - def a_2dfft_humanize( ):
4318 """ 4319 Rearranges 2D FFT output to a human-friendly form. 4320 4321 Top-left, top-right, bottom-left and bottom-right sub-rectangles are swapped 4322 to obtain a humanized 2D FFT output with (0,0) in the centre. 4323 4324 More precisely, for even field dimensions the equally-sized blocks starting 4325 with the Nyquist frequency and with the zero frequency (constant component) 4326 will exchange places. For odd field dimensions, the block containing the 4327 zero frequency is one item larger and the constant component will actually 4328 end up in the exact centre. 4329 4330 Also note if both dimensions are even, this function is involutory and 4331 identical to L{DataField.2dfft_dehumanize}(). However, if any dimension 4332 is odd, L{DataField.2dfft_humanize}() and 4333 L{DataField.2dfft_dehumanize}() are different, therefore they must be 4334 paired properly. 4335 4336 @return: 4337 """ 4338 return None
4339 - def a_2dfft_dehumanize( ):
4340 """ 4341 Rearranges 2D FFT output back from the human-friendly form. 4342 4343 Top-left, top-right, bottom-left and bottom-right sub-rectangles are swapped 4344 to reshuffle a humanized 2D FFT output back into the natural positions. 4345 4346 See L{DataField.2dfft_humanize}() for discussion. 4347 4348 Since: 2.8 4349 4350 @return: 4351 """ 4352 return None
4353 - def fft_postprocess( humanize ):
4354 """ 4355 Updates units, dimensions and offsets for a 2D FFT-processed field. 4356 4357 The field is expected to have dimensions and units of the original 4358 direct-space data. The lateral units and resolutions are updated to 4359 correspond to its Fourier transform. 4360 4361 If B{C{humanize}} is B{C{True}} L{DataField.2dfft_humanize}() is applied to the 4362 field data and the lateral offsets are set accordingly. Otherwise the 4363 offsets are cleared. 4364 4365 Value units are kept intact. 4366 4367 Since: 2.38 4368 4369 @param humanize: B{C{True}} to rearrange data to have the frequency origin in the 4370 centre. I{(bool)} 4371 @return: 4372 """ 4373 return None
4374 - def fft_filter_1d( result_field , weights , orientation , interpolation ):
4375 """ 4376 Performs 1D FFT filtering of a data field. 4377 4378 @param result_field: A data field to store the result to. It will be resampled 4379 to B{C{data_field}}'s size. I{(L{DataField})} 4380 @param weights: Filter weights for the lower half of the spectrum (the other 4381 half is symmetric). Its size can be arbitrary, it will be 4382 interpolated. I{(L{DataLine})} 4383 @param orientation: Filter direction. I{(Orientation)} 4384 @param interpolation: The interpolation to use for resampling. I{(InterpolationType)} 4385 @return: 4386 """ 4387 return None
4388 - def UNIMPLEMENTED_cwt( interpolation , scale , wtype ):
4389 """ 4390 Computes a continuous wavelet transform (CWT) at given 4391 scale and using given wavelet. 4392 4393 @param interpolation: Interpolation type. 4394 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4395 @param scale: Wavelet scale. I{(float)} 4396 @param wtype: Wavelet type. I{(2DCWTWaveletType)} 4397 @return: 4398 """ 4399 return None
4400 - def area_fit_plane( mask , col , row , width , height , pa , pbx , pby ):
4401 """ 4402 Fits a plane through a rectangular part of a data field. 4403 4404 The coefficients can be used for plane leveling using the same relation 4405 as in L{DataField.fit_plane}(), counting indices from area top left 4406 corner. 4407 4408 @param mask: Mask of values to take values into account, or B{C{NULL}} for full 4409 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4410 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4411 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4412 for values inside (0.0, 1.0) is undefined (it may be specified 4413 in the future). I{(L{DataField})} 4414 @param col: Upper-left column coordinate. I{(int)} 4415 @param row: Upper-left row coordinate. I{(int)} 4416 @param width: Area width (number of columns). I{(int)} 4417 @param height: Area height (number of rows). I{(int)} 4418 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(float)} 4419 @param pbx: Where x plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4420 @param pby: Where y plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4421 @return: 4422 """ 4423 return None
4424 - def fit_plane( pa , pbx , pby ):
4425 """ 4426 Fits a plane through a data field. 4427 4428 The coefficients can be used for plane leveling using relation 4429 data[i] := data[i] - (pa + pby*i + pbx*j); 4430 4431 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(float)} 4432 @param pbx: Where x plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4433 @param pby: Where y plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4434 @return: 4435 """ 4436 return None
4437 - def UNIMPLEMENTED_fit_facet_plane( mfield , masking , pa , pbx , pby ):
4438 """ 4439 Calculates the inclination of a plane close to the dominant plane in a data 4440 field. 4441 4442 The dominant plane is determined by taking into account larger local slopes 4443 with exponentially smaller weight. 4444 4445 This is the basis of so-called facet levelling algorithm. Usually, the 4446 plane found by this method is subtracted using L{DataField.plane_level}() 4447 and the entire process is repeated until it converges. A convergence 4448 criterion may be sufficiently small values of the x and y plane 4449 coefficients. Note that since L{DataField.plane_level}() uses pixel-based 4450 lateral coordinates, the coefficients must be divided by 4451 L{DataField.get_xmeasure}(data_field) and 4452 L{DataField.get_ymeasure}(data_field) to obtain physical plane 4453 coefficients. 4454 4455 Since: 2.37 4456 4457 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. 4458 @param masking: Masking mode to use. I{(MaskingType)} 4459 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(gdouble*)} 4460 @param pbx: Where x plane coefficient should be stored. I{(gdouble*)} 4461 @param pby: Where y plane coefficient should be stored. I{(gdouble*)} 4462 @return: B{C{True}} if any plane was actually fitted; B{C{False}} if there was an 4463 insufficient number of unmasked pixels. 4464 4465 4466 """ 4467 return None
4468 - def plane_level( a , bx , by ):
4469 """ 4470 Subtracts plane from a data field. 4471 4472 See L{DataField.fit_plane}() for details. 4473 4474 @param a: Constant coefficient. I{(float)} 4475 @param bx: X plane coefficient. I{(float)} 4476 @param by: Y plane coefficient. I{(float)} 4477 @return: 4478 """ 4479 return None
4480 - def plane_rotate( xangle , yangle , interpolation ):
4481 """ 4482 Performs rotation of plane along x and y axis. 4483 4484 @param xangle: Rotation angle in x direction (rotation along y axis, in radians). I{(float)} 4485 @param yangle: Rotation angle in y direction (rotation along x axis, in radians). I{(float)} 4486 @param interpolation: Interpolation type (can be only of two-point type). I{(InterpolationType)} 4487 @return: 4488 """ 4489 return None
4490 - def fit_lines( col , row , width , height , degree , exclude , orientation ):
4491 """ 4492 Independently levels profiles on each row/column in a data field. 4493 4494 Lines that have no intersection with area selected by B{C{ulcol}}, B{C{ulrow}}, 4495 B{C{brcol}}, B{C{brrow}} are always leveled as a whole. Lines that have intersection 4496 with selected area, are leveled using polynomial coefficients computed only 4497 from data inside (or outside for B{C{exclude}} = B{C{True}}) the area. 4498 4499 @param col: Upper-left column coordinate. I{(int)} 4500 @param row: Upper-left row coordinate. I{(int)} 4501 @param width: Area width (number of columns). I{(int)} 4502 @param height: Area height (number of rows). I{(int)} 4503 @param degree: Fitted polynomial degree. I{(int)} 4504 @param exclude: If B{C{True}}, outside of area selected by B{C{ulcol}}, B{C{ulrow}}, B{C{brcol}}, 4505 B{C{brrow}} will be used for polynomial coefficients computation, 4506 instead of inside. I{(bool)} 4507 @param orientation: Line orientation. I{(Orientation)} 4508 @return: 4509 """ 4510 return None
4511 - def fit_polynom( col_degree , row_degree , coeffs ):
4512 """ 4513 Fits a two-dimensional polynomial to a data field. 4514 4515 4516 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4517 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4518 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4519 coefficients to, or B{C{NULL}} (a fresh array is allocated then), 4520 see L{DataField.area_fit_polynom}() for details. I{(gdouble*)} 4521 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4522 with coefficients. 4523 4524 """ 4525 return None
4526 - def area_fit_polynom( col , row , width , height , col_degree , row_degree , coeffs ):
4527 """ 4528 Fits a two-dimensional polynomial to a rectangular part of a data field. 4529 4530 The coefficients are stored by row into B{C{coeffs}}, like data in a datafield. 4531 Row index is y-degree, column index is x-degree. 4532 4533 Note naive x^n y^m polynomial fitting is numerically unstable, therefore 4534 this method works only up to B{C{col_degree}} = B{C{row_degree}} = 6. 4535 4536 4537 @param col: Upper-left column coordinate. I{(int)} 4538 @param row: Upper-left row coordinate. I{(int)} 4539 @param width: Area width (number of columns). I{(int)} 4540 @param height: Area height (number of rows). I{(int)} 4541 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4542 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4543 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4544 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4545 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4546 with coefficients. 4547 4548 """ 4549 return None
4550 - def subtract_polynom( col_degree , row_degree , coeffs ):
4551 """ 4552 Subtracts a two-dimensional polynomial from a data field. 4553 4554 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4555 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4556 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4557 see L{DataField.area_fit_polynom}() for details. I{(const-gdouble*)} 4558 @return: 4559 """ 4560 return None
4561 - def area_subtract_polynom( col , row , width , height , col_degree , row_degree , coeffs ):
4562 """ 4563 Subtracts a two-dimensional polynomial from a rectangular part of a data 4564 field. 4565 4566 @param col: Upper-left column coordinate. I{(int)} 4567 @param row: Upper-left row coordinate. I{(int)} 4568 @param width: Area width (number of columns). I{(int)} 4569 @param height: Area height (number of rows). I{(int)} 4570 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4571 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4572 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4573 see L{DataField.area_fit_polynom}() for details. I{(const-gdouble*)} 4574 @return: 4575 """ 4576 return None
4577 - def UNIMPLEMENTED_fit_legendre( col_degree , row_degree , coeffs ):
4578 """ 4579 Fits two-dimensional Legendre polynomial to a data field. 4580 4581 See L{DataField.area_fit_legendre}() for details. 4582 4583 4584 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4585 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4586 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4587 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4588 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4589 with coefficients. 4590 4591 """ 4592 return None
4593 - def UNIMPLEMENTED_area_fit_legendre( col , row , width , height , col_degree , row_degree , coeffs ):
4594 """ 4595 Fits two-dimensional Legendre polynomial to a rectangular part of a data 4596 field. 4597 4598 The B{C{col_degree}} and B{C{row_degree}} parameters limit the maximum powers of x and 4599 y exactly as if simple powers were fitted, therefore if you do not intend to 4600 interpret contents of B{C{coeffs}} youself, the only difference is that this 4601 method is much more numerically stable. 4602 4603 The coefficients are organized exactly like in 4604 L{DataField.area_fit_polynom}(), but they are not coefficients of 4605 x^n y^m, instead they are coefficients of P_n(x) P_m(x), where P are 4606 Legendre polynomials. The polynomials are evaluated in coordinates where 4607 first row (column) corresponds to -1.0, and the last row (column) to 1.0. 4608 4609 Note the polynomials are normal Legendre polynomials that are not exactly 4610 orthogonal on a discrete point set (if their degrees are equal mod 2). 4611 4612 4613 @param col: Upper-left column coordinate. I{(int)} 4614 @param row: Upper-left row coordinate. I{(int)} 4615 @param width: Area width (number of columns). I{(int)} 4616 @param height: Area height (number of rows). I{(int)} 4617 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4618 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4619 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4620 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4621 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4622 with coefficients. 4623 4624 """ 4625 return None
4626 - def subtract_legendre( col_degree , row_degree , coeffs ):
4627 """ 4628 Subtracts a two-dimensional Legendre polynomial fit from a data field. 4629 4630 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4631 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4632 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4633 see L{DataField.area_fit_legendre}() for details. I{(const-gdouble*)} 4634 @return: 4635 """ 4636 return None
4637 - def area_subtract_legendre( col , row , width , height , col_degree , row_degree , coeffs ):
4638 """ 4639 Subtracts a two-dimensional Legendre polynomial fit from a rectangular part 4640 of a data field. 4641 4642 Due to the transform of coordinates to [-1,1] x [-1,1], this method can be 4643 used on an area of dimensions different than the area the coefficients were 4644 calculated for. 4645 4646 @param col: Upper-left column coordinate. I{(int)} 4647 @param row: Upper-left row coordinate. I{(int)} 4648 @param width: Area width (number of columns). I{(int)} 4649 @param height: Area height (number of rows). I{(int)} 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 UNIMPLEMENTED_fit_poly_max( max_degree , coeffs ):
4658 """ 4659 Fits two-dimensional polynomial with limited total degree to a data field. 4660 4661 See L{DataField.area_fit_poly_max}() for details. 4662 4663 4664 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4665 in x^n y^m terms. I{(int)} 4666 @param coeffs: An array of size (B{C{max_degree}}+1)*(B{C{max_degree}}+2)/2 to store the 4667 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4668 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4669 with coefficients. 4670 4671 """ 4672 return None
4673 - def UNIMPLEMENTED_area_fit_poly_max( col , row , width , height , max_degree , coeffs ):
4674 """ 4675 Fits two-dimensional polynomial with limited total degree to a rectangular 4676 part of a data field. 4677 4678 See L{DataField.area_fit_legendre}() for description. This function 4679 differs by limiting the total maximum degree, while 4680 L{DataField.area_fit_legendre}() limits the maximum degrees in horizontal 4681 and vertical directions independently. 4682 4683 4684 @param col: Upper-left column coordinate. I{(int)} 4685 @param row: Upper-left row coordinate. I{(int)} 4686 @param width: Area width (number of columns). I{(int)} 4687 @param height: Area height (number of rows). I{(int)} 4688 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4689 in x^n y^m terms. I{(int)} 4690 @param coeffs: An array of size (B{C{max_degree}}+1)*(B{C{max_degree}}+2)/2 to store the 4691 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4692 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4693 with coefficients. 4694 4695 """ 4696 return None
4697 - def subtract_poly_max( max_degree , coeffs ):
4698 """ 4699 Subtracts a two-dimensional polynomial with limited total degree from 4700 a data field. 4701 4702 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4703 in x^n y^m terms. I{(int)} 4704 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+2)/2 with 4705 coefficients, see L{DataField.area_fit_poly_max}() for details. I{(const-gdouble*)} 4706 @return: 4707 """ 4708 return None
4709 - def area_subtract_poly_max( col , row , width , height , max_degree , coeffs ):
4710 """ 4711 Subtracts a two-dimensional polynomial with limited total degree from a 4712 rectangular part of a data field. 4713 4714 Due to the transform of coordinates to [-1,1] x [-1,1], this method can be 4715 used on an area of dimensions different than the area the coefficients were 4716 calculated for. 4717 4718 @param col: Upper-left column coordinate. I{(int)} 4719 @param row: Upper-left row coordinate. I{(int)} 4720 @param width: Area width (number of columns). I{(int)} 4721 @param height: Area height (number of rows). I{(int)} 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 fit_poly( mask_field , nterms , term_powers , exclude , coeffs ):
4730 """ 4731 Fit a given set of polynomial terms to a data field. 4732 4733 Since: 2.11 4734 4735 @param mask_field: Mask of values to take values into account, or B{C{NULL}} for full 4736 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4737 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4738 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4739 for values inside (0.0, 1.0) is undefined (it may be specified 4740 in the future). I{(L{DataField})} 4741 @param nterms: The number of polynomial terms to take into account (half the 4742 number of items in B{C{term_powers}}). I{(int)} 4743 @param term_powers: Array of size 2*B{C{nterms}} describing the terms to fit. Each 4744 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4745 @param exclude: Interpret values B{C{w}} in the mask as 1.0-B{C{w}}. I{(bool)} 4746 @param coeffs: Array of size B{C{nterms}} to store the coefficients to, or B{C{NULL}} to 4747 allocate a new array. I{(gdouble*)} 4748 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4749 with coefficients. 4750 4751 4752 """ 4753 return None
4754 - def area_fit_poly( mask_field , col , row , width , height , nterms , term_powers , exclude , coeffs ):
4755 """ 4756 Fit a given set of polynomial terms to a rectangular part of a data field. 4757 4758 The polynomial coefficients correspond to normalized coordinates that 4759 are always from the interval [-1,1] where -1 corresponds to the left/topmost 4760 pixel and 1 corresponds to the bottom/rightmost pixel of the area. 4761 4762 Since: 2.11 4763 4764 @param mask_field: Mask of values to take values into account, or B{C{NULL}} for full 4765 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4766 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4767 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4768 for values inside (0.0, 1.0) is undefined (it may be specified 4769 in the future). I{(L{DataField})} 4770 @param col: Upper-left column coordinate. I{(int)} 4771 @param row: Upper-left row coordinate. I{(int)} 4772 @param width: Area width (number of columns). I{(int)} 4773 @param height: Area height (number of rows). I{(int)} 4774 @param nterms: The number of polynomial terms to take into account (half the 4775 number of items in B{C{term_powers}}). I{(int)} 4776 @param term_powers: Array of size 2*B{C{nterms}} describing the terms to fit. Each 4777 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4778 @param exclude: Interpret values B{C{w}} in the mask as 1.0-B{C{w}}. I{(bool)} 4779 @param coeffs: Array of size B{C{nterms}} to store the coefficients to, or B{C{NULL}} to 4780 allocate a new array. I{(gdouble*)} 4781 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4782 with coefficients. 4783 4784 4785 """ 4786 return None
4787 - def subtract_poly( nterms , term_powers , coeffs ):
4788 """ 4789 Subtract a given set of polynomial terms from a data field. 4790 4791 Since: 2.11 4792 4793 @param nterms: The number of polynomial terms to take into account (half the 4794 number of items in B{C{term_powers}}). I{(int)} 4795 @param term_powers: Array of size 2*B{C{nterms}} describing the fitter terms. Each 4796 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4797 @param coeffs: Array of size B{C{nterms}} to store with the coefficients. I{(const-gdouble*)} 4798 @return: 4799 """ 4800 return None
4801 - def area_subtract_poly( col , row , width , height , nterms , term_powers , coeffs ):
4802 """ 4803 Subtract a given set of polynomial terms from a rectangular part of a data 4804 field. 4805 4806 Since: 2.11 4807 4808 @param col: Upper-left column coordinate. I{(int)} 4809 @param row: Upper-left row coordinate. I{(int)} 4810 @param width: Area width (number of columns). I{(int)} 4811 @param height: Area height (number of rows). I{(int)} 4812 @param nterms: The number of polynomial terms to take into account (half the 4813 number of items in B{C{term_powers}}). I{(int)} 4814 @param term_powers: Array of size 2*B{C{nterms}} describing the fitted terms. Each 4815 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4816 @param coeffs: Array of size B{C{nterms}} to store with the coefficients. I{(const-gdouble*)} 4817 @return: 4818 """ 4819 return None
4820 - def UNIMPLEMENTED_area_fit_local_planes( size , col , row , width , height , nresults , types , results ):
4821 """ 4822 Fits a plane through neighbourhood of each sample in a rectangular part 4823 of a data field. 4824 4825 The sample is always in the origin of its local (x,y) coordinate system, 4826 even if the neighbourhood is not centered about it (e.g. because sample 4827 is on the edge of data field). Z-coordinate is however not centered, 4828 that is B{C{PLANE_FIT_A}} is normal mean value. 4829 4830 4831 @param size: Neighbourhood size (must be at least 2). It is centered around 4832 each pixel, unless B{C{size}} is even when it sticks to the right. I{(int)} 4833 @param col: Upper-left column coordinate. I{(int)} 4834 @param row: Upper-left row coordinate. I{(int)} 4835 @param width: Area width (number of columns). I{(int)} 4836 @param height: Area height (number of rows). I{(int)} 4837 @param nresults: The number of requested quantities. I{(int)} 4838 @param types: The types of requested quantities. I{(const-PlaneFitQuantity*)} 4839 @param results: An array to store quantities to, may be B{C{NULL}} to allocate a new 4840 one which must be freed by caller then. If any item is B{C{NULL}}, 4841 a new data field is allocated for it, existing data fields 4842 are resized to B{C{width}} x B{C{height}}. I{(DataField**)} 4843 @return: An array of data fields with requested quantities, that is 4844 B{C{results}} unless it was B{C{NULL}} and a new array was allocated. 4845 4846 """ 4847 return None
4848 - def area_local_plane_quantity( size , col , row , width , height , type , result ):
4849 """ 4850 Convenience function to get just one quantity from 4851 L{DataField.area_fit_local_planes}(). 4852 4853 4854 @param size: Neighbourhood size. I{(int)} 4855 @param col: Upper-left column coordinate. I{(int)} 4856 @param row: Upper-left row coordinate. I{(int)} 4857 @param width: Area width (number of columns). I{(int)} 4858 @param height: Area height (number of rows). I{(int)} 4859 @param type: The type of requested quantity. I{(PlaneFitQuantity)} 4860 @param result: A data field to store result to, or B{C{NULL}} to allocate a new one. I{(L{DataField})} 4861 @return: B{C{result}} if it isn't B{C{NULL}}, otherwise a newly allocated data field. 4862 4863 """ 4864 return None
4865 - def UNIMPLEMENTED_fit_local_planes( size , nresults , types , results ):
4866 """ 4867 Fits a plane through neighbourhood of each sample in a data field. 4868 4869 See L{DataField.area_fit_local_planes}() for details. 4870 4871 4872 @param size: Neighbourhood size. I{(int)} 4873 @param nresults: The number of requested quantities. I{(int)} 4874 @param types: The types of requested quantities. I{(const-PlaneFitQuantity*)} 4875 @param results: An array to store quantities to. I{(DataField**)} 4876 @return: An array of data fields with requested quantities. 4877 4878 """ 4879 return None
4880 - def local_plane_quantity( size , type , result ):
4881 """ 4882 Convenience function to get just one quantity from 4883 L{DataField.fit_local_planes}(). 4884 4885 4886 @param size: Neighbourhood size. I{(int)} 4887 @param type: The type of requested quantity. I{(PlaneFitQuantity)} 4888 @param result: A data field to store result to, or B{C{NULL}} to allocate a new one. I{(L{DataField})} 4889 @return: B{C{result}} if it isn't B{C{NULL}}, otherwise a newly allocated data field. 4890 4891 """ 4892 return None
4893 - def get_max( ):
4894 """ 4895 Finds the maximum value of a data field. 4896 4897 This quantity is cached. 4898 4899 4900 @return: The maximum value. 4901 4902 """ 4903 return None
4904 - def get_min( ):
4905 """ 4906 Finds the minimum value of a data field. 4907 4908 This quantity is cached. 4909 4910 4911 @return: The minimum value. 4912 4913 """ 4914 return None
4915 - def get_min_max( min , max ):
4916 """ 4917 Finds minimum and maximum values of a data field. 4918 4919 @param min: Location to store minimum to. I{(float)} 4920 @param max: Location to store maximum to. I{(float)} 4921 @return: 4922 """ 4923 return None
4924 - def get_avg( ):
4925 """ 4926 Computes average value of a data field. 4927 4928 This quantity is cached. 4929 4930 4931 @return: The average value. 4932 4933 """ 4934 return None
4935 - def get_rms( ):
4936 """ 4937 Computes root mean square value of a data field. 4938 4939 This quantity is cached. 4940 4941 4942 @return: The root mean square value. 4943 4944 """ 4945 return None
4946 - def get_sum( ):
4947 """ 4948 Sums all values in a data field. 4949 4950 This quantity is cached. 4951 4952 4953 @return: The sum of all values. 4954 4955 """ 4956 return None
4957 - def get_median( ):
4958 """ 4959 Computes median value of a data field. 4960 4961 This quantity is cached. 4962 4963 4964 @return: The median value. 4965 4966 """ 4967 return None
4968 - def get_surface_area( ):
4969 """ 4970 Computes surface area of a data field. 4971 4972 This quantity is cached. 4973 4974 4975 @return: The surface area. 4976 4977 """ 4978 return None
4979 - def get_variation( ):
4980 """ 4981 Computes the total variation of a data field. 4982 4983 See L{DataField.area_get_variation}() for the definition. 4984 4985 This quantity is cached. 4986 4987 Since: 2.38 4988 4989 @return: The variation. 4990 4991 4992 """ 4993 return None
4994 - def area_get_max( mask , col , row , width , height ):
4995 """ 4996 Finds the maximum value in a rectangular part of a data field. 4997 4998 4999 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5000 @param col: Upper-left column coordinate. I{(int)} 5001 @param row: Upper-left row coordinate. I{(int)} 5002 @param width: Area width (number of columns). I{(int)} 5003 @param height: Area height (number of rows). I{(int)} 5004 @return: The maximum value. When the number of samples to calculate 5005 maximum of is zero, -B{C{G_MAXDOUBLE}} is returned. 5006 5007 """ 5008 return None
5009 - def area_get_min( mask , col , row , width , height ):
5010 """ 5011 Finds the minimum value in a rectangular part of a data field. 5012 5013 5014 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5015 @param col: Upper-left column coordinate. I{(int)} 5016 @param row: Upper-left row coordinate. I{(int)} 5017 @param width: Area width (number of columns). I{(int)} 5018 @param height: Area height (number of rows). I{(int)} 5019 @return: The minimum value. When the number of samples to calculate 5020 minimum of is zero, -B{C{G_MAXDOUBLE}} is returned. 5021 5022 """ 5023 return None
5024 - def UNIMPLEMENTED_area_get_min_max( mask , col , row , width , height , min , max ):
5025 """ 5026 Finds minimum and maximum values in a rectangular part of a data field. 5027 5028 This function is equivalent to calling 5029 B{C{L{DataField.area_get_min_max_mask}}}() 5030 with masking mode B{C{MASK_INCLUDE}}. 5031 5032 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5033 @param col: Upper-left column coordinate. I{(int)} 5034 @param row: Upper-left row coordinate. I{(int)} 5035 @param width: Area width (number of columns). I{(int)} 5036 @param height: Area height (number of rows). I{(int)} 5037 @param min: Location to store minimum to. I{(gdouble*)} 5038 @param max: Location to store maximum to. I{(gdouble*)} 5039 @return: 5040 """ 5041 return None
5042 - def UNIMPLEMENTED_area_get_min_max_mask( mask , mode , col , row , width , height , min , max ):
5043 """ 5044 Finds minimum and maximum values in a rectangular part of a data field. 5045 5046 Since: 2.18 5047 5048 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5049 @param mode: Masking mode to use. See the introduction for description of 5050 masking modes. I{(MaskingType)} 5051 @param col: Upper-left column coordinate. I{(int)} 5052 @param row: Upper-left row coordinate. I{(int)} 5053 @param width: Area width (number of columns). I{(int)} 5054 @param height: Area height (number of rows). I{(int)} 5055 @param min: Location to store minimum to. I{(gdouble*)} 5056 @param max: Location to store maximum to. I{(gdouble*)} 5057 @return: 5058 """ 5059 return None
5060 - def area_get_avg( mask , col , row , width , height ):
5061 """ 5062 Computes average value of a rectangular part of a data field. 5063 5064 This function is equivalent to calling B{C{L{DataField.area_get_avg_mask}}}() 5065 with masking mode B{C{MASK_INCLUDE}}. 5066 5067 5068 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5069 @param col: Upper-left column coordinate. I{(int)} 5070 @param row: Upper-left row coordinate. I{(int)} 5071 @param width: Area width (number of columns). I{(int)} 5072 @param height: Area height (number of rows). I{(int)} 5073 @return: The average value. 5074 5075 """ 5076 return None
5077 - def area_get_avg_mask( mask , mode , col , row , width , height ):
5078 """ 5079 Computes average value of a rectangular part of a data field. 5080 5081 Since: 2.18 5082 5083 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5084 @param mode: Masking mode to use. See the introduction for description of 5085 masking modes. I{(MaskingType)} 5086 @param col: Upper-left column coordinate. I{(int)} 5087 @param row: Upper-left row coordinate. I{(int)} 5088 @param width: Area width (number of columns). I{(int)} 5089 @param height: Area height (number of rows). I{(int)} 5090 @return: The average value. 5091 5092 5093 """ 5094 return None
5095 - def area_get_rms( mask , col , row , width , height ):
5096 """ 5097 Computes root mean square value of a rectangular part of a data field. 5098 5099 5100 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5101 @param col: Upper-left column coordinate. I{(int)} 5102 @param row: Upper-left row coordinate. I{(int)} 5103 @param width: Area width (number of columns). I{(int)} 5104 @param height: Area height (number of rows). I{(int)} 5105 @return: The root mean square value. 5106 5107 This function is equivalent to calling B{C{L{DataField.area_get_rms_mask}}}() 5108 with masking mode B{C{MASK_INCLUDE}}. 5109 5110 """ 5111 return None
5112 - def area_get_rms_mask( mask , mode , col , row , width , height ):
5113 """ 5114 Computes root mean square value of deviations of a rectangular part of a 5115 data field. 5116 5117 Since: 2.18 5118 5119 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5120 @param mode: Masking mode to use. See the introduction for description of 5121 masking modes. I{(MaskingType)} 5122 @param col: Upper-left column coordinate. I{(int)} 5123 @param row: Upper-left row coordinate. I{(int)} 5124 @param width: Area width (number of columns). I{(int)} 5125 @param height: Area height (number of rows). I{(int)} 5126 @return: The root mean square value of deviations from the mean value. 5127 5128 5129 """ 5130 return None
5131 - def area_get_grainwise_rms( mask , mode , col , row , width , height ):
5132 """ 5133 Computes grain-wise root mean square value of deviations of a rectangular 5134 part of a data field. 5135 5136 Grain-wise means that the mean value is determined for each grain (i.e. 5137 cotinguous part of the mask or inverted mask) separately and the deviations 5138 are calculated from these mean values. 5139 5140 Since: 2.29 5141 5142 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5143 @param mode: Masking mode to use. See the introduction for description of 5144 masking modes. I{(MaskingType)} 5145 @param col: Upper-left column coordinate. I{(int)} 5146 @param row: Upper-left row coordinate. I{(int)} 5147 @param width: Area width (number of columns). I{(int)} 5148 @param height: Area height (number of rows). I{(int)} 5149 @return: The root mean square value of deviations from the mean value. 5150 5151 5152 """ 5153 return None
5154 - def area_get_sum( mask , col , row , width , height ):
5155 """ 5156 Sums values of a rectangular part of a data field. 5157 5158 This function is equivalent to calling B{C{L{DataField.area_get_sum_mask}}}() 5159 with masking mode B{C{MASK_INCLUDE}}. 5160 5161 5162 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5163 @param col: Upper-left column coordinate. I{(int)} 5164 @param row: Upper-left row coordinate. I{(int)} 5165 @param width: Area width (number of columns). I{(int)} 5166 @param height: Area height (number of rows). I{(int)} 5167 @return: The sum of all values inside area. 5168 5169 """ 5170 return None
5171 - def area_get_sum_mask( mask , mode , col , row , width , height ):
5172 """ 5173 Sums values of a rectangular part of a data field. 5174 5175 Since: 2.18 5176 5177 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5178 @param mode: Masking mode to use. See the introduction for description of 5179 masking modes. I{(MaskingType)} 5180 @param col: Upper-left column coordinate. I{(int)} 5181 @param row: Upper-left row coordinate. I{(int)} 5182 @param width: Area width (number of columns). I{(int)} 5183 @param height: Area height (number of rows). I{(int)} 5184 @return: The sum of all values inside area. 5185 5186 5187 """ 5188 return None
5189 - def area_get_median( mask , col , row , width , height ):
5190 """ 5191 Computes median value of a data field area. 5192 5193 This function is equivalent to calling 5194 B{C{L{DataField.area_get_median_mask}}}() 5195 with masking mode B{C{MASK_INCLUDE}}. 5196 5197 5198 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5199 @param col: Upper-left column coordinate. I{(int)} 5200 @param row: Upper-left row coordinate. I{(int)} 5201 @param width: Area width (number of columns). I{(int)} 5202 @param height: Area height (number of rows). I{(int)} 5203 @return: The median value. 5204 5205 """ 5206 return None
5207 - def area_get_median_mask( mask , mode , col , row , width , height ):
5208 """ 5209 Computes median value of a data field area. 5210 5211 Since: 2.18 5212 5213 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5214 @param mode: Masking mode to use. See the introduction for description of 5215 masking modes. I{(MaskingType)} 5216 @param col: Upper-left column coordinate. I{(int)} 5217 @param row: Upper-left row coordinate. I{(int)} 5218 @param width: Area width (number of columns). I{(int)} 5219 @param height: Area height (number of rows). I{(int)} 5220 @return: The median value. 5221 5222 5223 """ 5224 return None
5225 - def area_get_surface_area( mask , col , row , width , height ):
5226 return None
5227 - def area_get_surface_area_mask( mask , mode , col , row , width , height ):
5228 """ 5229 Computes surface area of a rectangular part of a data field. 5230 5231 This quantity makes sense only if the lateral dimensions and values of 5232 B{C{data_field}} are the same physical quantities. 5233 5234 Since: 2.18 5235 5236 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5237 @param mode: Masking mode to use. See the introduction for description of 5238 masking modes. I{(MaskingType)} 5239 @param col: Upper-left column coordinate. I{(int)} 5240 @param row: Upper-left row coordinate. I{(int)} 5241 @param width: Area width (number of columns). I{(int)} 5242 @param height: Area height (number of rows). I{(int)} 5243 @return: The surface area. 5244 5245 5246 """ 5247 return None
5248 - def area_get_variation( mask , mode , col , row , width , height ):
5249 """ 5250 Computes the total variation of a rectangular part of a data field. 5251 5252 The total variation is estimated as the integral of the absolute value of 5253 local gradient. 5254 5255 Since: 2.38 5256 5257 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5258 @param mode: Masking mode to use. See the introduction for description of 5259 masking modes. I{(MaskingType)} 5260 @param col: Upper-left column coordinate. I{(int)} 5261 @param row: Upper-left row coordinate. I{(int)} 5262 @param width: Area width (number of columns). I{(int)} 5263 @param height: Area height (number of rows). I{(int)} 5264 @return: The variation. 5265 5266 5267 """ 5268 return None
5269 - def area_get_volume( basis , mask , col , row , width , height ):
5270 """ 5271 Computes volume of a rectangular part of a data field. 5272 5273 Since: 2.3 5274 5275 @param basis: The basis or background for volume calculation if not B{C{NULL}}. 5276 The height of each vertex is then the difference between 5277 B{C{data_field}} value and B{C{basis}} value. Value B{C{NULL}} is the same 5278 as passing all zeroes for the basis. I{(L{DataField})} 5279 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 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 volume. 5285 5286 5287 """ 5288 return None
5289 - def UNIMPLEMENTED_get_autorange( _from , to ):
5290 """ 5291 Computes value range with outliers cut-off. 5292 5293 The purpose of this function is to find a range is suitable for false color 5294 mapping. The precise method how it is calculated is unspecified and may be 5295 subject to changes. 5296 5297 However, it is guaranteed minimum <= B{C{from}} <= B{C{to}} <= maximum. 5298 5299 This quantity is cached. 5300 5301 @param _from: Location to store range start. I{(gdouble*)} 5302 @param to: Location to store range end. I{(gdouble*)} 5303 @return: 5304 """ 5305 return None
5306 - def get_stats( avg , ra , rms , skew , kurtosis ):
5307 """ 5308 Computes basic statistical quantities of a data field. 5309 5310 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(float)} 5311 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(float)} 5312 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5313 or B{C{NULL}}. I{(float)} 5314 @param skew: Where skew (symmetry of height distribution) should be stored, or 5315 B{C{NULL}}. I{(float)} 5316 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5317 stored, or B{C{NULL}}. I{(float)} 5318 @return: 5319 """ 5320 return None
5321 - def area_get_stats( mask , col , row , width , height , avg , ra , rms , skew , kurtosis ):
5322 """ 5323 Computes basic statistical quantities of a rectangular part of a data field. 5324 5325 This function is equivalent to calling B{C{L{DataField.area_get_stats_mask}}}() 5326 with masking mode B{C{MASK_INCLUDE}}. 5327 5328 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5329 @param col: Upper-left column coordinate. I{(int)} 5330 @param row: Upper-left row coordinate. I{(int)} 5331 @param width: Area width (number of columns). I{(int)} 5332 @param height: Area height (number of rows). I{(int)} 5333 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(float)} 5334 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(float)} 5335 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5336 or B{C{NULL}}. I{(float)} 5337 @param skew: Where skew (symmetry of height distribution) should be stored, or 5338 B{C{NULL}}. I{(float)} 5339 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5340 stored, or B{C{NULL}}. I{(float)} 5341 @return: 5342 """ 5343 return None
5344 - def UNIMPLEMENTED_area_get_stats_mask( mask , mode , col , row , width , height , avg , ra , rms , skew , kurtosis ):
5345 """ 5346 Computes basic statistical quantities of a rectangular part of a data field. 5347 5348 Since: 2.18 5349 5350 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5351 @param mode: Masking mode to use. See the introduction for description of 5352 masking modes. I{(MaskingType)} 5353 @param col: Upper-left column coordinate. I{(int)} 5354 @param row: Upper-left row coordinate. I{(int)} 5355 @param width: Area width (number of columns). I{(int)} 5356 @param height: Area height (number of rows). I{(int)} 5357 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(gdouble*)} 5358 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(gdouble*)} 5359 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5360 or B{C{NULL}}. I{(gdouble*)} 5361 @param skew: Where skew (symmetry of height distribution) should be stored, or 5362 B{C{NULL}}. I{(gdouble*)} 5363 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5364 stored, or B{C{NULL}}. I{(gdouble*)} 5365 @return: 5366 """ 5367 return None
5368 - def area_count_in_range( mask , col , row , width , height , below , above , nbelow , nabove ):
5369 """ 5370 Counts data samples in given range. 5371 5372 No assertion is made about the values of B{C{above}} and B{C{below}}, in other words 5373 B{C{above}} may be larger than B{C{below}}. To count samples in an open interval 5374 instead of a closed interval, exchange B{C{below}} and B{C{above}} and then subtract 5375 the B{C{nabove}} and B{C{nbelow}} from B{C{width}}*B{C{height}} to get the complementary counts. 5376 5377 With this trick the common task of counting positive values can be 5378 realized: 5379 <informalexample><programlisting> 5380 L{DataField.area_count_in_range}(data_field, NULL, 5381 col, row, width, height, 5382 0.0, 0.0, &amp;count, NULL); 5383 count = width*height - count; 5384 </programlisting></informalexample> 5385 5386 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5387 @param col: Upper-left column coordinate. I{(int)} 5388 @param row: Upper-left row coordinate. I{(int)} 5389 @param width: Area width (number of columns). I{(int)} 5390 @param height: Area height (number of rows). I{(int)} 5391 @param below: Upper bound to compare data to. The number of samples less 5392 than or equal to B{C{below}} is stored in B{C{nbelow}}. I{(float)} 5393 @param above: Lower bound to compare data to. The number of samples greater 5394 than or equal to B{C{above}} is stored in B{C{nabove}}. I{(float)} 5395 @param nbelow: Location to store the number of samples less than or equal 5396 to B{C{below}}, or B{C{NULL}}. I{(int)} 5397 @param nabove: Location to store the number of samples greater than or equal 5398 to B{C{above}}, or B{C{NULL}}. I{(int)} 5399 @return: 5400 """ 5401 return None
5402 - def area_dh( mask , target_line , col , row , width , height , nstats ):
5403 """ 5404 Calculates distribution of heights in a rectangular part of data field. 5405 5406 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5407 @param target_line: A data line to store the distribution to. It will be 5408 resampled to requested width. I{(L{DataLine})} 5409 @param col: Upper-left column coordinate. I{(int)} 5410 @param row: Upper-left row coordinate. I{(int)} 5411 @param width: Area width (number of columns). I{(int)} 5412 @param height: Area height (number of rows). I{(int)} 5413 @param nstats: The number of samples to take on the distribution function. If 5414 nonpositive, a suitable resolution is determined automatically. I{(int)} 5415 @return: 5416 """ 5417 return None
5418 - def dh( target_line , nstats ):
5419 """ 5420 Calculates distribution of heights in a data field. 5421 5422 @param target_line: A data line to store the distribution to. It will be 5423 resampled to requested width. I{(L{DataLine})} 5424 @param nstats: The number of samples to take on the distribution function. If 5425 nonpositive, a suitable resolution is determined automatically. I{(int)} 5426 @return: 5427 """ 5428 return None
5429