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