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 new_alike( nullme ):
2284 """ 2285 Creates a new data field similar to an existing one. 2286 2287 Use L{DataField.duplicate}() if you want to copy a data field including 2288 data. 2289 2290 2291 @param nullme: Whether the data field should be initialized to zeroes. If B{C{False}}, 2292 the data will not be initialized. I{(bool)} 2293 @return: A newly created data field. 2294 2295 """ 2296 return None
2297 - def data_changed( ):
2298 """ 2299 Emits signal "data-changed" on a data field. 2300 2301 @return: 2302 """ 2303 return None
2304 - def new_resampled( xres , yres , interpolation ):
2305 """ 2306 Creates a new data field by resampling an existing one. 2307 2308 This method is equivalent to L{DataField.duplicate}() followed by 2309 L{DataField.resample}(), but it is more efficient. 2310 2311 2312 @param xres: Desired X resolution. I{(int)} 2313 @param yres: Desired Y resolution. I{(int)} 2314 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2315 @return: A newly created data field. 2316 2317 """ 2318 return None
2319 - def resample( xres , yres , interpolation ):
2320 """ 2321 Resamples a data field using given interpolation method 2322 2323 This method may invalidate raw data buffer returned by 2324 L{DataField.get_data}(). 2325 2326 @param xres: Desired X resolution. I{(int)} 2327 @param yres: Desired Y resolution. I{(int)} 2328 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2329 @return: 2330 """ 2331 return None
2332 - def resize( ulcol , ulrow , brcol , brrow ):
2333 """ 2334 Resizes (crops) a data field. 2335 2336 Crops a data field to a rectangle between upper-left and bottom-right 2337 points, recomputing real size. 2338 2339 This method may invalidate raw data buffer returned by 2340 L{DataField.get_data}(). 2341 2342 @param ulcol: Upper-left column coordinate. I{(int)} 2343 @param ulrow: Upper-left row coordinate. I{(int)} 2344 @param brcol: Bottom-right column coordinate + 1. I{(int)} 2345 @param brrow: Bottom-right row coordinate + 1. I{(int)} 2346 @return: 2347 """ 2348 return None
2349 - def area_extract( col , row , width , height ):
2350 """ 2351 Extracts a rectangular part of a data field to a new data field. 2352 2353 2354 @param row: Upper-left row coordinate. I{(int)} 2355 @param col: Upper-left column coordinate. I{(int)} 2356 @param width: Area width (number of columns). I{(int)} 2357 @param height: Area height (number of rows). I{(int)} 2358 @return: The extracted area as a newly created data field. 2359 2360 """ 2361 return None
2362 - def copy( dest , nondata_too ):
2363 """ 2364 Copies the contents of an already allocated data field to a data field 2365 of the same size. 2366 2367 @param dest: Destination data field. I{(L{DataField})} 2368 @param nondata_too: Whether non-data (units) should be compied too. I{(bool)} 2369 @return: 2370 """ 2371 return None
2372 - def area_copy( dest , col , row , width , height , destcol , destrow ):
2373 """ 2374 Copies a rectangular area from one data field to another. 2375 2376 The area starts at (B{C{col}}, B{C{row}}) in B{C{src}} and its dimension is B{C{width}}*B{C{height}}. 2377 It is copied to B{C{dest}} starting from (B{C{destcol}}, B{C{destrow}}). 2378 2379 The source area has to be completely contained in B{C{src}}. No assumptions are 2380 made about destination position, however, parts of the source area sticking 2381 out the destination data field B{C{dest}} are cut off. 2382 2383 If B{C{src}} is equal to B{C{dest}}, the areas may not overlap. 2384 2385 @param dest: Destination data field. I{(L{DataField})} 2386 @param col: Area upper-left column coordinate in B{C{src}}. I{(int)} 2387 @param row: Area upper-left row coordinate B{C{src}}. I{(int)} 2388 @param width: Area width (number of columns), pass -1 for full B{C{src}} widdth. I{(int)} 2389 @param height: Area height (number of rows), pass -1 for full B{C{src}} height. I{(int)} 2390 @param destcol: Destination column in B{C{dest}}. I{(int)} 2391 @param destrow: Destination row in B{C{dest}}. I{(int)} 2392 @return: 2393 """ 2394 return None
2395 - def get_data( ):
2396 """ 2397 Create a tuple of data which the datafield contains. Content of the tuple is NOT reference to original datafield but its copy. 2398 2399 2400 @return: tuple of raw numeric data from DataField 2401 2402 """ 2403 return None
2404 - def get_xres( ):
2405 """ 2406 Gets X resolution (number of columns) of a data field. 2407 2408 2409 @return: X resolution. 2410 2411 """ 2412 return None
2413 - def get_yres( ):
2414 """ 2415 Gets Y resolution (number of rows) of the field. 2416 2417 2418 @return: Y resolution. 2419 2420 """ 2421 return None
2422 - def get_xreal( ):
2423 """ 2424 Gets the X real (physical) size of a data field. 2425 2426 2427 @return: X real size value. 2428 2429 """ 2430 return None
2431 - def get_yreal( ):
2432 """ 2433 Gets the Y real (physical) size of a data field. 2434 2435 2436 @return: Y real size value. 2437 2438 """ 2439 return None
2440 - def set_xreal( xreal ):
2441 """ 2442 Sets X real (physical) size value of a data field. 2443 2444 @param xreal: New X real size value. I{(float)} 2445 @return: 2446 """ 2447 return None
2448 - def set_yreal( yreal ):
2449 """ 2450 Sets Y real (physical) size value of a data field. 2451 2452 @param yreal: New Y real size value. I{(float)} 2453 @return: 2454 """ 2455 return None
2456 - def get_xoffset( ):
2457 """ 2458 Gets the X offset of data field origin. 2459 2460 2461 @return: X offset value. 2462 2463 """ 2464 return None
2465 - def get_yoffset( ):
2466 """ 2467 Gets the Y offset of data field origin. 2468 2469 2470 @return: Y offset value. 2471 2472 """ 2473 return None
2474 - def set_xoffset( xoff ):
2475 """ 2476 Sets the X offset of a data field origin. 2477 2478 Note offsets don't affect any calculation, nor functions like 2479 L{DataField.rotj}(). 2480 2481 @param xoff: New X offset value. I{(float)} 2482 @return: 2483 """ 2484 return None
2485 - def set_yoffset( yoff ):
2486 """ 2487 Sets the Y offset of a data field origin. 2488 2489 Note offsets don't affect any calculation, nor functions like 2490 L{DataField.rtoi}(). 2491 2492 @param yoff: New Y offset value. I{(float)} 2493 @return: 2494 """ 2495 return None
2496 - def get_si_unit_xy( ):
2497 """ 2498 Returns lateral SI unit of a data field. 2499 2500 2501 @return: SI unit corresponding to the lateral (XY) dimensions of the data 2502 field. Its reference count is not incremented. 2503 2504 """ 2505 return None
2506 - def get_si_unit_z( ):
2507 """ 2508 Returns value SI unit of a data field. 2509 2510 2511 @return: SI unit corresponding to the "height" (Z) dimension of the data 2512 field. Its reference count is not incremented. 2513 2514 """ 2515 return None
2516 - def set_si_unit_xy( si_unit ):
2517 """ 2518 Sets the SI unit corresponding to the lateral (XY) dimensions of a data 2519 field. 2520 2521 It does not assume a reference on B{C{si_unit}}, instead it adds its own 2522 reference. 2523 2524 @param si_unit: SI unit to be set. I{(L{SIUnit})} 2525 @return: 2526 """ 2527 return None
2528 - def set_si_unit_z( si_unit ):
2529 """ 2530 Sets the SI unit corresponding to the "height" (Z) dimension of a data 2531 field. 2532 2533 It does not assume a reference on B{C{si_unit}}, instead it adds its own 2534 reference. 2535 2536 @param si_unit: SI unit to be set. I{(L{SIUnit})} 2537 @return: 2538 """ 2539 return None
2540 - def UNIMPLEMENTED_get_value_format_xy( style , format ):
2541 """ 2542 Finds value format good for displaying coordinates of a data field. 2543 2544 2545 @param style: Unit format style. I{(SIUnitFormatStyle)} 2546 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 2547 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 2548 is returned, otherwise (modified) B{C{format}} itself is returned. 2549 2550 """ 2551 return None
2552 - def UNIMPLEMENTED_get_value_format_z( style , format ):
2553 """ 2554 Finds value format good for displaying values of a data field. 2555 2556 2557 @param style: Unit format style. I{(SIUnitFormatStyle)} 2558 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 2559 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 2560 is returned, otherwise (modified) B{C{format}} itself is returned. 2561 2562 """ 2563 return None
2564 - def copy_units_to_data_line( data_line ):
2565 """ 2566 Sets lateral and value units of a data line to match a data field. 2567 2568 @param data_line: A data line to set units of. I{(L{DataLine})} 2569 @return: 2570 """ 2571 return None
2572 - def itor( row ):
2573 """ 2574 Transforms vertical pixel coordinate to real (physical) Y coordinate. 2575 2576 That is it maps range [0..y-resolution] to range [0..real-y-size]. 2577 It is not suitable for conversion of matrix indices to physical coordinates, 2578 you have to use L{DataField.itor}(B{C{data_field}}, B{C{row}} + 0.5) for that. 2579 2580 2581 @param row: Vertical pixel coordinate. I{(float)} 2582 @return: Real Y coordinate. 2583 2584 """ 2585 return None
2586 - def jtor( col ):
2587 """ 2588 Transforms horizontal pixel coordinate to real (physical) X coordinate. 2589 2590 That is it maps range [0..x-resolution] to range [0..real-x-size]. 2591 It is not suitable for conversion of matrix indices to physical coordinates, 2592 you have to use L{DataField.jtor}(B{C{data_field}}, B{C{col}} + 0.5) for that. 2593 2594 2595 @param col: Horizontal pixel coordinate. I{(float)} 2596 @return: Real X coordinate. 2597 2598 """ 2599 return None
2600 - def rtoi( realy ):
2601 """ 2602 Transforms real (physical) Y coordinate to row. 2603 2604 That is it maps range [0..real-y-size] to range [0..y-resolution]. 2605 2606 2607 @param realy: Real (physical) Y coordinate. I{(float)} 2608 @return: Vertical pixel coodinate. 2609 2610 """ 2611 return None
2612 - def rtoj( realx ):
2613 """ 2614 Transforms real (physical) X coordinate to column. 2615 2616 That is it maps range [0..real-x-size] to range [0..x-resolution]. 2617 2618 2619 @param realx: Real (physical) X coodinate. I{(float)} 2620 @return: Horizontal pixel coordinate. 2621 2622 """ 2623 return None
2624 - def get_val( col , row ):
2625 """ 2626 Gets value at given position in a data field. 2627 2628 Do not access data with this function inside inner loops, it's slow. 2629 Get the raw data buffer with L{DataField.get_data_const}() and access it 2630 directly instead. 2631 2632 2633 @param col: Column index. I{(int)} 2634 @param row: Row index. I{(int)} 2635 @return: Value at (B{C{col}}, B{C{row}}). 2636 2637 """ 2638 return None
2639 - def set_val( col , row , value ):
2640 """ 2641 Sets value at given position in a data field. 2642 2643 Do not set data with this function inside inner loops, it's slow. Get the 2644 raw data buffer with L{DataField.get_data}() and write to it directly 2645 instead. 2646 2647 @param col: Column index. I{(int)} 2648 @param row: Row index. I{(int)} 2649 @param value: Value to set. I{(float)} 2650 @return: 2651 """ 2652 return None
2653 - def get_dval( x , y , interpolation ):
2654 """ 2655 Gets interpolated value at arbitrary data field point indexed by pixel 2656 coordinates. 2657 2658 Note pixel values are centered in pixels, so to get the same 2659 value as L{DataField.get_val}(B{C{data_field}}, B{C{j}}, B{C{i}}) returns, 2660 it's necessary to add 0.5: 2661 L{DataField.get_dval}(B{C{data_field}}, B{C{j}}+0.5, B{C{i}}+0.5, B{C{interpolation}}). 2662 2663 See also L{DataField.get_dval_real}() that does the same, but takes 2664 real coordinates. 2665 2666 2667 @param x: Horizontal position in pixel units, in range [0, x-resolution]. I{(float)} 2668 @param y: Vertical postition in pixel units, in range [0, y-resolution]. I{(float)} 2669 @param interpolation: Interpolation method to be used. I{(InterpolationType)} 2670 @return: Interpolated value at position (B{C{x}},B{C{y}}). 2671 2672 """ 2673 return None
2674 - def get_dval_real( x , y , interpolation ):
2675 """ 2676 Gets interpolated value at arbitrary data field point indexed by real 2677 coordinates. 2678 2679 See also L{DataField.get_dval}() that does the same, but takes pixel 2680 coordinates. 2681 2682 2683 @param x: X postion in real coordinates. I{(float)} 2684 @param y: Y postition in real coordinates. I{(float)} 2685 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2686 @return: Value at position (B{C{x}},B{C{y}}). 2687 2688 """ 2689 return None
2690 - def rotate( angle , interpolation ):
2691 """ 2692 Rotates a data field by a given angle. 2693 2694 Values that get outside of data field by the rotation are lost. 2695 Undefined values from outside of data field that get inside are set to 2696 data field minimum value. 2697 2698 @param angle: Rotation angle (in radians). I{(float)} 2699 @param interpolation: Interpolation method to use. I{(InterpolationType)} 2700 @return: 2701 """ 2702 return None
2703 - def invert( x , y , z ):
2704 """ 2705 Reflects amd/or inverts a data field. 2706 2707 In the case of value reflection, it's inverted about the mean value. 2708 2709 @param x: B{C{True}} to reflect about X axis (i.e., vertically). I{(bool)} 2710 @param y: B{C{True}} to reflect about Y axis (i.e., horizontally). I{(bool)} 2711 @param z: B{C{True}} to invert in Z direction (i.e., invert values). I{(bool)} 2712 @return: 2713 """ 2714 return None
2715 - def fill( value ):
2716 """ 2717 Fills a data field with given value. 2718 2719 @param value: Value to be entered. I{(float)} 2720 @return: 2721 """ 2722 return None
2723 - def clear( ):
2724 """ 2725 Fills a data field with zeroes. 2726 2727 @return: 2728 """ 2729 return None
2730 - def multiply( value ):
2731 """ 2732 Multiplies all values in a data field by given value. 2733 2734 @param value: Value to multiply B{C{data_field}} with. I{(float)} 2735 @return: 2736 """ 2737 return None
2738 - def add( value ):
2739 """ 2740 Adds given value to all values in a data field. 2741 2742 @param value: Value to be added to data field values. I{(float)} 2743 @return: 2744 """ 2745 return None
2746 - def area_fill( col , row , width , height , value ):
2747 """ 2748 Fills a rectangular part of a data field with given value. 2749 2750 @param col: Upper-left column coordinate. I{(int)} 2751 @param row: Upper-left row coordinate. I{(int)} 2752 @param width: Area width (number of columns). I{(int)} 2753 @param height: Area height (number of rows). I{(int)} 2754 @param value: Value to be entered I{(float)} 2755 @return: 2756 """ 2757 return None
2758 - def area_clear( col , row , width , height ):
2759 """ 2760 Fills a rectangular part of a data field with zeroes. 2761 2762 @param col: Upper-left column coordinate. I{(int)} 2763 @param row: Upper-left row coordinate. I{(int)} 2764 @param width: Area width (number of columns). I{(int)} 2765 @param height: Area height (number of rows). I{(int)} 2766 @return: 2767 """ 2768 return None
2769 - def area_multiply( col , row , width , height , value ):
2770 """ 2771 Multiplies values in a rectangular part of a data field by given value 2772 2773 @param col: Upper-left column coordinate. I{(int)} 2774 @param row: Upper-left row coordinate. I{(int)} 2775 @param width: Area width (number of columns). I{(int)} 2776 @param height: Area height (number of rows). I{(int)} 2777 @param value: Value to multiply area with. I{(float)} 2778 @return: 2779 """ 2780 return None
2781 - def area_add( col , row , width , height , value ):
2782 """ 2783 Adds given value to all values in a rectangular part of a data field. 2784 2785 @param col: Upper-left column coordinate. I{(int)} 2786 @param row: Upper-left row coordinate. I{(int)} 2787 @param width: Area width (number of columns). I{(int)} 2788 @param height: Area height (number of rows). I{(int)} 2789 @param value: Value to be added to area values. I{(float)} 2790 @return: 2791 """ 2792 return None
2793 - def get_profile( data_line , scol , srow , ecol , erow , res , thickness , interpolation ):
2794 """ 2795 Extracts a possibly averaged profile from data field to a data line. 2796 2797 2798 @param data_line: A data line. It will be resized to B{C{res}} samples. It is 2799 possible to pass B{C{NULL}} to instantiate and return a new 2800 B{C{DataLine}}. I{(L{DataLine})} 2801 @param scol: The column the line starts at (inclusive). I{(int)} 2802 @param srow: The row the line starts at (inclusive). I{(int)} 2803 @param ecol: The column the line ends at (inclusive). I{(int)} 2804 @param erow: The row the line ends at (inclusive). I{(int)} 2805 @param res: Requested resolution of data line (the number of samples to take). 2806 If nonpositive, data line resolution is chosen to match B{C{data_field}}'s. I{(int)} 2807 @param thickness: Thickness of line to be averaged. I{(int)} 2808 @param interpolation: Interpolation type to use. I{(InterpolationType)} 2809 @return: B{C{data_line}} itself if it was not B{C{NULL}}, otherwise a newly created 2810 data line. 2811 2812 """ 2813 return None
2814 - def get_row( data_line , row ):
2815 """ 2816 Extracts a data field row into a data line. 2817 2818 @param data_line: A data line. It will be resized to width ot B{C{data_field}}. I{(L{DataLine})} 2819 @param row: Row index. I{(int)} 2820 @return: 2821 """ 2822 return None
2823 - def get_column( data_line , col ):
2824 """ 2825 Extracts a data field column into a data line. 2826 2827 @param data_line: A data line. It will be resized to height of B{C{data_field}}. I{(L{DataLine})} 2828 @param col: Column index. I{(int)} 2829 @return: 2830 """ 2831 return None
2832 - def set_row( data_line , row ):
2833 """ 2834 Sets a row in the data field to values of a data line. 2835 2836 Data line length must be equal to width of data field. 2837 2838 @param data_line: A data line. I{(L{DataLine})} 2839 @param row: Row index. I{(int)} 2840 @return: 2841 """ 2842 return None
2843 - def set_column( data_line , col ):
2844 """ 2845 Sets a column in the data field to values of a data line. 2846 2847 Data line length must be equal to height of data field. 2848 2849 @param data_line: A data line. I{(L{DataLine})} 2850 @param col: Column index. I{(int)} 2851 @return: 2852 """ 2853 return None
2854 - def get_row_part( data_line , row , _from , to ):
2855 """ 2856 Extracts part of a data field row into a data line. 2857 2858 @param data_line: A data line. It will be resized to the row part width. I{(L{DataLine})} 2859 @param row: Row index. I{(int)} 2860 @param _from: Start column index. I{(int)} 2861 @param to: End column index + 1. I{(int)} 2862 @return: 2863 """ 2864 return None
2865 - def get_column_part( data_line , col , _from , to ):
2866 """ 2867 Extracts part of a data field column into a data line. 2868 2869 @param data_line: A data line. It will be resized to the column part height. I{(L{DataLine})} 2870 @param col: Column index. I{(int)} 2871 @param _from: Start row index. I{(int)} 2872 @param to: End row index + 1. I{(int)} 2873 @return: 2874 """ 2875 return None
2876 - def set_row_part( data_line , row , _from , to ):
2877 """ 2878 Puts a data line into a data field row. 2879 2880 If data line length differs from B{C{to}}-B{C{from}}, it is resampled to this length. 2881 2882 @param data_line: A data line. I{(L{DataLine})} 2883 @param row: Row index. I{(int)} 2884 @param _from: Start row index. I{(int)} 2885 @param to: End row index + 1. I{(int)} 2886 @return: 2887 """ 2888 return None
2889 - def set_column_part( data_line , col , _from , to ):
2890 """ 2891 Puts a data line into data field column. 2892 2893 If data line length differs from B{C{to}}-B{C{from}}, it is resampled to this length. 2894 2895 @param data_line: A data line. I{(L{DataLine})} 2896 @param col: Column index. I{(int)} 2897 @param _from: Start row index. I{(int)} 2898 @param to: End row index + 1. I{(int)} 2899 @return: 2900 """ 2901 return None
2902 - def get_xder( col , row ):
2903 """ 2904 Computes central derivative in X direction. 2905 2906 On border points, one-side derivative is returned. 2907 2908 2909 @param col: Column index. I{(int)} 2910 @param row: Row index. I{(int)} 2911 @return: Derivative in X direction. 2912 2913 """ 2914 return None
2915 - def get_yder( col , row ):
2916 """ 2917 Computes central derivative in Y direction. 2918 2919 On border points, one-side derivative is returned. 2920 2921 Note the derivative is for legacy reasons calulcated for the opposite 2922 y direction than is usual elsewhere in Gwyddion, i.e. if values increase 2923 with increasing row number, the returned value is negative. 2924 2925 2926 @param col: Column index. I{(int)} 2927 @param row: Row index. I{(int)} 2928 @return: Derivative in Y direction 2929 2930 """ 2931 return None
2932 - def get_angder( col , row , theta ):
2933 """ 2934 Computes derivative in direction specified by given angle. 2935 2936 2937 @param col: Column index. I{(int)} 2938 @param row: Row index. I{(int)} 2939 @param theta: Angle defining the direction (in radians, counterclockwise). I{(float)} 2940 @return: Derivative in direction given by angle B{C{theta}}. 2941 2942 """ 2943 return None
2944 - def xdwt( wt_coefs , direction , minsize ):
2945 """ 2946 Performs steps of the X-direction image wavelet decomposition. 2947 2948 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 2949 B{C{minsize}} = B{C{dfield}}->xres/2 to perform one step of decomposition 2950 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 2951 2952 2953 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 2954 @param direction: Transform direction. I{(TransformDirection)} 2955 @param minsize: size of minimal transform result block I{(int)} 2956 @return: 2957 """ 2958 return None
2959 - def ydwt( wt_coefs , direction , minsize ):
2960 """ 2961 Performs steps of the Y-direction image wavelet decomposition. 2962 2963 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 2964 B{C{minsize}} = B{C{dfield}}->yres/2 to perform one step of decomposition 2965 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 2966 2967 2968 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 2969 @param direction: Transform direction. I{(TransformDirection)} 2970 @param minsize: size of minimal transform result block I{(int)} 2971 @return: 2972 """ 2973 return None
2974 - def dwt( wt_coefs , direction , minsize ):
2975 """ 2976 Performs steps of the 2D image wavelet decomposition. 2977 2978 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 2979 B{C{minsize}} = B{C{dfield}}->xres/2 to perform one step of decomposition 2980 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 2981 2982 2983 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 2984 @param direction: Transform direction. I{(TransformDirection)} 2985 @param minsize: size of minimal transform result block I{(int)} 2986 @return: 2987 """ 2988 return None
2989 - def dwt_mark_anisotropy( mask , wt_coefs , ratio , lowlimit ):
2990 return None
2991 - def elliptic_area_fill( col , row , width , height , value ):
2992 """ 2993 Fills an elliptic region of a data field with given value. 2994 2995 The elliptic region is defined by its bounding box which must be completely 2996 contained in the data field. 2997 2998 2999 @param col: Upper-left bounding box column coordinate. I{(int)} 3000 @param row: Upper-left bounding box row coordinate. I{(int)} 3001 @param width: Bounding box width (number of columns). I{(int)} 3002 @param height: Bounding box height (number of rows). I{(int)} 3003 @param value: Value to be entered. I{(float)} 3004 @return: The number of filled values. 3005 3006 """ 3007 return None
3008 - def elliptic_area_extract( col , row , width , height , data ):
3009 """ 3010 Extracts values from an elliptic region of a data field. 3011 3012 The elliptic region is defined by its bounding box which must be completely 3013 contained in the data field. 3014 3015 3016 @param col: Upper-left bounding box column coordinate. I{(int)} 3017 @param row: Upper-left bounding box row coordinate. I{(int)} 3018 @param width: Bounding box width (number of columns). I{(int)} 3019 @param height: Bounding box height (number of rows). I{(int)} 3020 @param data: Location to store the extracted values to. Its size has to be 3021 sufficient to contain all the extracted values. As a conservative 3022 estimate B{C{width}}*B{C{height}} can be used, or the 3023 size can be calculated with L{DataField.get_elliptic_area_size}(). I{(gdouble*)} 3024 @return: The number of extracted values. 3025 3026 """ 3027 return None
3028 - def elliptic_area_unextract( col , row , width , height , data ):
3029 """ 3030 Puts values back to an elliptic region of a data field. 3031 3032 The elliptic region is defined by its bounding box which must be completely 3033 contained in the data field. 3034 3035 This method does the reverse of L{DataField.elliptic_area_extract}() 3036 allowing to implement pixel-wise filters on elliptic areas. Values from 3037 B{C{data}} are put back to the same positions 3038 L{DataField.elliptic_area_extract}() took them from. 3039 3040 @param col: Upper-left bounding box column coordinate. I{(int)} 3041 @param row: Upper-left bounding box row coordinate. I{(int)} 3042 @param width: Bounding box width (number of columns). I{(int)} 3043 @param height: Bounding box height (number of rows). I{(int)} 3044 @param data: The values to put back. It must be the same array as in previous 3045 L{DataField.elliptic_area_extract}(). I{(const-gdouble*)} 3046 @return: 3047 """ 3048 return None
3049 - def circular_area_fill( col , row , radius , value ):
3050 """ 3051 Fills an elliptic region of a data field with given value. 3052 3053 3054 @param col: Row index of circular area centre. I{(int)} 3055 @param row: Column index of circular area centre. I{(int)} 3056 @param radius: Circular area radius (in pixels). Any value is allowed, although 3057 to get areas that do not deviate from true circles after 3058 pixelization too much, half-integer values are recommended, 3059 integer values are NOT recommended. I{(float)} 3060 @param value: Value to be entered. I{(float)} 3061 @return: The number of filled values. 3062 3063 """ 3064 return None
3065 - def circular_area_extract( col , row , radius , data ):
3066 """ 3067 Extracts values from a circular region of a data field. 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). See 3073 L{DataField.circular_area_extract_with_pos}() for caveats. I{(float)} 3074 @param data: Location to store the extracted values to. See 3075 L{DataField.circular_area_extract_with_pos}(). I{(gdouble*)} 3076 @return: The number of extracted values. It can be zero when the inside of 3077 the circle does not intersect with the data field. 3078 3079 """ 3080 return None
3081 - def UNIMPLEMENTED_circular_area_extract_with_pos( col , row , radius , data , xpos , ypos ):
3082 """ 3083 Extracts values with positions from a circular region of a data field. 3084 3085 The row and column indices stored to B{C{xpos}} and B{C{ypos}} are relative to the 3086 area centre, i.e. to (B{C{col}}, B{C{row}}). The central pixel will therefore have 3087 0 at the corresponding position in both B{C{xpos}} and B{C{ypos}}. 3088 3089 Since: 2.2 3090 3091 @param col: Row index of circular area centre. I{(int)} 3092 @param row: Column index of circular area centre. I{(int)} 3093 @param radius: Circular area radius (in pixels). Any value is allowed, although 3094 to get areas that do not deviate from true circles after 3095 pixelization too much, half-integer values are recommended, 3096 integer radii are NOT recommended. I{(float)} 3097 @param data: Location to store the extracted values to. Its size has to be 3098 sufficient to contain all the extracted values. As a conservative 3099 estimate (2*floor(B{C{radius}})+1)^2 can be used, or the size can be 3100 calculated with L{DataField.get_circular_area_size}(). I{(gdouble*)} 3101 @param xpos: Location to store relative column indices of values in B{C{data}} to, 3102 the size requirements are the same as for B{C{data}}. I{(int)} 3103 @param ypos: Location to store relative tow indices of values in B{C{data}} to, 3104 the size requirements are the same as for B{C{data}}. I{(int)} 3105 @return: The number of extracted values. It can be zero when the inside of 3106 the circle does not intersect with the data field. 3107 3108 3109 """ 3110 return None
3111 - def circular_area_unextract( col , row , radius , data ):
3112 """ 3113 Puts values back to a circular region of a data field. 3114 3115 This method does the reverse of L{DataField.circular_area_extract}() 3116 allowing to implement pixel-wise filters on circular areas. Values from 3117 B{C{data}} are put back to the same positions 3118 L{DataField.circular_area_extract}() took them from. 3119 3120 @param col: Row index of circular area centre. I{(int)} 3121 @param row: Column index of circular area centre. I{(int)} 3122 @param radius: Circular area radius (in pixels). I{(float)} 3123 @param data: The values to put back. It must be the same array as in previous 3124 L{DataField.circular_area_unextract}(). I{(const-gdouble*)} 3125 @return: 3126 """ 3127 return None
3128 - def normalize( ):
3129 """ 3130 Normalizes data in a data field to range 0.0 to 1.0. 3131 3132 It is equivalent to L{DataField.renormalize}(B{C{data_field}}, 1.0, 0.0); 3133 3134 If B{C{data_field}} is filled with only one value, it is changed to 0.0. 3135 3136 @return: 3137 """ 3138 return None
3139 - def renormalize( range , offset ):
3140 """ 3141 Transforms data in a data field with first linear function to given range. 3142 3143 When B{C{range}} is positive, the new data range is (B{C{offset}}, B{C{offset}}+B{C{range}}); 3144 when B{C{range}} is negative, the new data range is (B{C{offset}}-B{C{range}}, B{C{offset}}). 3145 In neither case the data are flipped, negative range only means different 3146 selection of boundaries. 3147 3148 When B{C{range}} is zero, this method is equivalent to 3149 L{DataField.fill}(B{C{data_field}}, B{C{offset}}). 3150 3151 @param range: New data interval size. I{(float)} 3152 @param offset: New data interval offset. I{(float)} 3153 @return: 3154 """ 3155 return None
3156 - def threshold( threshval , bottom , top ):
3157 """ 3158 Tresholds values of a data field. 3159 3160 Values smaller than B{C{threshold}} are set to value B{C{bottom}}, values higher 3161 than B{C{threshold}} or equal to it are set to value B{C{top}} 3162 3163 3164 @param threshval: Threshold value. I{(float)} 3165 @param bottom: Lower replacement value. I{(float)} 3166 @param top: Upper replacement value. I{(float)} 3167 @return: The total number of values above threshold. 3168 3169 """ 3170 return None
3171 - def area_threshold( col , row , width , height , threshval , bottom , top ):
3172 """ 3173 Tresholds values of a rectangular part of a data field. 3174 3175 Values smaller than B{C{threshold}} are set to value B{C{bottom}}, values higher 3176 than B{C{threshold}} or equal to it are set to value B{C{top}} 3177 3178 3179 @param col: Upper-left column coordinate. I{(int)} 3180 @param row: Upper-left row coordinate. I{(int)} 3181 @param width: Area width (number of columns). I{(int)} 3182 @param height: Area height (number of rows). I{(int)} 3183 @param threshval: Threshold value. I{(float)} 3184 @param bottom: Lower replacement value. I{(float)} 3185 @param top: Upper replacement value. I{(float)} 3186 @return: The total number of values above threshold. 3187 3188 """ 3189 return None
3190 - def clamp( bottom , top ):
3191 """ 3192 Limits data field values to a range. 3193 3194 3195 @param bottom: Lower limit value. I{(float)} 3196 @param top: Upper limit value. I{(float)} 3197 @return: The number of changed values, i.e., values that were outside 3198 [B{C{bottom}}, B{C{top}}]. 3199 3200 """ 3201 return None
3202 - def area_clamp( col , row , width , height , bottom , top ):
3203 """ 3204 Limits values in a rectangular part of a data field to a range. 3205 3206 3207 @param col: Upper-left column coordinate. I{(int)} 3208 @param row: Upper-left row coordinate. I{(int)} 3209 @param width: Area width (number of columns). I{(int)} 3210 @param height: Area height (number of rows). I{(int)} 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_gather( result , buffer , hsize , vsize , average , col , row , width , height ):
3219 """ 3220 Sums or averages values in reactangular areas around each sample in a data 3221 field. 3222 3223 When the gathered area extends out of calculation area, only samples from 3224 their intersection are taken into the local sum (or average). 3225 3226 There are no restrictions on values of B{C{hsize}} and B{C{vsize}} with regard to 3227 B{C{width}} and B{C{height}}, but they have to be positive. 3228 3229 The result is calculated by the means of two-dimensional rolling sums. 3230 One one hand it means the calculation time depends linearly on 3231 (B{C{width}} + B{C{hsize}})*(B{C{height}} + B{C{vsize}}) instead of 3232 B{C{width}}*B{C{hsize}}*B{C{height}}*B{C{vsize}}. On the other hand it means absolute rounding 3233 errors of all output values are given by the largest input values, that is 3234 relative precision of results small in absolute value may be poor. 3235 3236 @param result: A data field to put the result to, it may be B{C{data_field}} itself. I{(L{DataField})} 3237 @param buffer: A data field to use as a scratch area, its size must be at least 3238 B{C{width}}*B{C{height}}. May be B{C{NULL}} to allocate a private temporary 3239 buffer. I{(L{DataField})} 3240 @param col: Upper-left column coordinate. I{(int)} 3241 @param row: Upper-left row coordinate. I{(int)} 3242 @param width: Area width (number of columns). I{(int)} 3243 @param height: Area height (number of rows). I{(int)} 3244 @param hsize: Horizontal size of gathered area. The area is centered around 3245 each sample if B{C{hsize}} is odd, it extends one pixel more to the 3246 right if B{C{hsize}} is even. I{(int)} 3247 @param vsize: Vertical size of gathered area. The area is centered around 3248 each sample if B{C{vsize}} is odd, it extends one pixel more down 3249 if B{C{vsize}} is even. I{(int)} 3250 @param average: B{C{True}} to divide resulting sums by the number of involved samples 3251 to get averages instead of sums. I{(bool)} 3252 @return: 3253 """ 3254 return None
3255 - def convolve( kernel_field ):
3256 """ 3257 Convolves a data field with given kernel. 3258 3259 @param kernel_field: Kenrel field to convolve B{C{data_field}} with. I{(L{DataField})} 3260 @return: 3261 """ 3262 return None
3263 - def area_convolve( kernel_field , col , row , width , height ):
3264 """ 3265 Convolves a rectangular part of a data field with given kernel. 3266 3267 @param kernel_field: Kenrel field to convolve B{C{data_field}} with. I{(L{DataField})} 3268 @param col: Upper-left column coordinate. I{(int)} 3269 @param row: Upper-left row coordinate. I{(int)} 3270 @param width: Area width (number of columns). I{(int)} 3271 @param height: Area height (number of rows). I{(int)} 3272 @return: 3273 """ 3274 return None
3275 - def convolve_1d( kernel_line , orientation ):
3276 """ 3277 Convolves a data field with given linear kernel. 3278 3279 Since: 2.4 3280 3281 @param kernel_line: Kenrel line to convolve B{C{data_field}} with. I{(L{DataLine})} 3282 @param orientation: Filter orientation (see L{DataField.area_convolve_1d}()). I{(Orientation)} 3283 @return: 3284 """ 3285 return None
3286 - def area_convolve_1d( kernel_line , orientation , col , row , width , height ):
3287 """ 3288 Convolves a rectangular part of a data field with given linear kernel. 3289 3290 For large separable kernels it can be more efficient to use a sequence of 3291 horizontal and vertical convolutions instead one 2D convolution. 3292 3293 Since: 2.4 3294 3295 @param kernel_line: Kernel line to convolve B{C{data_field}} with. I{(L{DataLine})} 3296 @param orientation: Filter orientation (B{C{ORIENTATION_HORIZONTAL}} for 3297 row-wise convolution, B{C{ORIENTATION_VERTICAL}} for 3298 column-wise convolution). I{(Orientation)} 3299 @param col: Upper-left column coordinate. I{(int)} 3300 @param row: Upper-left row coordinate. I{(int)} 3301 @param width: Area width (number of columns). I{(int)} 3302 @param height: Area height (number of rows). I{(int)} 3303 @return: 3304 """ 3305 return None
3306 - def filter_median( size ):
3307 """ 3308 Filters a data field with median filter. 3309 3310 @param size: Size of area to take median of. I{(int)} 3311 @return: 3312 """ 3313 return None
3314 - def area_filter_median( size , col , row , width , height ):
3315 """ 3316 Filters a rectangular part of a data field with median filter. 3317 3318 @param size: Size of area to take median of. I{(int)} 3319 @param col: Upper-left column coordinate. I{(int)} 3320 @param row: Upper-left row coordinate. I{(int)} 3321 @param width: Area width (number of columns). I{(int)} 3322 @param height: Area height (number of rows). I{(int)} 3323 @return: 3324 """ 3325 return None
3326 - def filter_mean( size ):
3327 """ 3328 Filters a data field with mean filter of size B{C{size}}. 3329 3330 @param size: Averaged area size. I{(int)} 3331 @return: 3332 """ 3333 return None
3334 - def area_filter_mean( size , col , row , width , height ):
3335 """ 3336 Filters a rectangular part of a data field with mean filter of size B{C{size}}. 3337 3338 This method is a simple L{DataField.area_gather}() wrapper. 3339 3340 @param size: Averaged area size. I{(int)} 3341 @param col: Upper-left column coordinate. I{(int)} 3342 @param row: Upper-left row coordinate. I{(int)} 3343 @param width: Area width (number of columns). I{(int)} 3344 @param height: Area height (number of rows). I{(int)} 3345 @return: 3346 """ 3347 return None
3348 - def filter_conservative( size ):
3349 """ 3350 Filters a data field with conservative denoise filter. 3351 3352 @param size: Filtered area size. I{(int)} 3353 @return: 3354 """ 3355 return None
3356 - def area_filter_conservative( size , col , row , width , height ):
3357 """ 3358 Filters a rectangular part of a data field with conservative denoise filter. 3359 3360 @param size: Filtered area size. I{(int)} 3361 @param col: Upper-left column coordinate. I{(int)} 3362 @param row: Upper-left row coordinate. I{(int)} 3363 @param width: Area width (number of columns). I{(int)} 3364 @param height: Area height (number of rows). I{(int)} 3365 @return: 3366 """ 3367 return None
3368 - def filter_laplacian( ):
3369 """ 3370 Filters a data field with Laplacian filter. 3371 3372 @return: 3373 """ 3374 return None
3375 - def area_filter_laplacian( col , row , width , height ):
3376 """ 3377 Filters a rectangular part of a data field with Laplacian filter. 3378 3379 @param col: Upper-left column coordinate. I{(int)} 3380 @param row: Upper-left row coordinate. I{(int)} 3381 @param width: Area width (number of columns). I{(int)} 3382 @param height: Area height (number of rows). I{(int)} 3383 @return: 3384 """ 3385 return None
3387 """ 3388 Filters a data field with Laplacian of Gaussians filter. 3389 3390 Since: 2.23 3391 3392 @return: 3393 """ 3394 return None
3395 - def area_filter_laplacian_of_gaussians( col , row , width , height ):
3396 """ 3397 Filters a rectangular part of a data field 3398 with Laplacian of Gaussians filter. 3399 3400 Since: 2.23 3401 3402 @param col: Upper-left column coordinate. I{(int)} 3403 @param row: Upper-left row coordinate. I{(int)} 3404 @param width: Area width (number of columns). I{(int)} 3405 @param height: Area height (number of rows). I{(int)} 3406 @return: 3407 """ 3408 return None
3409 - def filter_sobel( orientation ):
3410 """ 3411 Filters a data field with a directional Sobel filter. 3412 3413 @param orientation: Filter orientation. I{(Orientation)} 3414 @return: 3415 """ 3416 return None
3417 - def area_filter_sobel( orientation , col , row , width , height ):
3418 """ 3419 Filters a rectangular part of a data field with a directional Sobel filter. 3420 3421 @param orientation: Filter orientation. I{(Orientation)} 3422 @param col: Upper-left column coordinate. I{(int)} 3423 @param row: Upper-left row coordinate. I{(int)} 3424 @param width: Area width (number of columns). I{(int)} 3425 @param height: Area height (number of rows). I{(int)} 3426 @return: 3427 """ 3428 return None
3429 - def filter_sobel_total( ):
3430 """ 3431 Filters a data field with total Sobel filter. 3432 3433 Since: 2.31 3434 3435 @return: 3436 """ 3437 return None
3438 - def filter_prewitt( orientation ):
3439 """ 3440 Filters a data field with Prewitt filter. 3441 3442 @param orientation: Filter orientation. I{(Orientation)} 3443 @return: 3444 """ 3445 return None
3446 - def area_filter_prewitt( orientation , col , row , width , height ):
3447 """ 3448 Filters a rectangular part of a data field with a directional Prewitt 3449 filter. 3450 3451 @param orientation: Filter orientation. I{(Orientation)} 3452 @param col: Upper-left column coordinate. I{(int)} 3453 @param row: Upper-left row coordinate. I{(int)} 3454 @param width: Area width (number of columns). I{(int)} 3455 @param height: Area height (number of rows). I{(int)} 3456 @return: 3457 """ 3458 return None
3459 - def filter_prewitt_total( ):
3460 """ 3461 Filters a data field with total Prewitt filter. 3462 3463 Since: 2.31 3464 3465 @return: 3466 """ 3467 return None
3468 - def filter_slope( xder , yder ):
3469 """ 3470 Calculates x and y derivaties for an entire field. 3471 3472 The derivatives are calculated as the simple symmetrical differences (in 3473 physical units, not pixel-wise), except at the edges where the differences 3474 are one-sided. 3475 3476 Since: 2.37 3477 3478 @param xder: Data field where the x-derivarive is to be stored, or B{C{NULL}} if you 3479 are only interested in the y-derivarive. I{(L{DataField})} 3480 @param yder: Data field where the y-derivarive is to be stored, or B{C{NULL}} if you 3481 are only interested in the x-derivarive. I{(L{DataField})} 3482 @return: 3483 """ 3484 return None
3485 - def filter_dechecker( ):
3486 """ 3487 Filters a data field with 5x5 checker pattern removal filter. 3488 3489 Since: 2.1 3490 3491 @return: 3492 """ 3493 return None
3494 - def area_filter_dechecker( col , row , width , height ):
3495 """ 3496 Filters a rectangular part of a data field with 5x5 checker pattern removal 3497 filter. 3498 3499 Since: 2.1 3500 3501 @param col: Upper-left column coordinate. I{(int)} 3502 @param row: Upper-left row coordinate. I{(int)} 3503 @param width: Area width (number of columns). I{(int)} 3504 @param height: Area height (number of rows). I{(int)} 3505 @return: 3506 """ 3507 return None
3508 - def filter_gaussian( sigma ):
3509 """ 3510 Filters a data field with a Gaussian filter. 3511 3512 Since: 2.4 3513 3514 @param sigma: The sigma parameter of the Gaussian. I{(float)} 3515 @return: 3516 """ 3517 return None
3518 - def area_filter_gaussian( sigma , col , row , width , height ):
3519 """ 3520 Filters a rectangular part of a data field with a Gaussian filter. 3521 3522 The Gausian is normalized, i.e. it is sum-preserving. 3523 3524 Since: 2.4 3525 3526 @param sigma: The sigma parameter of the Gaussian. I{(float)} 3527 @param col: Upper-left column coordinate. I{(int)} 3528 @param row: Upper-left row coordinate. I{(int)} 3529 @param width: Area width (number of columns). I{(int)} 3530 @param height: Area height (number of rows). I{(int)} 3531 @return: 3532 """ 3533 return None
3534 - def filter_minimum( size ):
3535 """ 3536 Filters a data field with minimum filter. 3537 3538 @param size: Neighbourhood size for minimum search. I{(int)} 3539 @return: 3540 """ 3541 return None
3542 - def area_filter_minimum( size , col , row , width , height ):
3543 """ 3544 Filters a rectangular part of a data field with minimum filter. 3545 3546 This operation is often called erosion filter. 3547 3548 @param size: Neighbourhood size for minimum search. I{(int)} 3549 @param col: Upper-left column coordinate. I{(int)} 3550 @param row: Upper-left row coordinate. I{(int)} 3551 @param width: Area width (number of columns). I{(int)} 3552 @param height: Area height (number of rows). I{(int)} 3553 @return: 3554 """ 3555 return None
3556 - def filter_maximum( size ):
3557 """ 3558 Filters a data field with maximum filter. 3559 3560 @param size: Neighbourhood size for maximum search. I{(int)} 3561 @return: 3562 """ 3563 return None
3564 - def area_filter_maximum( size , col , row , width , height ):
3565 """ 3566 Filters a rectangular part of a data field with maximum filter. 3567 3568 This operation is often called dilation filter. 3569 3570 @param size: Neighbourhood size for maximum search. I{(int)} 3571 @param col: Upper-left column coordinate. I{(int)} 3572 @param row: Upper-left row coordinate. I{(int)} 3573 @param width: Area width (number of columns). I{(int)} 3574 @param height: Area height (number of rows). I{(int)} 3575 @return: 3576 """ 3577 return None
3578 - def filter_rms( size ):
3579 """ 3580 Filters a data field with RMS filter. 3581 3582 @param size: Area size. I{(int)} 3583 @return: 3584 """ 3585 return None
3586 - def area_filter_rms( size , col , row , width , height ):
3587 """ 3588 Filters a rectangular part of a data field with RMS filter of size B{C{size}}. 3589 3590 RMS filter computes root mean square in given area. 3591 3592 @param size: Area size. I{(int)} 3593 @param col: Upper-left column coordinate. I{(int)} 3594 @param row: Upper-left row coordinate. I{(int)} 3595 @param width: Area width (number of columns). I{(int)} 3596 @param height: Area height (number of rows). I{(int)} 3597 @return: 3598 """ 3599 return None
3600 - def filter_kuwahara( ):
3601 """ 3602 Filters a data field with Kuwahara filter. 3603 3604 @return: 3605 """ 3606 return None
3607 - def area_filter_kuwahara( col , row , width , height ):
3608 """ 3609 Filters a rectangular part of a data field with a Kuwahara 3610 (edge-preserving smoothing) filter. 3611 3612 @param col: Upper-left column coordinate. I{(int)} 3613 @param row: Upper-left row coordinate. I{(int)} 3614 @param width: Area width (number of columns). I{(int)} 3615 @param height: Area height (number of rows). I{(int)} 3616 @return: 3617 """ 3618 return None
3619 - def filter_canny( threshold ):
3620 """ 3621 Filters a rectangular part of a data field with canny edge detector filter. 3622 3623 @param threshold: Slope detection threshold (range 0..1). I{(float)} 3624 @return: 3625 """ 3626 return None
3627 - def shade( target_field , theta , phi ):
3628 """ 3629 Shades a data field. 3630 3631 @param target_field: A data field to put the shade to. It will be resized to 3632 match B{C{data_field}}. I{(L{DataField})} 3633 @param theta: Shading angle (in radians, from north pole). I{(float)} 3634 @param phi: Shade orientation in xy plane (in radians, counterclockwise). I{(float)} 3635 @return: 3636 """ 3637 return None
3638 - def filter_harris( y_gradient , result , neighbourhood , alpha ):
3639 return None
3640 - def fractal_partitioning( xresult , yresult , interpolation ):
3641 """ 3642 Computes data for log-log plot by partitioning. 3643 3644 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3645 they will contain corresponding values at each position. 3646 3647 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3648 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3649 @param interpolation: Interpolation type. I{(InterpolationType)} 3650 @return: 3651 """ 3652 return None
3653 - def fractal_cubecounting( xresult , yresult , interpolation ):
3654 """ 3655 Computes data for log-log plot by cube counting. 3656 3657 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3658 they will contain corresponding values at each position. 3659 3660 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3661 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3662 @param interpolation: Interpolation type. I{(InterpolationType)} 3663 @return: 3664 """ 3665 return None
3666 - def fractal_triangulation( xresult , yresult , interpolation ):
3667 """ 3668 Computes data for log-log plot by triangulation. 3669 3670 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3671 they will contain corresponding values at each position. 3672 3673 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3674 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3675 @param interpolation: Interpolation type. I{(InterpolationType)} 3676 @return: 3677 """ 3678 return None
3679 - def fractal_psdf( xresult , yresult , interpolation ):
3680 """ 3681 Computes data for log-log plot by spectral density method. 3682 3683 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 3684 they will contain corresponding values at each position. 3685 3686 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 3687 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 3688 @param interpolation: Interpolation type. I{(InterpolationType)} 3689 @return: 3690 """ 3691 return None
3692 - def fractal_correction( mask_field , interpolation ):
3693 """ 3694 Replaces data under mask with interpolated values using fractal 3695 interpolation. 3696 3697 @param mask_field: Mask of places to be corrected. I{(L{DataField})} 3698 @param interpolation: Interpolation type. I{(InterpolationType)} 3699 @return: 3700 """ 3701 return None
3702 - def grains_mark_curvature( grain_field , threshval , below ):
3703 """ 3704 Marks data that are above/below curvature threshold. 3705 3706 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 3707 @param threshval: Relative curvature threshold, in percents. I{(float)} 3708 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 3709 threshold are marked. I{(bool)} 3710 @return: 3711 """ 3712 return None
3713 - def grains_mark_watershed( grain_field , locate_steps , locate_thresh , locate_dropsize , wshed_steps , wshed_dropsize , prefilter , below ):
3714 """ 3715 Performs watershed algorithm. 3716 3717 @param grain_field: Result of marking (mask). I{(L{DataField})} 3718 @param locate_steps: Locating algorithm steps. I{(int)} 3719 @param locate_thresh: Locating algorithm threshold. I{(int)} 3720 @param locate_dropsize: Locating drop size. I{(float)} 3721 @param wshed_steps: Watershed steps. I{(int)} 3722 @param wshed_dropsize: Watershed drop size. I{(float)} 3723 @param prefilter: Use prefiltering. I{(bool)} 3724 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 3725 @return: 3726 """ 3727 return None
3728 - def grains_remove_grain( col , row ):
3729 """ 3730 Removes one grain at given position. 3731 3732 3733 @param col: Column inside a grain. I{(int)} 3734 @param row: Row inside a grain. I{(int)} 3735 @return: B{C{True}} if a grain was actually removed (i.e., (B{C{col}},B{C{row}}) was 3736 inside a grain). 3737 3738 """ 3739 return None
3740 - def grains_extract_grain( col , row ):
3741 """ 3742 Removes all grains except that one at given position. 3743 3744 If there is no grain at (B{C{col}}, B{C{row}}), all grains are removed. 3745 3746 3747 @param col: Column inside a grain. I{(int)} 3748 @param row: Row inside a grain. I{(int)} 3749 @return: B{C{True}} if a grain remained (i.e., (B{C{col}},B{C{row}}) was inside a grain). 3750 3751 """ 3752 return None
3753 - def grains_remove_by_number( number ):
3754 """ 3755 Removes grain identified by B{C{number}}. 3756 3757 Since: 2.35 3758 3759 @param number: Grain number was filled by L{DataField.number_grains}(). I{(int)} 3760 @return: 3761 """ 3762 return None
3763 - def grains_remove_by_size( size ):
3764 """ 3765 Removes all grains below specified area. 3766 3767 @param size: Grain area threshold, in square pixels. I{(int)} 3768 @return: 3769 """ 3770 return None
3771 - def grains_remove_by_height( grain_field , threshval , below ):
3772 """ 3773 Removes grains that are higher/lower than given threshold value. 3774 3775 @param grain_field: Field of marked grains (mask) I{(L{DataField})} 3776 @param threshval: Relative height threshold, in percents. I{(float)} 3777 @param below: If B{C{True}}, grains below threshold are removed, otherwise grains above 3778 threshold are removed. I{(bool)} 3779 @return: 3780 """ 3781 return None
3783 """ 3784 Removes all grains that touch field borders. 3785 3786 Since: 2.30 3787 3788 @return: 3789 """ 3790 return None
3791 - def UNIMPLEMENTED_grains_watershed_init( grain_field , locate_steps , locate_thresh , locate_dropsize , wshed_steps , wshed_dropsize , prefilter , below ):
3792 """ 3793 Initializes the watershed algorithm. 3794 3795 This iterator reports its state as B{C{WatershedStateType}}. 3796 3797 3798 @param grain_field: Result of marking (mask). I{(L{DataField})} 3799 @param locate_steps: Locating algorithm steps. I{(int)} 3800 @param locate_thresh: Locating algorithm threshold. I{(int)} 3801 @param locate_dropsize: Locating drop size. I{(float)} 3802 @param wshed_steps: Watershed steps. I{(int)} 3803 @param wshed_dropsize: Watershed drop size. I{(float)} 3804 @param prefilter: Use prefiltering. I{(bool)} 3805 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 3806 @return: A new watershed iterator. 3807 3808 """ 3809 return None
3810 - def grains_mark_height( grain_field , threshval , below ):
3811 """ 3812 Marks data that are above/below height threshold. 3813 3814 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 3815 @param threshval: Relative height threshold, in percents. I{(float)} 3816 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 3817 threshold are marked. I{(bool)} 3818 @return: 3819 """ 3820 return None
3821 - def grains_mark_slope( grain_field , threshval , below ):
3822 """ 3823 Marks data that are above/below slope threshold. 3824 3825 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 3826 @param threshval: Relative slope threshold, in percents. I{(float)} 3827 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 3828 threshold are marked. I{(bool)} 3829 @return: 3830 """ 3831 return None
3832 - def grains_add( add_field ):
3833 """ 3834 Adds B{C{add_field}} grains to B{C{grain_field}}. 3835 3836 Note: This function is equivalent to 3837 <literal>L{DataField.max_of_fields}(grain_field, grain_field, add_field);</literal> 3838 and it will be probably removed someday. 3839 3840 @param add_field: Field of marked grains (mask) to be added. I{(L{DataField})} 3841 @return: 3842 """ 3843 return None
3844 - def grains_intersect( intersect_field ):
3845 """ 3846 Performs intersection betweet two grain fields, 3847 result is stored in B{C{grain_field}}. 3848 3849 Note: This function is equivalent to 3850 <literal>L{DataField.min_of_fields}(grain_field, grain_field, intersect_field);</literal> 3851 and it will be probably removed someday. 3852 3853 @param intersect_field: Field of marked grains (mask). I{(L{DataField})} 3854 @return: 3855 """ 3856 return None
3857 - def number_grains( grains ):
3858 """ 3859 Create a tuple of integer grain numbers in the data field representing a 3860 mask. 3861 3862 3863 @return: tuple of grain numbers for each piel 3864 3865 """ 3866 return None
3867 - def UNIMPLEMENTED_get_grain_bounding_boxes( ngrains , grains , bboxes ):
3868 """ 3869 Find bounding boxes of all grains. 3870 3871 Since: 2.3 3872 3873 @param ngrains: The number of grains as returned by 3874 L{DataField.number_grains}(). I{(int)} 3875 @param grains: Grain numbers filled with L{DataField.number_grains}(). I{(const-gint*)} 3876 @param bboxes: Array of size at least 4*(B{C{ngrains}}+1) to fill with grain bounding 3877 boxes (as usual zero does not correspond to any grain, grains 3878 start from 1). The bounding boxes are stored as quadruples of 3879 indices: (xmin, ymin, width, height). It can be B{C{NULL}} to allocate 3880 a new array. I{(gint*)} 3881 @return: Either B{C{bboxes}} (if it was not B{C{NULL}}), or a newly allocated array 3882 of size 4(B{C{ngrains}} + 1). 3883 3884 3885 """ 3886 return None
3887 - def UNIMPLEMENTED_grains_get_distribution( grain_field , distribution , ngrains , grains , quantity , nstats ):
3888 """ 3889 Computes distribution of requested grain characteristics. 3890 3891 Puts number of grains vs. grain value data into B{C{distribution}}, units, scales 3892 and offsets of B{C{distribution}} are updated accordingly. 3893 3894 3895 @param grain_field: Data field (mask) of marked grains. Note if you pass 3896 non-B{C{NULL}} B{C{grains}} all grain information is taken from it and 3897 B{C{grain_field}} can be even B{C{NULL}} then. I{(L{DataField})} 3898 @param distribution: Data line to store grain distribution to. I{(L{DataLine})} 3899 @param grains: Grain numbers filled with L{DataField.number_grains}() if you 3900 have it, or B{C{NULL}} (the function then finds grain numbers itself 3901 which is not efficient for repeated use on the same grain field). I{(const-gint*)} 3902 @param ngrains: The number of grains as returned by 3903 L{DataField.number_grains}(). Ignored in B{C{grains}} is B{C{NULL}}. I{(int)} 3904 @param quantity: The quantity to calculate. I{(GrainQuantity)} 3905 @param nstats: The number of samples to take on the distribution function. If 3906 nonpositive, a suitable resolution is determined automatically. I{(int)} 3907 @return: A data line with the distribution: B{C{distribution}} itself if it was 3908 not B{C{NULL}}, otherwise a newly created B{C{DataLine}} caller must 3909 destroy. If there are no grains, B{C{NULL}} is returned and 3910 B{C{distribution}} is not changed. 3911 3912 """ 3913 return None
3914 - def grains_get_values( values , ngrains , grains , quantity ):
3915 """ 3916 Obtains values of one grain quantity for all grains. 3917 3918 The zeroth value corresponds to the empty space between grains and isn't 3919 meaningful in general. 3920 3921 3922 @param quantity: Grain quantity. I{(GrainQuantity)} 3923 @return: tuple of values of the grain quantity 3924 3925 """ 3926 return None
3927 - def UNIMPLEMENTED_grains_get_quantities( values , quantities , nquantities , ngrains , grains ):
3928 """ 3929 Calculates multiple characteristics of grains simultaneously. 3930 3931 See L{DataField.grains_get_values}() for some discussion. This function 3932 is more efficient if several grain quantities need to be calculated since 3933 L{DataField.grains_get_values}() can do lot of repeated work in such case. 3934 3935 Since: 2.22 3936 3937 @param values: Array of B{C{nquantities}} pointers to blocks of length B{C{ngrains}}+1 to 3938 put the calculated grain values to. Each block corresponds to one 3939 requested quantity. B{C{NULL}} can be passed to allocate and return a 3940 new array. I{(gdouble**)} 3941 @param quantities: Array of B{C{nquantities}} items that specify the requested 3942 B{C{GrainQuantity}} to put to corresponding items in B{C{values}}. 3943 Quantities can repeat. I{(const-GrainQuantity*)} 3944 @param nquantities: The number of requested different grain values. I{(int)} 3945 @param grains: Grain numbers filled with L{DataField.number_grains}(). I{(const-gint*)} 3946 @param ngrains: The number of grains as returned by 3947 L{DataField.number_grains}(). I{(int)} 3948 @return: B{C{values}} itself if it was not B{C{NULL}}, otherwise a newly allocated 3949 array that caller has to free with g_free(), including the 3950 contained arrays. 3951 3952 3953 """ 3954 return None
3955 - def area_grains_tgnd( target_line , col , row , width , height , below , nstats ):
3956 """ 3957 Calculates threshold grain number distribution. 3958 3959 This function is a simple L{DataField.area_grains_tgnd_range}() that 3960 calculates the distribution in the full range. 3961 3962 @param target_line: A data line to store the distribution to. It will be 3963 resampled to the requested width. I{(L{DataLine})} 3964 @param col: Upper-left column coordinate. I{(int)} 3965 @param row: Upper-left row coordinate. I{(int)} 3966 @param width: Area width (number of columns). I{(int)} 3967 @param height: Area height (number of rows). I{(int)} 3968 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 3969 @param nstats: The number of samples to take on the distribution function. If 3970 nonpositive, a suitable resolution is determined automatically. I{(int)} 3971 @return: 3972 """ 3973 return None
3974 - def area_grains_tgnd_range( target_line , col , row , width , height , min , max , below , nstats ):
3975 """ 3976 Calculates threshold grain number distribution in given height range. 3977 3978 This is the number of grains for each of B{C{nstats}} equidistant height 3979 threshold levels. For large B{C{nstats}} this function is much faster than the 3980 equivalent number of L{DataField.grains_mark_height}() calls. 3981 3982 @param target_line: A data line to store the distribution to. It will be 3983 resampled to the requested width. I{(L{DataLine})} 3984 @param col: Upper-left column coordinate. I{(int)} 3985 @param row: Upper-left row coordinate. I{(int)} 3986 @param width: Area width (number of columns). I{(int)} 3987 @param height: Area height (number of rows). I{(int)} 3988 @param min: Minimum threshold value. I{(float)} 3989 @param max: Maximum threshold value. I{(float)} 3990 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 3991 @param nstats: The number of samples to take on the distribution function. If 3992 nonpositive, a suitable resolution is determined automatically. I{(int)} 3993 @return: 3994 """ 3995 return None
3996 - def grains_splash_water( minima , locate_steps , locate_dropsize ):
3997 return None
3999 """ 4000 Performs Euclidean distance transform of a data field with grains. 4001 4002 Each non-zero value will be replaced with Euclidean distance to the grain 4003 boundary, measured in pixels. 4004 4005 Since: 2.36 4006 4007 @return: 4008 """ 4009 return None
4010 - def fill_voids( ):
4011 """ 4012 Fills voids in grains in a data field representing a mask. 4013 4014 Voids in grains are zero pixels in B{C{data_field}} from which no path exists 4015 through other zero pixels to the field boundary. The paths are considered 4016 in 8-connectivity because grains themselves are considered in 4017 4-connectivity. 4018 4019 Since: 2.37 4020 4021 @return: B{C{True}} if any voids were filled at all, B{C{False}} if no change was 4022 made. 4023 4024 4025 """ 4026 return None
4027 - def UNIMPLEMENTED_waterpour( result , grains ):
4028 """ 4029 Performs the classical Vincent watershed segmentation of a data field. 4030 4031 The segmentation always results in the entire field being masked with the 4032 exception of thin (8-connectivity) lines separating the segments (grains). 4033 4034 Compared to L{DataField.grains_mark_watershed}(), this algorithm is very 4035 fast. However, when used alone, it typically results in a serious 4036 oversegmentation as each local minimum gives raise to a grain. Furthermore, 4037 the full segmentation means that also pixels which would be considered 4038 outside any grain in the topographical sense will be assigned to some 4039 catchment basin. Therefore, pre- or postprocessing is usually necessary, 4040 using the gradient image or a more sophisticated method. 4041 4042 Since the algorithm numbers the grains as a side effect, you can pass a 4043 B{C{grains}} array and get the grain numbers immediatelly, avoiding the 4044 relatively (although not drastically) expensive 4045 L{DataField.number_grains}() call. 4046 4047 Since: 2.37 4048 4049 @param result: Data field that will be filled with the resulting mask. It will be 4050 resized to the dimensions of B{C{data_field}} and its properties set 4051 accordingly. I{(L{DataField})} 4052 @param grains: Optionally, an array with the same number of items as B{C{data_field}}. 4053 If non-B{C{NULL}}, it will be filled with grain numbers in the same 4054 manner as L{DataField.number_grains}(). Pass B{C{NULL}} to ignore. I{(gint*)} 4055 @return: The number of segments (grains) in the result, excluding the 4056 separators, i.e. the same convention as in 4057 L{DataField.number_grains}() is used. 4058 4059 4060 """ 4061 return None
4062 - def mark_extrema( extrema , maxima ):
4063 return None
4064 - def hough_line( x_gradient , y_gradient , result , hwidth , overlapping ):
4065 return None
4066 - def hough_circle( x_gradient , y_gradient , result , radius ):
4067 return None
4068 - def hough_line_strenghten( x_gradient , y_gradient , hwidth , threshold ):
4069 return None
4070 - def hough_circle_strenghten( x_gradient , y_gradient , radius , threshold ):
4071 return None
4072 - def UNIMPLEMENTED_get_local_maxima_list( xdata , ydata , zdata , ndata , skip , threshold , subpixel ):
4073 return None
4074 - def hough_polar_line_to_datafield( rho , theta , px1 , px2 , py1 , py2 ):
4075 return None
4076 - def a_1dfft( iin , rout , iout , orientation , windowing , direction , interpolation , preserverms , level ):
4077 """ 4078 Transforms all rows or columns in a data field with Fast Fourier Transform. 4079 4080 If requested a windowing and/or leveling is applied to preprocess data to 4081 obtain reasonable results. 4082 4083 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4084 transform which can be somewhat faster than complex-to-complex 4085 transform. I{(L{DataField})} 4086 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4087 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4088 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4089 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4090 columns. I{(Orientation)} 4091 @param windowing: Windowing type. I{(WindowingType)} 4092 @param direction: FFT direction. I{(TransformDirection)} 4093 @param interpolation: Interpolation type. 4094 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4095 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4096 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4097 line (the number can be interpreted as the first polynomial degree 4098 to keep, but only the enumerated three values are available). I{(int)} 4099 @return: 4100 """ 4101 return None
4102 - def area_1dfft( iin , rout , iout , col , row , width , height , orientation , windowing , direction , interpolation , preserverms , level ):
4103 """ 4104 Transforms all rows or columns in a rectangular part of a data field with 4105 Fast Fourier Transform. 4106 4107 If requested a windowing and/or leveling is applied to preprocess data to 4108 obtain reasonable results. 4109 4110 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4111 transform which can be somewhat faster than complex-to-complex 4112 transform. I{(L{DataField})} 4113 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4114 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4115 @param col: Upper-left column coordinate. I{(int)} 4116 @param row: Upper-left row coordinate. I{(int)} 4117 @param width: Area width (number of columns), must be at least 2 for horizontal 4118 transforms. I{(int)} 4119 @param height: Area height (number of rows), must be at least 2 for vertical 4120 transforms. I{(int)} 4121 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4122 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4123 columns. I{(Orientation)} 4124 @param windowing: Windowing type. I{(WindowingType)} 4125 @param direction: FFT direction. I{(TransformDirection)} 4126 @param interpolation: Interpolation type. 4127 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4128 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4129 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4130 lines (the number can be interpreted as the first polynomial degree 4131 to keep, but only the enumerated three values are available). I{(int)} 4132 @return: 4133 """ 4134 return None
4135 - def a_1dfft_raw( iin , rout , iout , orientation , direction ):
4136 """ 4137 Transforms all rows or columns in a data field with Fast Fourier Transform. 4138 4139 No leveling, windowing nor scaling is performed. 4140 4141 Since 2.8 the dimensions need not to be from the set of sizes returned 4142 by L{gwy_fft_find_nice_size}(). 4143 4144 Since: 2.1 4145 4146 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4147 transform. I{(L{DataField})} 4148 @param rout: Real output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4149 @param iout: Imaginary output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4150 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4151 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4152 columns. I{(Orientation)} 4153 @param direction: FFT direction. I{(TransformDirection)} 4154 @return: 4155 """ 4156 return None
4157 - def a_2dfft( iin , rout , iout , windowing , direction , interpolation , preserverms , level ):
4158 """ 4159 Calculates 2D Fast Fourier Transform of a rectangular a data field. 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 windowing: Windowing type. I{(WindowingType)} 4170 @param direction: FFT direction. I{(TransformDirection)} 4171 @param interpolation: Interpolation type. I{(InterpolationType)} 4172 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4173 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4174 plane (the number can be interpreted as the first polynomial degree 4175 to keep, but only the enumerated three values are available). I{(int)} 4176 @return: 4177 """ 4178 return None
4179 - def area_2dfft( iin , rout , iout , col , row , width , height , windowing , direction , interpolation , preserverms , level ):
4180 """ 4181 Calculates 2D Fast Fourier Transform of a rectangular area of a data field. 4182 4183 If requested a windowing and/or leveling is applied to preprocess data to 4184 obtain reasonable results. 4185 4186 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4187 transform which can be somewhat faster than complex-to-complex 4188 transform. I{(L{DataField})} 4189 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4190 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4191 @param col: Upper-left column coordinate. I{(int)} 4192 @param row: Upper-left row coordinate. I{(int)} 4193 @param width: Area width (number of columns), must be at least 2. I{(int)} 4194 @param height: Area height (number of rows), must be at least 2. I{(int)} 4195 @param windowing: Windowing type. I{(WindowingType)} 4196 @param direction: FFT direction. I{(TransformDirection)} 4197 @param interpolation: Interpolation type. 4198 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4199 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4200 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4201 plane (the number can be interpreted as the first polynomial degree 4202 to keep, but only the enumerated three values are available). I{(int)} 4203 @return: 4204 """ 4205 return None
4206 - def a_2dfft_raw( iin , rout , iout , direction ):
4207 """ 4208 Calculates 2D Fast Fourier Transform of a data field. 4209 4210 No leveling, windowing nor scaling is performed. 4211 4212 Since 2.8 the dimensions need not to be from the set of sizes returned 4213 by L{gwy_fft_find_nice_size}(). 4214 4215 Since: 2.1 4216 4217 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4218 transform. I{(L{DataField})} 4219 @param rout: Real output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4220 @param iout: Imaginary output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4221 @param direction: FFT direction. I{(TransformDirection)} 4222 @return: 4223 """ 4224 return None
4225 - def a_2dfft_humanize( ):
4226 """ 4227 Rearranges 2D FFT output to a human-friendly form. 4228 4229 Top-left, top-right, bottom-left and bottom-right sub-rectangles are swapped 4230 to obtain a humanized 2D FFT output with (0,0) in the centre. 4231 4232 More precisely, for even field dimensions the equally-sized blocks starting 4233 with the Nyquist frequency and with the zero frequency (constant component) 4234 will exchange places. For odd field dimensions, the block containing the 4235 zero frequency is one item larger and the constant component will actually 4236 end up in the exact centre. 4237 4238 Also note if both dimensions are even, this function is involutory and 4239 identical to L{DataField.2dfft_dehumanize}(). However, if any dimension 4240 is odd, L{DataField.2dfft_humanize}() and 4241 L{DataField.2dfft_dehumanize}() are different, therefore they must be 4242 paired properly. 4243 4244 @return: 4245 """ 4246 return None
4247 - def a_2dfft_dehumanize( ):
4248 """ 4249 Rearranges 2D FFT output back from the human-friendly form. 4250 4251 Top-left, top-right, bottom-left and bottom-right sub-rectangles are swapped 4252 to reshuffle a humanized 2D FFT output back into the natural positions. 4253 4254 See L{DataField.2dfft_humanize}() for discussion. 4255 4256 Since: 2.8 4257 4258 @return: 4259 """ 4260 return None
4261 - def fft_filter_1d( result_field , weights , orientation , interpolation ):
4262 """ 4263 Performs 1D FFT filtering of a data field. 4264 4265 @param result_field: A data field to store the result to. It will be resampled 4266 to B{C{data_field}}'s size. I{(L{DataField})} 4267 @param weights: Filter weights for the lower half of the spectrum (the other 4268 half is symmetric). Its size can be arbitrary, it will be 4269 interpolated. I{(L{DataLine})} 4270 @param orientation: Filter direction. I{(Orientation)} 4271 @param interpolation: The interpolation to use for resampling. I{(InterpolationType)} 4272 @return: 4273 """ 4274 return None
4275 - def UNIMPLEMENTED_cwt( interpolation , scale , wtype ):
4276 """ 4277 Computes a continuous wavelet transform (CWT) at given 4278 scale and using given wavelet. 4279 4280 @param interpolation: Interpolation type. 4281 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4282 @param scale: Wavelet scale. I{(float)} 4283 @param wtype: Wavelet type. I{(2DCWTWaveletType)} 4284 @return: 4285 """ 4286 return None
4287 - def area_fit_plane( mask , col , row , width , height , pa , pbx , pby ):
4288 """ 4289 Fits a plane through a rectangular part of a data field. 4290 4291 The coefficients can be used for plane leveling using the same relation 4292 as in L{DataField.fit_plane}(), counting indices from area top left 4293 corner. 4294 4295 @param mask: Mask of values to take values into account, or B{C{NULL}} for full 4296 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4297 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4298 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4299 for values inside (0.0, 1.0) is undefined (it may be specified 4300 in the future). I{(L{DataField})} 4301 @param col: Upper-left column coordinate. I{(int)} 4302 @param row: Upper-left row coordinate. I{(int)} 4303 @param width: Area width (number of columns). I{(int)} 4304 @param height: Area height (number of rows). I{(int)} 4305 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(float)} 4306 @param pbx: Where x plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4307 @param pby: Where y plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4308 @return: 4309 """ 4310 return None
4311 - def fit_plane( pa , pbx , pby ):
4312 """ 4313 Fits a plane through a data field. 4314 4315 The coefficients can be used for plane leveling using relation 4316 data[i] := data[i] - (pa + pby*i + pbx*j); 4317 4318 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(float)} 4319 @param pbx: Where x plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4320 @param pby: Where y plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4321 @return: 4322 """ 4323 return None
4324 - def plane_level( a , bx , by ):
4325 """ 4326 Subtracts plane from a data field. 4327 4328 See L{DataField.fit_plane}() for details. 4329 4330 @param a: Constant coefficient. I{(float)} 4331 @param bx: X plane coefficient. I{(float)} 4332 @param by: Y plane coefficient. I{(float)} 4333 @return: 4334 """ 4335 return None
4336 - def plane_rotate( xangle , yangle , interpolation ):
4337 """ 4338 Performs rotation of plane along x and y axis. 4339 4340 @param xangle: Rotation angle in x direction (rotation along y axis, in radians). I{(float)} 4341 @param yangle: Rotation angle in y direction (rotation along x axis, in radians). I{(float)} 4342 @param interpolation: Interpolation type (can be only of two-point type). I{(InterpolationType)} 4343 @return: 4344 """ 4345 return None
4346 - def fit_lines( col , row , width , height , degree , exclude , orientation ):
4347 """ 4348 Independently levels profiles on each row/column in a data field. 4349 4350 Lines that have no intersection with area selected by B{C{ulcol}}, B{C{ulrow}}, 4351 B{C{brcol}}, B{C{brrow}} are always leveled as a whole. Lines that have intersection 4352 with selected area, are leveled using polynomial coefficients computed only 4353 from data inside (or outside for B{C{exclude}} = B{C{True}}) the area. 4354 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 degree: Fitted polynomial degree. I{(int)} 4360 @param exclude: If B{C{True}}, outside of area selected by B{C{ulcol}}, B{C{ulrow}}, B{C{brcol}}, 4361 B{C{brrow}} will be used for polynomial coefficients computation, 4362 instead of inside. I{(bool)} 4363 @param orientation: Line orientation. I{(Orientation)} 4364 @return: 4365 """ 4366 return None
4367 - def fit_polynom( col_degree , row_degree , coeffs ):
4368 """ 4369 Fits a two-dimensional polynomial to a data field. 4370 4371 4372 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4373 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4374 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4375 coefficients to, or B{C{NULL}} (a fresh array is allocated then), 4376 see L{DataField.area_fit_polynom}() for details. I{(gdouble*)} 4377 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4378 with coefficients. 4379 4380 """ 4381 return None
4382 - def area_fit_polynom( col , row , width , height , col_degree , row_degree , coeffs ):
4383 """ 4384 Fits a two-dimensional polynomial to a rectangular part of a data field. 4385 4386 The coefficients are stored by row into B{C{coeffs}}, like data in a datafield. 4387 Row index is y-degree, column index is x-degree. 4388 4389 Note naive x^n y^m polynomial fitting is numerically unstable, therefore 4390 this method works only up to B{C{col_degree}} = B{C{row_degree}} = 6. 4391 4392 4393 @param col: Upper-left column coordinate. I{(int)} 4394 @param row: Upper-left row coordinate. I{(int)} 4395 @param width: Area width (number of columns). I{(int)} 4396 @param height: Area height (number of rows). I{(int)} 4397 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4398 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4399 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4400 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4401 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4402 with coefficients. 4403 4404 """ 4405 return None
4406 - def subtract_polynom( col_degree , row_degree , coeffs ):
4407 """ 4408 Subtracts a two-dimensional polynomial from a data field. 4409 4410 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4411 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4412 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4413 see L{DataField.area_fit_polynom}() for details. I{(const-gdouble*)} 4414 @return: 4415 """ 4416 return None
4417 - def area_subtract_polynom( col , row , width , height , col_degree , row_degree , coeffs ):
4418 """ 4419 Subtracts a two-dimensional polynomial from a rectangular part of a data 4420 field. 4421 4422 @param col: Upper-left column coordinate. I{(int)} 4423 @param row: Upper-left row coordinate. I{(int)} 4424 @param width: Area width (number of columns). I{(int)} 4425 @param height: Area height (number of rows). I{(int)} 4426 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4427 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4428 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4429 see L{DataField.area_fit_polynom}() for details. I{(const-gdouble*)} 4430 @return: 4431 """ 4432 return None
4433 - def UNIMPLEMENTED_fit_legendre( col_degree , row_degree , coeffs ):
4434 """ 4435 Fits two-dimensional Legendre polynomial to a data field. 4436 4437 See L{DataField.area_fit_legendre}() for details. 4438 4439 4440 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4441 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4442 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4443 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4444 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4445 with coefficients. 4446 4447 """ 4448 return None
4449 - def UNIMPLEMENTED_area_fit_legendre( col , row , width , height , col_degree , row_degree , coeffs ):
4450 """ 4451 Fits two-dimensional Legendre polynomial to a rectangular part of a data 4452 field. 4453 4454 The B{C{col_degree}} and B{C{row_degree}} parameters limit the maximum powers of x and 4455 y exactly as if simple powers were fitted, therefore if you do not intend to 4456 interpret contents of B{C{coeffs}} youself, the only difference is that this 4457 method is much more numerically stable. 4458 4459 The coefficients are organized exactly like in 4460 L{DataField.area_fit_polynom}(), but they are not coefficients of 4461 x^n y^m, instead they are coefficients of P_n(x) P_m(x), where P are 4462 Legendre polynomials. The polynomials are evaluated in coordinates where 4463 first row (column) corresponds to -1.0, and the last row (column) to 1.0. 4464 4465 Note the polynomials are normal Legendre polynomials that are not exactly 4466 orthogonal on a discrete point set (if their degrees are equal mod 2). 4467 4468 4469 @param col: Upper-left column coordinate. I{(int)} 4470 @param row: Upper-left row coordinate. I{(int)} 4471 @param width: Area width (number of columns). I{(int)} 4472 @param height: Area height (number of rows). I{(int)} 4473 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4474 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4475 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4476 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4477 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4478 with coefficients. 4479 4480 """ 4481 return None
4482 - def subtract_legendre( col_degree , row_degree , coeffs ):
4483 """ 4484 Subtracts a two-dimensional Legendre polynomial fit from a data field. 4485 4486 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4487 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4488 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4489 see L{DataField.area_fit_legendre}() for details. I{(const-gdouble*)} 4490 @return: 4491 """ 4492 return None
4493 - def area_subtract_legendre( col , row , width , height , col_degree , row_degree , coeffs ):
4494 """ 4495 Subtracts a two-dimensional Legendre polynomial fit from a rectangular part 4496 of a data field. 4497 4498 Due to the transform of coordinates to [-1,1] x [-1,1], this method can be 4499 used on an area of dimensions different than the area the coefficients were 4500 calculated for. 4501 4502 @param col: Upper-left column coordinate. I{(int)} 4503 @param row: Upper-left row coordinate. I{(int)} 4504 @param width: Area width (number of columns). I{(int)} 4505 @param height: Area height (number of rows). I{(int)} 4506 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4507 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4508 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4509 see L{DataField.area_fit_legendre}() for details. I{(const-gdouble*)} 4510 @return: 4511 """ 4512 return None
4513 - def UNIMPLEMENTED_fit_poly_max( max_degree , coeffs ):
4514 """ 4515 Fits two-dimensional polynomial with limited total degree to a data field. 4516 4517 See L{DataField.area_fit_poly_max}() for details. 4518 4519 4520 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4521 in x^n y^m terms. I{(int)} 4522 @param coeffs: An array of size (B{C{max_degree}}+1)*(B{C{max_degree}}+2)/2 to store the 4523 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4524 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4525 with coefficients. 4526 4527 """ 4528 return None
4529 - def UNIMPLEMENTED_area_fit_poly_max( col , row , width , height , max_degree , coeffs ):
4530 """ 4531 Fits two-dimensional polynomial with limited total degree to a rectangular 4532 part of a data field. 4533 4534 See L{DataField.area_fit_legendre}() for description. This function 4535 differs by limiting the total maximum degree, while 4536 L{DataField.area_fit_legendre}() limits the maximum degrees in horizontal 4537 and vertical directions independently. 4538 4539 4540 @param col: Upper-left column coordinate. I{(int)} 4541 @param row: Upper-left row coordinate. I{(int)} 4542 @param width: Area width (number of columns). I{(int)} 4543 @param height: Area height (number of rows). I{(int)} 4544 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4545 in x^n y^m terms. I{(int)} 4546 @param coeffs: An array of size (B{C{max_degree}}+1)*(B{C{max_degree}}+2)/2 to store the 4547 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4548 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4549 with coefficients. 4550 4551 """ 4552 return None
4553 - def subtract_poly_max( max_degree , coeffs ):
4554 """ 4555 Subtracts a two-dimensional polynomial with limited total degree from 4556 a data field. 4557 4558 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4559 in x^n y^m terms. I{(int)} 4560 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+2)/2 with 4561 coefficients, see L{DataField.area_fit_poly_max}() for details. I{(const-gdouble*)} 4562 @return: 4563 """ 4564 return None
4565 - def area_subtract_poly_max( col , row , width , height , max_degree , coeffs ):
4566 """ 4567 Subtracts a two-dimensional polynomial with limited total degree from a 4568 rectangular part of a data field. 4569 4570 Due to the transform of coordinates to [-1,1] x [-1,1], this method can be 4571 used on an area of dimensions different than the area the coefficients were 4572 calculated for. 4573 4574 @param col: Upper-left column coordinate. I{(int)} 4575 @param row: Upper-left row coordinate. I{(int)} 4576 @param width: Area width (number of columns). I{(int)} 4577 @param height: Area height (number of rows). I{(int)} 4578 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4579 in x^n y^m terms. I{(int)} 4580 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+2)/2 with 4581 coefficients, see L{DataField.area_fit_poly_max}() for details. I{(const-gdouble*)} 4582 @return: 4583 """ 4584 return None
4585 - def fit_poly( mask_field , nterms , term_powers , exclude , coeffs ):
4586 """ 4587 Fit a given set of polynomial terms to a data field. 4588 4589 Since: 2.11 4590 4591 @param mask_field: Mask of values to take values into account, or B{C{NULL}} for full 4592 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4593 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4594 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4595 for values inside (0.0, 1.0) is undefined (it may be specified 4596 in the future). I{(L{DataField})} 4597 @param nterms: The number of polynomial terms to take into account (half the 4598 number of items in B{C{term_powers}}). I{(int)} 4599 @param term_powers: Array of size 2*B{C{nterms}} describing the terms to fit. Each 4600 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4601 @param exclude: Interpret values B{C{w}} in the mask as 1.0-B{C{w}}. I{(bool)} 4602 @param coeffs: Array of size B{C{nterms}} to store the coefficients to, or B{C{NULL}} to 4603 allocate a new array. I{(gdouble*)} 4604 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4605 with coefficients. 4606 4607 4608 """ 4609 return None
4610 - def area_fit_poly( mask_field , col , row , width , height , nterms , term_powers , exclude , coeffs ):
4611 """ 4612 Fit a given set of polynomial terms to a rectangular part of a data field. 4613 4614 The polynomial coefficients correspond to normalized coordinates that 4615 are always from the interval [-1,1] where -1 corresponds to the left/topmost 4616 pixel and 1 corresponds to the bottom/rightmost pixel of the area. 4617 4618 Since: 2.11 4619 4620 @param mask_field: Mask of values to take values into account, or B{C{NULL}} for full 4621 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4622 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4623 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4624 for values inside (0.0, 1.0) is undefined (it may be specified 4625 in the future). I{(L{DataField})} 4626 @param col: Upper-left column coordinate. I{(int)} 4627 @param row: Upper-left row coordinate. I{(int)} 4628 @param width: Area width (number of columns). I{(int)} 4629 @param height: Area height (number of rows). I{(int)} 4630 @param nterms: The number of polynomial terms to take into account (half the 4631 number of items in B{C{term_powers}}). I{(int)} 4632 @param term_powers: Array of size 2*B{C{nterms}} describing the terms to fit. Each 4633 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4634 @param exclude: Interpret values B{C{w}} in the mask as 1.0-B{C{w}}. I{(bool)} 4635 @param coeffs: Array of size B{C{nterms}} to store the coefficients to, or B{C{NULL}} to 4636 allocate a new array. I{(gdouble*)} 4637 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4638 with coefficients. 4639 4640 4641 """ 4642 return None
4643 - def subtract_poly( nterms , term_powers , coeffs ):
4644 """ 4645 Subtract a given set of polynomial terms from a data field. 4646 4647 Since: 2.11 4648 4649 @param nterms: The number of polynomial terms to take into account (half the 4650 number of items in B{C{term_powers}}). I{(int)} 4651 @param term_powers: Array of size 2*B{C{nterms}} describing the fitter terms. Each 4652 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4653 @param coeffs: Array of size B{C{nterms}} to store with the coefficients. I{(const-gdouble*)} 4654 @return: 4655 """ 4656 return None
4657 - def area_subtract_poly( col , row , width , height , nterms , term_powers , coeffs ):
4658 """ 4659 Subtract a given set of polynomial terms from a rectangular part of a data 4660 field. 4661 4662 Since: 2.11 4663 4664 @param col: Upper-left column coordinate. I{(int)} 4665 @param row: Upper-left row coordinate. I{(int)} 4666 @param width: Area width (number of columns). I{(int)} 4667 @param height: Area height (number of rows). I{(int)} 4668 @param nterms: The number of polynomial terms to take into account (half the 4669 number of items in B{C{term_powers}}). I{(int)} 4670 @param term_powers: Array of size 2*B{C{nterms}} describing the fitted terms. Each 4671 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4672 @param coeffs: Array of size B{C{nterms}} to store with the coefficients. I{(const-gdouble*)} 4673 @return: 4674 """ 4675 return None
4676 - def UNIMPLEMENTED_area_fit_local_planes( size , col , row , width , height , nresults , types , results ):
4677 """ 4678 Fits a plane through neighbourhood of each sample in a rectangular part 4679 of a data field. 4680 4681 The sample is always in the origin of its local (x,y) coordinate system, 4682 even if the neighbourhood is not centered about it (e.g. because sample 4683 is on the edge of data field). Z-coordinate is however not centered, 4684 that is B{C{PLANE_FIT_A}} is normal mean value. 4685 4686 4687 @param size: Neighbourhood size (must be at least 2). It is centered around 4688 each pixel, unless B{C{size}} is even when it sticks to the right. I{(int)} 4689 @param col: Upper-left column coordinate. I{(int)} 4690 @param row: Upper-left row coordinate. I{(int)} 4691 @param width: Area width (number of columns). I{(int)} 4692 @param height: Area height (number of rows). I{(int)} 4693 @param nresults: The number of requested quantities. I{(int)} 4694 @param types: The types of requested quantities. I{(const-PlaneFitQuantity*)} 4695 @param results: An array to store quantities to, may be B{C{NULL}} to allocate a new 4696 one which must be freed by caller then. If any item is B{C{NULL}}, 4697 a new data field is allocated for it, existing data fields 4698 are resized to B{C{width}} x B{C{height}}. I{(DataField**)} 4699 @return: An array of data fields with requested quantities, that is 4700 B{C{results}} unless it was B{C{NULL}} and a new array was allocated. 4701 4702 """ 4703 return None
4704 - def area_local_plane_quantity( size , col , row , width , height , type , result ):
4705 """ 4706 Convenience function to get just one quantity from 4707 L{DataField.area_fit_local_planes}(). 4708 4709 4710 @param size: Neighbourhood size. I{(int)} 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 type: The type of requested quantity. I{(PlaneFitQuantity)} 4716 @param result: A data field to store result to, or B{C{NULL}} to allocate a new one. I{(L{DataField})} 4717 @return: B{C{result}} if it isn't B{C{NULL}}, otherwise a newly allocated data field. 4718 4719 """ 4720 return None
4721 - def UNIMPLEMENTED_fit_local_planes( size , nresults , types , results ):
4722 """ 4723 Fits a plane through neighbourhood of each sample in a data field. 4724 4725 See L{DataField.area_fit_local_planes}() for details. 4726 4727 4728 @param size: Neighbourhood size. I{(int)} 4729 @param nresults: The number of requested quantities. I{(int)} 4730 @param types: The types of requested quantities. I{(const-PlaneFitQuantity*)} 4731 @param results: An array to store quantities to. I{(DataField**)} 4732 @return: An array of data fields with requested quantities. 4733 4734 """ 4735 return None
4736 - def local_plane_quantity( size , type , result ):
4737 """ 4738 Convenience function to get just one quantity from 4739 L{DataField.fit_local_planes}(). 4740 4741 4742 @param size: Neighbourhood size. I{(int)} 4743 @param type: The type of requested quantity. I{(PlaneFitQuantity)} 4744 @param result: A data field to store result to, or B{C{NULL}} to allocate a new one. I{(L{DataField})} 4745 @return: B{C{result}} if it isn't B{C{NULL}}, otherwise a newly allocated data field. 4746 4747 """ 4748 return None
4749 - def get_max( ):
4750 """ 4751 Finds the maximum value of a data field. 4752 4753 This quantity is cached. 4754 4755 4756 @return: The maximum value. 4757 4758 """ 4759 return None
4760 - def get_min( ):
4761 """ 4762 Finds the minimum value of a data field. 4763 4764 This quantity is cached. 4765 4766 4767 @return: The minimum value. 4768 4769 """ 4770 return None
4771 - def get_min_max( min , max ):
4772 """ 4773 Finds minimum and maximum values of a data field. 4774 4775 @param min: Location to store minimum to. I{(float)} 4776 @param max: Location to store maximum to. I{(float)} 4777 @return: 4778 """ 4779 return None
4780 - def get_avg( ):
4781 """ 4782 Computes average value of a data field. 4783 4784 This quantity is cached. 4785 4786 4787 @return: The average value. 4788 4789 """ 4790 return None
4791 - def get_rms( ):
4792 """ 4793 Computes root mean square value of a data field. 4794 4795 This quantity is cached. 4796 4797 4798 @return: The root mean square value. 4799 4800 """ 4801 return None
4802 - def get_sum( ):
4803 """ 4804 Sums all values in a data field. 4805 4806 This quantity is cached. 4807 4808 4809 @return: The sum of all values. 4810 4811 """ 4812 return None
4813 - def get_median( ):
4814 """ 4815 Computes median value of a data field. 4816 4817 This quantity is cached. 4818 4819 4820 @return: The median value. 4821 4822 """ 4823 return None
4824 - def get_surface_area( ):
4825 """ 4826 Computes surface area of a data field. 4827 4828 This quantity is cached. 4829 4830 4831 @return: surface area 4832 4833 """ 4834 return None
4835 - def area_get_max( mask , col , row , width , height ):
4836 """ 4837 Finds the maximum value in a rectangular part of a data field. 4838 4839 4840 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4841 @param col: Upper-left column coordinate. I{(int)} 4842 @param row: Upper-left row coordinate. I{(int)} 4843 @param width: Area width (number of columns). I{(int)} 4844 @param height: Area height (number of rows). I{(int)} 4845 @return: The maximum value. When the number of samples to calculate 4846 maximum of is zero, -B{C{G_MAXDOUBLE}} is returned. 4847 4848 """ 4849 return None
4850 - def area_get_min( mask , col , row , width , height ):
4851 """ 4852 Finds the minimum value in a rectangular part of a data field. 4853 4854 4855 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4856 @param col: Upper-left column coordinate. I{(int)} 4857 @param row: Upper-left row coordinate. I{(int)} 4858 @param width: Area width (number of columns). I{(int)} 4859 @param height: Area height (number of rows). I{(int)} 4860 @return: The minimum value. When the number of samples to calculate 4861 minimum of is zero, -B{C{G_MAXDOUBLE}} is returned. 4862 4863 """ 4864 return None
4865 - def UNIMPLEMENTED_area_get_min_max( mask , col , row , width , height , min , max ):
4866 """ 4867 Finds minimum and maximum values in a rectangular part of a data field. 4868 4869 This function is equivalent to calling 4870 B{C{L{DataField.area_get_min_max_mask}}}() 4871 with masking mode B{C{MASK_INCLUDE}}. 4872 4873 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4874 @param col: Upper-left column coordinate. I{(int)} 4875 @param row: Upper-left row coordinate. I{(int)} 4876 @param width: Area width (number of columns). I{(int)} 4877 @param height: Area height (number of rows). I{(int)} 4878 @param min: Location to store minimum to. I{(gdouble*)} 4879 @param max: Location to store maximum to. I{(gdouble*)} 4880 @return: 4881 """ 4882 return None
4883 - def UNIMPLEMENTED_area_get_min_max_mask( mask , mode , col , row , width , height , min , max ):
4884 """ 4885 Finds minimum and maximum values in a rectangular part of a data field. 4886 4887 Since: 2.18 4888 4889 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4890 @param mode: Masking mode to use. See the introduction for description of 4891 masking modes. I{(MaskingType)} 4892 @param col: Upper-left column coordinate. I{(int)} 4893 @param row: Upper-left row coordinate. I{(int)} 4894 @param width: Area width (number of columns). I{(int)} 4895 @param height: Area height (number of rows). I{(int)} 4896 @param min: Location to store minimum to. I{(gdouble*)} 4897 @param max: Location to store maximum to. I{(gdouble*)} 4898 @return: 4899 """ 4900 return None
4901 - def area_get_avg( mask , col , row , width , height ):
4902 """ 4903 Computes average value of a rectangular part of a data field. 4904 4905 This function is equivalent to calling B{C{L{DataField.area_get_avg_mask}}}() 4906 with masking mode B{C{MASK_INCLUDE}}. 4907 4908 4909 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4910 @param col: Upper-left column coordinate. I{(int)} 4911 @param row: Upper-left row coordinate. I{(int)} 4912 @param width: Area width (number of columns). I{(int)} 4913 @param height: Area height (number of rows). I{(int)} 4914 @return: The average value. 4915 4916 """ 4917 return None
4918 - def area_get_avg_mask( mask , mode , col , row , width , height ):
4919 """ 4920 Computes average value of a rectangular part of a data field. 4921 4922 Since: 2.18 4923 4924 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4925 @param mode: Masking mode to use. See the introduction for description of 4926 masking modes. I{(MaskingType)} 4927 @param col: Upper-left column coordinate. I{(int)} 4928 @param row: Upper-left row coordinate. I{(int)} 4929 @param width: Area width (number of columns). I{(int)} 4930 @param height: Area height (number of rows). I{(int)} 4931 @return: The average value. 4932 4933 4934 """ 4935 return None
4936 - def area_get_rms( mask , col , row , width , height ):
4937 """ 4938 Computes root mean square value of a rectangular part of a data field. 4939 4940 4941 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4942 @param col: Upper-left column coordinate. I{(int)} 4943 @param row: Upper-left row coordinate. I{(int)} 4944 @param width: Area width (number of columns). I{(int)} 4945 @param height: Area height (number of rows). I{(int)} 4946 @return: The root mean square value. 4947 4948 This function is equivalent to calling B{C{L{DataField.area_get_rms_mask}}}() 4949 with masking mode B{C{MASK_INCLUDE}}. 4950 4951 """ 4952 return None
4953 - def area_get_rms_mask( mask , mode , col , row , width , height ):
4954 """ 4955 Computes root mean square value of deviations of a rectangular part of a 4956 data field. 4957 4958 Since: 2.18 4959 4960 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4961 @param mode: Masking mode to use. See the introduction for description of 4962 masking modes. I{(MaskingType)} 4963 @param col: Upper-left column coordinate. I{(int)} 4964 @param row: Upper-left row coordinate. I{(int)} 4965 @param width: Area width (number of columns). I{(int)} 4966 @param height: Area height (number of rows). I{(int)} 4967 @return: The root mean square value of deviations from the mean value. 4968 4969 4970 """ 4971 return None
4972 - def area_get_grainwise_rms( mask , mode , col , row , width , height ):
4973 """ 4974 Computes grain-wise root mean square value of deviations of a rectangular 4975 part of a data field. 4976 4977 Grain-wise means that the mean value is determined for each grain (i.e. 4978 cotinguous part of the mask or inverted mask) separately and the deviations 4979 are calculated from these mean values. 4980 4981 Since: 2.29 4982 4983 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4984 @param mode: Masking mode to use. See the introduction for description of 4985 masking modes. I{(MaskingType)} 4986 @param col: Upper-left column coordinate. I{(int)} 4987 @param row: Upper-left row coordinate. I{(int)} 4988 @param width: Area width (number of columns). I{(int)} 4989 @param height: Area height (number of rows). I{(int)} 4990 @return: The root mean square value of deviations from the mean value. 4991 4992 4993 """ 4994 return None
4995 - def area_get_sum( mask , col , row , width , height ):
4996 """ 4997 Sums values of a rectangular part of a data field. 4998 4999 This function is equivalent to calling B{C{L{DataField.area_get_sum_mask}}}() 5000 with masking mode B{C{MASK_INCLUDE}}. 5001 5002 5003 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5004 @param col: Upper-left column coordinate. I{(int)} 5005 @param row: Upper-left row coordinate. I{(int)} 5006 @param width: Area width (number of columns). I{(int)} 5007 @param height: Area height (number of rows). I{(int)} 5008 @return: The sum of all values inside area. 5009 5010 """ 5011 return None
5012 - def area_get_sum_mask( mask , mode , col , row , width , height ):
5013 """ 5014 Sums values of a rectangular part of a data field. 5015 5016 Since: 2.18 5017 5018 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5019 @param mode: Masking mode to use. See the introduction for description of 5020 masking modes. I{(MaskingType)} 5021 @param col: Upper-left column coordinate. I{(int)} 5022 @param row: Upper-left row coordinate. I{(int)} 5023 @param width: Area width (number of columns). I{(int)} 5024 @param height: Area height (number of rows). I{(int)} 5025 @return: The sum of all values inside area. 5026 5027 5028 """ 5029 return None
5030 - def area_get_median( mask , col , row , width , height ):
5031 """ 5032 Computes median value of a data field area. 5033 5034 This function is equivalent to calling 5035 B{C{L{DataField.area_get_median_mask}}}() 5036 with masking mode B{C{MASK_INCLUDE}}. 5037 5038 5039 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5040 @param col: Upper-left column coordinate. I{(int)} 5041 @param row: Upper-left row coordinate. I{(int)} 5042 @param width: Area width (number of columns). I{(int)} 5043 @param height: Area height (number of rows). I{(int)} 5044 @return: The median value. 5045 5046 """ 5047 return None
5048 - def area_get_median_mask( mask , mode , col , row , width , height ):
5049 """ 5050 Computes median value of a data field area. 5051 5052 Since: 2.18 5053 5054 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5055 @param mode: Masking mode to use. See the introduction for description of 5056 masking modes. I{(MaskingType)} 5057 @param col: Upper-left column coordinate. I{(int)} 5058 @param row: Upper-left row coordinate. I{(int)} 5059 @param width: Area width (number of columns). I{(int)} 5060 @param height: Area height (number of rows). I{(int)} 5061 @return: The median value. 5062 5063 5064 """ 5065 return None
5066 - def area_get_surface_area( mask , col , row , width , height ):
5067 return None
5068 - def area_get_surface_area_mask( mask , mode , col , row , width , height ):
5069 """ 5070 Computes surface area of a rectangular part of a data field. 5071 5072 This quantity makes sense only if the lateral dimensions and values of 5073 B{C{data_field}} are the same physical quantities. 5074 5075 Since: 2.18 5076 5077 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5078 @param mode: Masking mode to use. See the introduction for description of 5079 masking modes. I{(MaskingType)} 5080 @param col: Upper-left column coordinate. I{(int)} 5081 @param row: Upper-left row coordinate. I{(int)} 5082 @param width: Area width (number of columns). I{(int)} 5083 @param height: Area height (number of rows). I{(int)} 5084 @return: The surface area. 5085 5086 5087 """ 5088 return None
5089 - def area_get_volume( basis , mask , col , row , width , height ):
5090 """ 5091 Computes volume of a rectangular part of a data field. 5092 5093 Since: 2.3 5094 5095 @param basis: The basis or background for volume calculation if not B{C{NULL}}. 5096 The height of each vertex is then the difference between 5097 B{C{data_field}} value and B{C{basis}} value. Value B{C{NULL}} is the same 5098 as passing all zeroes for the basis. I{(L{DataField})} 5099 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5100 @param col: Upper-left column coordinate. I{(int)} 5101 @param row: Upper-left row coordinate. I{(int)} 5102 @param width: Area width (number of columns). I{(int)} 5103 @param height: Area height (number of rows). I{(int)} 5104 @return: The volume. 5105 5106 5107 """ 5108 return None
5109 - def UNIMPLEMENTED_get_autorange( _from , to ):
5110 """ 5111 Computes value range with outliers cut-off. 5112 5113 The purpose of this function is to find a range is suitable for false color 5114 mapping. The precise method how it is calculated is unspecified and may be 5115 subject to changes. 5116 5117 However, it is guaranteed minimum <= B{C{from}} <= B{C{to}} <= maximum. 5118 5119 This quantity is cached. 5120 5121 @param _from: Location to store range start. I{(gdouble*)} 5122 @param to: Location to store range end. I{(gdouble*)} 5123 @return: 5124 """ 5125 return None
5126 - def get_stats( avg , ra , rms , skew , kurtosis ):
5127 """ 5128 Computes basic statistical quantities of a data field. 5129 5130 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(float)} 5131 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(float)} 5132 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5133 or B{C{NULL}}. I{(float)} 5134 @param skew: Where skew (symmetry of height distribution) should be stored, or 5135 B{C{NULL}}. I{(float)} 5136 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5137 stored, or B{C{NULL}}. I{(float)} 5138 @return: 5139 """ 5140 return None
5141 - def area_get_stats( mask , col , row , width , height , avg , ra , rms , skew , kurtosis ):
5142 """ 5143 Computes basic statistical quantities of a rectangular part of a data field. 5144 5145 This function is equivalent to calling B{C{L{DataField.area_get_stats_mask}}}() 5146 with masking mode B{C{MASK_INCLUDE}}. 5147 5148 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5149 @param col: Upper-left column coordinate. I{(int)} 5150 @param row: Upper-left row coordinate. I{(int)} 5151 @param width: Area width (number of columns). I{(int)} 5152 @param height: Area height (number of rows). I{(int)} 5153 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(float)} 5154 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(float)} 5155 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5156 or B{C{NULL}}. I{(float)} 5157 @param skew: Where skew (symmetry of height distribution) should be stored, or 5158 B{C{NULL}}. I{(float)} 5159 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5160 stored, or B{C{NULL}}. I{(float)} 5161 @return: 5162 """ 5163 return None
5164 - def UNIMPLEMENTED_area_get_stats_mask( mask , mode , col , row , width , height , avg , ra , rms , skew , kurtosis ):
5165 """ 5166 Computes basic statistical quantities of a rectangular part of a data field. 5167 5168 Since: 2.18 5169 5170 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5171 @param mode: Masking mode to use. See the introduction for description of 5172 masking modes. I{(MaskingType)} 5173 @param col: Upper-left column coordinate. I{(int)} 5174 @param row: Upper-left row coordinate. I{(int)} 5175 @param width: Area width (number of columns). I{(int)} 5176 @param height: Area height (number of rows). I{(int)} 5177 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(gdouble*)} 5178 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(gdouble*)} 5179 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5180 or B{C{NULL}}. I{(gdouble*)} 5181 @param skew: Where skew (symmetry of height distribution) should be stored, or 5182 B{C{NULL}}. I{(gdouble*)} 5183 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5184 stored, or B{C{NULL}}. I{(gdouble*)} 5185 @return: 5186 """ 5187 return None
5188 - def area_count_in_range( mask , col , row , width , height , below , above , nbelow , nabove ):
5189 """ 5190 Counts data samples in given range. 5191 5192 No assertion is made about the values of B{C{above}} and B{C{below}}, in other words 5193 B{C{above}} may be larger than B{C{below}}. To count samples in an open interval 5194 instead of a closed interval, exchange B{C{below}} and B{C{above}} and then subtract 5195 the B{C{nabove}} and B{C{nbelow}} from B{C{width}}*B{C{height}} to get the complementary counts. 5196 5197 With this trick the common task of counting positive values can be 5198 realized: 5199 <informalexample><programlisting> 5200 L{DataField.area_count_in_range}(data_field, NULL, 5201 col, row, width, height, 5202 0.0, 0.0, &amp;count, NULL); 5203 count = width*height - count; 5204 </programlisting></informalexample> 5205 5206 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5207 @param col: Upper-left column coordinate. I{(int)} 5208 @param row: Upper-left row coordinate. I{(int)} 5209 @param width: Area width (number of columns). I{(int)} 5210 @param height: Area height (number of rows). I{(int)} 5211 @param below: Upper bound to compare data to. The number of samples less 5212 than or equal to B{C{below}} is stored in B{C{nbelow}}. I{(float)} 5213 @param above: Lower bound to compare data to. The number of samples greater 5214 than or equal to B{C{above}} is stored in B{C{nabove}}. I{(float)} 5215 @param nbelow: Location to store the number of samples less than or equal 5216 to B{C{below}}, or B{C{NULL}}. I{(int)} 5217 @param nabove: Location to store the number of samples greater than or equal 5218 to B{C{above}}, or B{C{NULL}}. I{(int)} 5219 @return: 5220 """ 5221 return None
5222 - def area_dh( mask , target_line , col , row , width , height , nstats ):
5223 """ 5224 Calculates distribution of heights in a rectangular part of data field. 5225 5226 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5227 @param target_line: A data line to store the distribution to. It will be 5228 resampled to requested width. I{(L{DataLine})} 5229 @param col: Upper-left column coordinate. I{(int)} 5230 @param row: Upper-left row coordinate. I{(int)} 5231 @param width: Area width (number of columns). I{(int)} 5232 @param height: Area height (number of rows). I{(int)} 5233 @param nstats: The number of samples to take on the distribution function. If 5234 nonpositive, a suitable resolution is determined automatically. I{(int)} 5235 @return: 5236 """ 5237 return None
5238 - def dh( target_line , nstats ):
5239 """ 5240 Calculates distribution of heights in a data field. 5241 5242 @param target_line: A data line to store the distribution to. It will be 5243 resampled to requested width. I{(L{DataLine})} 5244 @param nstats: The number of samples to take on the distribution function. If 5245 nonpositive, a suitable resolution is determined automatically. I{(int)} 5246 @return: 5247 """ 5248 return None
5249 - def area_cdh( mask , target_line , col , row , width , height , nstats ):
5250 """ 5251 Calculates uncertainty of the cumulative distribution of heights in a 5252 rectangular part of the data field. 5253 5254 Since: 2.23 5255 5256 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5257 @param uncz_field: Corresponding uncertainty data field. 5258 @param target_line: A data line to store the distribution to. It will be 5259 resampled to requested width. I{(L{DataLine})} 5260 @param col: Upper-left column coordinate. I{(int)} 5261 @param row: Upper-left row coordinate. I{(int)} 5262 @param width: Area width (number of columns). I{(int)} 5263 @param height: Area height (number of rows). I{(int)} 5264 @param nstats: The number of samples to take on the distribution function. If 5265 nonpositive, a suitable resolution is determined automatically. I{(int)} 5266 @return: 5267 """ 5268 return None
5269 - def cdh( target_line , nstats ):
5270 """ 5271 Calculates cumulative distribution of heights in a data field. 5272 5273 @param target_line: A data line to store the distribution to. It will be 5274 resampled to requested width. I{(L{DataLine})} 5275 @param nstats: The number of samples to take on the distribution function. If 5276 nonpositive, a suitable resolution is determined automatically. I{(int)} 5277 @return: 5278 """ 5279 return None
5280 - def area_da( target_line , col , row , width , height , orientation , nstats ):
5281 """ 5282 Calculates distribution of slopes in a rectangular part of data field. 5283 5284 @param target_line: A data line to store the distribution to. It will be 5285 resampled to requested width. I{(L{DataLine})} 5286 @param col: Upper-left column coordinate. I{(int)} 5287 @param row: Upper-left row coordinate. I{(int)} 5288 @param width: Area width (number of columns). I{(int)} 5289 @param height: Area height (number of rows). I{(int)} 5290 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 5291 @param nstats: The number of samples to take on the distribution function. If 5292 nonpositive, a suitable resolution is determined automatically. I{(int)} 5293 @return: 5294 """ 5295 return None
5296 - def da( target_line , orientation , nstats ):
5297 """ 5298 Calculates distribution of slopes in a data field. 5299 5300 @param target_line: A data line to store the distribution to. It will be 5301 resampled to requested width. I{(L{DataLine})} 5302 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 5303 @param nstats: The number of samples to take on the distribution function. If 5304 nonpositive, a suitable resolution is determined automatically. I{(int)} 5305 @return: 5306 """ 5307 return None
5308 - def area_cda( target_line , col , row , width , height , orientation , nstats ):
5309 """ 5310 Calculates cumulative distribution of slopes in a rectangular part of data 5311 field. 5312 5313 @param target_line: A data line to store the distribution to. It will be 5314 resampled to requested width. I{(L{DataLine})} 5315 @param col: Upper-left column coordinate. I{(int)} 5316 @param row: Upper-left row coordinate. I{(int)} 5317 @param width: Area width (number of columns). I{(int)} 5318 @param height: Area height (number of rows). I{(int)} 5319 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 5320 @param nstats: The number of samples to take on the distribution function. If 5321 nonpositive, a suitable resolution is determined automatically. I{(int)} 5322 @return: 5323 """ 5324 return None
5325 - def cda( target_line , orientation , nstats ):
5326 """ 5327 Calculates cumulative distribution of slopes in a data field. 5328 5329 @param target_line: A data line to store the distribution to. It will be 5330 resampled to requested width. I{(L{DataLine})} 5331 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 5332 @param nstats: The number of samples to take on the distribution function. If 5333 nonpositive, a suitable resolution is determined automatically. I{(int)} 5334 @return: 5335 """ 5336 return None
5337 - def area_acf( target_line , col , row , width , height , orientation , interpolation , nstats ):
5338 """ 5339 Calculates one-dimensional autocorrelation function of a rectangular part of 5340 a data field. 5341 5342 @param target_line: A data line to store the distribution to. It will be 5343 resampled to requested width. I{(L{DataLine})} 5344 @param col: Upper-left column coordinate. I{(int)} 5345 @param row: Upper-left row coordinate. I{(int)} 5346 @param width: Area width (number of columns). I{(int)} 5347 @param height: Area height (number of rows). I{(int)} 5348 @param orientation: Orientation of lines (ACF is simply averaged over the 5349 other orientation). I{(Orientation)} 5350 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 5351 resampling. I{(InterpolationType)} 5352 @param nstats: The number of samples to take on the distribution function. If 5353 nonpositive, B{C{width}} (B{C{height}}) is used. I{(int)} 5354 @return: 5355 """ 5356 return None
5357 - def acf( target_line , orientation , interpolation , nstats ):
5358 """ 5359 Calculates one-dimensional autocorrelation function of a data field. 5360 5361 @param target_line: A data line to store the distribution to. It will be 5362 resampled to requested width. I{(L{DataLine})} 5363 @param orientation: Orientation of lines (ACF is simply averaged over the 5364 other orientation). I{(Orientation)} 5365 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 5366 resampling. I{(InterpolationType)} 5367 @param nstats: The number of samples to take on the distribution function. If 5368 nonpositive, data field width (height) is used. I{(int)} 5369 @return: 5370 """ 5371 return None
5372 - def area_hhcf( target_line , col , row , width , height , orientation , interpolation , nstats ):
5373 """ 5374 Calculates one-dimensional autocorrelation function of a rectangular part of 5375 a data field. 5376 5377 @param target_line: A data line to store the distribution to. It will be 5378 resampled to requested width. I{(L{DataLine})} 5379 @param col: Upper-left column coordinate. I{(int)} 5380 @param row: Upper-left row coordinate. I{(int)} 5381 @param width: Area width (number of columns). I{(int)} 5382 @param height: Area height (number of rows). I{(int)} 5383 @param orientation: Orientation of lines (HHCF is simply averaged over the 5384 other orientation). I{(Orientation)} 5385 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 5386 resampling. I{(InterpolationType)} 5387 @param nstats: The number of samples to take on the distribution function. If 5388 nonpositive, B{C{width}} (B{C{height}}) is used. I{(int)} 5389 @return: 5390 """ 5391 return None
5392 - def hhcf( target_line , orientation , interpolation , nstats ):
5393 """ 5394 Calculates one-dimensional autocorrelation function of a data field. 5395 5396 @param target_line: A data line to store the distribution to. It will be 5397 resampled to requested width. I{(L{DataLine})} 5398 @param orientation: Orientation of lines (HHCF is simply averaged over the 5399 other orientation). I{(Orientation)} 5400 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 5401 resampling. I{(InterpolationType)} 5402 @param nstats: The number of samples to take on the distribution function. If 5403 nonpositive, data field width (height) is used. I{(int)} 5404 @return: 5405 """ 5406 return None