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