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 The function does not assign pixels with value B{C{HUGE_VAL}} or larger to any 4043 segment. This can be used to pre-mark certain areas explicitly as 4044 boundaries. 4045 4046 Since the algorithm numbers the grains as a side effect, you can pass a 4047 B{C{grains}} array and get the grain numbers immediatelly, avoiding the 4048 relatively (although not drastically) expensive 4049 L{DataField.number_grains}() call. 4050 4051 Since: 2.37 4052 4053 @param result: Data field that will be filled with the resulting mask. It will be 4054 resized to the dimensions of B{C{data_field}} and its properties set 4055 accordingly. I{(L{DataField})} 4056 @param grains: Optionally, an array with the same number of items as B{C{data_field}}. 4057 If non-B{C{NULL}}, it will be filled with grain numbers in the same 4058 manner as L{DataField.number_grains}(). Pass B{C{NULL}} to ignore. I{(gint*)} 4059 @return: The number of segments (grains) in the result, excluding the 4060 separators, i.e. the same convention as in 4061 L{DataField.number_grains}() is used. 4062 4063 4064 """ 4065 return None
4066 - def mark_extrema( extrema , maxima ):
4067 return None
4068 - def hough_line( x_gradient , y_gradient , result , hwidth , overlapping ):
4069 return None
4070 - def hough_circle( x_gradient , y_gradient , result , radius ):
4071 return None
4072 - def hough_line_strenghten( x_gradient , y_gradient , hwidth , threshold ):
4073 return None
4074 - def hough_circle_strenghten( x_gradient , y_gradient , radius , threshold ):
4075 return None
4076 - def UNIMPLEMENTED_get_local_maxima_list( xdata , ydata , zdata , ndata , skip , threshold , subpixel ):
4077 return None
4078 - def hough_polar_line_to_datafield( rho , theta , px1 , px2 , py1 , py2 ):
4079 return None
4080 - def a_1dfft( iin , rout , iout , orientation , windowing , direction , interpolation , preserverms , level ):
4081 """ 4082 Transforms all rows or columns in a data field with Fast Fourier Transform. 4083 4084 If requested a windowing and/or leveling is applied to preprocess data to 4085 obtain reasonable results. 4086 4087 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4088 transform which can be somewhat faster than complex-to-complex 4089 transform. I{(L{DataField})} 4090 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4091 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4092 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4093 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4094 columns. I{(Orientation)} 4095 @param windowing: Windowing type. I{(WindowingType)} 4096 @param direction: FFT direction. I{(TransformDirection)} 4097 @param interpolation: Interpolation type. 4098 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4099 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4100 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4101 line (the number can be interpreted as the first polynomial degree 4102 to keep, but only the enumerated three values are available). I{(int)} 4103 @return: 4104 """ 4105 return None
4106 - def area_1dfft( iin , rout , iout , col , row , width , height , orientation , windowing , direction , interpolation , preserverms , level ):
4107 """ 4108 Transforms all rows or columns in a rectangular part of a data field with 4109 Fast Fourier Transform. 4110 4111 If requested a windowing and/or leveling is applied to preprocess data to 4112 obtain reasonable results. 4113 4114 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4115 transform which can be somewhat faster than complex-to-complex 4116 transform. I{(L{DataField})} 4117 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4118 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4119 @param col: Upper-left column coordinate. I{(int)} 4120 @param row: Upper-left row coordinate. I{(int)} 4121 @param width: Area width (number of columns), must be at least 2 for horizontal 4122 transforms. I{(int)} 4123 @param height: Area height (number of rows), must be at least 2 for vertical 4124 transforms. I{(int)} 4125 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4126 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4127 columns. I{(Orientation)} 4128 @param windowing: Windowing type. I{(WindowingType)} 4129 @param direction: FFT direction. I{(TransformDirection)} 4130 @param interpolation: Interpolation type. 4131 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4132 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4133 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4134 lines (the number can be interpreted as the first polynomial degree 4135 to keep, but only the enumerated three values are available). I{(int)} 4136 @return: 4137 """ 4138 return None
4139 - def a_1dfft_raw( iin , rout , iout , orientation , direction ):
4140 """ 4141 Transforms all rows or columns in a data field with Fast Fourier Transform. 4142 4143 No leveling, windowing nor scaling is performed. 4144 4145 Since 2.8 the dimensions need not to be from the set of sizes returned 4146 by L{gwy_fft_find_nice_size}(). 4147 4148 Since: 2.1 4149 4150 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4151 transform. I{(L{DataField})} 4152 @param rout: Real output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4153 @param iout: Imaginary output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4154 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 4155 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 4156 columns. I{(Orientation)} 4157 @param direction: FFT direction. I{(TransformDirection)} 4158 @return: 4159 """ 4160 return None
4161 - def a_2dfft( iin , rout , iout , windowing , direction , interpolation , preserverms , level ):
4162 """ 4163 Calculates 2D Fast Fourier Transform of a rectangular a data field. 4164 4165 If requested a windowing and/or leveling is applied to preprocess data to 4166 obtain reasonable results. 4167 4168 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4169 transform which can be somewhat faster than complex-to-complex 4170 transform. I{(L{DataField})} 4171 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4172 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4173 @param windowing: Windowing type. I{(WindowingType)} 4174 @param direction: FFT direction. I{(TransformDirection)} 4175 @param interpolation: Interpolation type. I{(InterpolationType)} 4176 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4177 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4178 plane (the number can be interpreted as the first polynomial degree 4179 to keep, but only the enumerated three values are available). I{(int)} 4180 @return: 4181 """ 4182 return None
4183 - def area_2dfft( iin , rout , iout , col , row , width , height , windowing , direction , interpolation , preserverms , level ):
4184 """ 4185 Calculates 2D Fast Fourier Transform of a rectangular area of a data field. 4186 4187 If requested a windowing and/or leveling is applied to preprocess data to 4188 obtain reasonable results. 4189 4190 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4191 transform which can be somewhat faster than complex-to-complex 4192 transform. I{(L{DataField})} 4193 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 4194 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 4195 @param col: Upper-left column coordinate. I{(int)} 4196 @param row: Upper-left row coordinate. I{(int)} 4197 @param width: Area width (number of columns), must be at least 2. I{(int)} 4198 @param height: Area height (number of rows), must be at least 2. I{(int)} 4199 @param windowing: Windowing type. I{(WindowingType)} 4200 @param direction: FFT direction. I{(TransformDirection)} 4201 @param interpolation: Interpolation type. 4202 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4203 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 4204 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 4205 plane (the number can be interpreted as the first polynomial degree 4206 to keep, but only the enumerated three values are available). I{(int)} 4207 @return: 4208 """ 4209 return None
4210 - def a_2dfft_raw( iin , rout , iout , direction ):
4211 """ 4212 Calculates 2D Fast Fourier Transform of a data field. 4213 4214 No leveling, windowing nor scaling is performed. 4215 4216 Since 2.8 the dimensions need not to be from the set of sizes returned 4217 by L{gwy_fft_find_nice_size}(). 4218 4219 Since: 2.1 4220 4221 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 4222 transform. I{(L{DataField})} 4223 @param rout: Real output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4224 @param iout: Imaginary output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 4225 @param direction: FFT direction. I{(TransformDirection)} 4226 @return: 4227 """ 4228 return None
4229 - def a_2dfft_humanize( ):
4230 """ 4231 Rearranges 2D FFT output to a human-friendly form. 4232 4233 Top-left, top-right, bottom-left and bottom-right sub-rectangles are swapped 4234 to obtain a humanized 2D FFT output with (0,0) in the centre. 4235 4236 More precisely, for even field dimensions the equally-sized blocks starting 4237 with the Nyquist frequency and with the zero frequency (constant component) 4238 will exchange places. For odd field dimensions, the block containing the 4239 zero frequency is one item larger and the constant component will actually 4240 end up in the exact centre. 4241 4242 Also note if both dimensions are even, this function is involutory and 4243 identical to L{DataField.2dfft_dehumanize}(). However, if any dimension 4244 is odd, L{DataField.2dfft_humanize}() and 4245 L{DataField.2dfft_dehumanize}() are different, therefore they must be 4246 paired properly. 4247 4248 @return: 4249 """ 4250 return None
4251 - def a_2dfft_dehumanize( ):
4252 """ 4253 Rearranges 2D FFT output back from the human-friendly form. 4254 4255 Top-left, top-right, bottom-left and bottom-right sub-rectangles are swapped 4256 to reshuffle a humanized 2D FFT output back into the natural positions. 4257 4258 See L{DataField.2dfft_humanize}() for discussion. 4259 4260 Since: 2.8 4261 4262 @return: 4263 """ 4264 return None
4265 - def fft_filter_1d( result_field , weights , orientation , interpolation ):
4266 """ 4267 Performs 1D FFT filtering of a data field. 4268 4269 @param result_field: A data field to store the result to. It will be resampled 4270 to B{C{data_field}}'s size. I{(L{DataField})} 4271 @param weights: Filter weights for the lower half of the spectrum (the other 4272 half is symmetric). Its size can be arbitrary, it will be 4273 interpolated. I{(L{DataLine})} 4274 @param orientation: Filter direction. I{(Orientation)} 4275 @param interpolation: The interpolation to use for resampling. I{(InterpolationType)} 4276 @return: 4277 """ 4278 return None
4279 - def UNIMPLEMENTED_cwt( interpolation , scale , wtype ):
4280 """ 4281 Computes a continuous wavelet transform (CWT) at given 4282 scale and using given wavelet. 4283 4284 @param interpolation: Interpolation type. 4285 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 4286 @param scale: Wavelet scale. I{(float)} 4287 @param wtype: Wavelet type. I{(2DCWTWaveletType)} 4288 @return: 4289 """ 4290 return None
4291 - def area_fit_plane( mask , col , row , width , height , pa , pbx , pby ):
4292 """ 4293 Fits a plane through a rectangular part of a data field. 4294 4295 The coefficients can be used for plane leveling using the same relation 4296 as in L{DataField.fit_plane}(), counting indices from area top left 4297 corner. 4298 4299 @param mask: Mask of values to take values into account, or B{C{NULL}} for full 4300 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4301 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4302 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4303 for values inside (0.0, 1.0) is undefined (it may be specified 4304 in the future). I{(L{DataField})} 4305 @param col: Upper-left column coordinate. I{(int)} 4306 @param row: Upper-left row coordinate. I{(int)} 4307 @param width: Area width (number of columns). I{(int)} 4308 @param height: Area height (number of rows). I{(int)} 4309 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(float)} 4310 @param pbx: Where x plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4311 @param pby: Where y plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4312 @return: 4313 """ 4314 return None
4315 - def fit_plane( pa , pbx , pby ):
4316 """ 4317 Fits a plane through a data field. 4318 4319 The coefficients can be used for plane leveling using relation 4320 data[i] := data[i] - (pa + pby*i + pbx*j); 4321 4322 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(float)} 4323 @param pbx: Where x plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4324 @param pby: Where y plane coefficient should be stored (or B{C{NULL}}). I{(float)} 4325 @return: 4326 """ 4327 return None
4328 - def plane_level( a , bx , by ):
4329 """ 4330 Subtracts plane from a data field. 4331 4332 See L{DataField.fit_plane}() for details. 4333 4334 @param a: Constant coefficient. I{(float)} 4335 @param bx: X plane coefficient. I{(float)} 4336 @param by: Y plane coefficient. I{(float)} 4337 @return: 4338 """ 4339 return None
4340 - def plane_rotate( xangle , yangle , interpolation ):
4341 """ 4342 Performs rotation of plane along x and y axis. 4343 4344 @param xangle: Rotation angle in x direction (rotation along y axis, in radians). I{(float)} 4345 @param yangle: Rotation angle in y direction (rotation along x axis, in radians). I{(float)} 4346 @param interpolation: Interpolation type (can be only of two-point type). I{(InterpolationType)} 4347 @return: 4348 """ 4349 return None
4350 - def fit_lines( col , row , width , height , degree , exclude , orientation ):
4351 """ 4352 Independently levels profiles on each row/column in a data field. 4353 4354 Lines that have no intersection with area selected by B{C{ulcol}}, B{C{ulrow}}, 4355 B{C{brcol}}, B{C{brrow}} are always leveled as a whole. Lines that have intersection 4356 with selected area, are leveled using polynomial coefficients computed only 4357 from data inside (or outside for B{C{exclude}} = B{C{True}}) the area. 4358 4359 @param col: Upper-left column coordinate. I{(int)} 4360 @param row: Upper-left row coordinate. I{(int)} 4361 @param width: Area width (number of columns). I{(int)} 4362 @param height: Area height (number of rows). I{(int)} 4363 @param degree: Fitted polynomial degree. I{(int)} 4364 @param exclude: If B{C{True}}, outside of area selected by B{C{ulcol}}, B{C{ulrow}}, B{C{brcol}}, 4365 B{C{brrow}} will be used for polynomial coefficients computation, 4366 instead of inside. I{(bool)} 4367 @param orientation: Line orientation. I{(Orientation)} 4368 @return: 4369 """ 4370 return None
4371 - def fit_polynom( col_degree , row_degree , coeffs ):
4372 """ 4373 Fits a two-dimensional polynomial to a data field. 4374 4375 4376 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4377 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4378 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4379 coefficients to, or B{C{NULL}} (a fresh array is allocated then), 4380 see L{DataField.area_fit_polynom}() for details. I{(gdouble*)} 4381 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4382 with coefficients. 4383 4384 """ 4385 return None
4386 - def area_fit_polynom( col , row , width , height , col_degree , row_degree , coeffs ):
4387 """ 4388 Fits a two-dimensional polynomial to a rectangular part of a data field. 4389 4390 The coefficients are stored by row into B{C{coeffs}}, like data in a datafield. 4391 Row index is y-degree, column index is x-degree. 4392 4393 Note naive x^n y^m polynomial fitting is numerically unstable, therefore 4394 this method works only up to B{C{col_degree}} = B{C{row_degree}} = 6. 4395 4396 4397 @param col: Upper-left column coordinate. I{(int)} 4398 @param row: Upper-left row coordinate. I{(int)} 4399 @param width: Area width (number of columns). I{(int)} 4400 @param height: Area height (number of rows). I{(int)} 4401 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4402 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4403 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4404 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4405 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4406 with coefficients. 4407 4408 """ 4409 return None
4410 - def subtract_polynom( col_degree , row_degree , coeffs ):
4411 """ 4412 Subtracts a two-dimensional polynomial from a data field. 4413 4414 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4415 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4416 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4417 see L{DataField.area_fit_polynom}() for details. I{(const-gdouble*)} 4418 @return: 4419 """ 4420 return None
4421 - def area_subtract_polynom( col , row , width , height , col_degree , row_degree , coeffs ):
4422 """ 4423 Subtracts a two-dimensional polynomial from a rectangular part of a data 4424 field. 4425 4426 @param col: Upper-left column coordinate. I{(int)} 4427 @param row: Upper-left row coordinate. I{(int)} 4428 @param width: Area width (number of columns). I{(int)} 4429 @param height: Area height (number of rows). I{(int)} 4430 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4431 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4432 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4433 see L{DataField.area_fit_polynom}() for details. I{(const-gdouble*)} 4434 @return: 4435 """ 4436 return None
4437 - def UNIMPLEMENTED_fit_legendre( col_degree , row_degree , coeffs ):
4438 """ 4439 Fits two-dimensional Legendre polynomial to a data field. 4440 4441 See L{DataField.area_fit_legendre}() for details. 4442 4443 4444 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4445 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4446 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4447 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4448 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4449 with coefficients. 4450 4451 """ 4452 return None
4453 - def UNIMPLEMENTED_area_fit_legendre( col , row , width , height , col_degree , row_degree , coeffs ):
4454 """ 4455 Fits two-dimensional Legendre polynomial to a rectangular part of a data 4456 field. 4457 4458 The B{C{col_degree}} and B{C{row_degree}} parameters limit the maximum powers of x and 4459 y exactly as if simple powers were fitted, therefore if you do not intend to 4460 interpret contents of B{C{coeffs}} youself, the only difference is that this 4461 method is much more numerically stable. 4462 4463 The coefficients are organized exactly like in 4464 L{DataField.area_fit_polynom}(), but they are not coefficients of 4465 x^n y^m, instead they are coefficients of P_n(x) P_m(x), where P are 4466 Legendre polynomials. The polynomials are evaluated in coordinates where 4467 first row (column) corresponds to -1.0, and the last row (column) to 1.0. 4468 4469 Note the polynomials are normal Legendre polynomials that are not exactly 4470 orthogonal on a discrete point set (if their degrees are equal mod 2). 4471 4472 4473 @param col: Upper-left column coordinate. I{(int)} 4474 @param row: Upper-left row coordinate. I{(int)} 4475 @param width: Area width (number of columns). I{(int)} 4476 @param height: Area height (number of rows). I{(int)} 4477 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4478 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4479 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 4480 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4481 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4482 with coefficients. 4483 4484 """ 4485 return None
4486 - def subtract_legendre( col_degree , row_degree , coeffs ):
4487 """ 4488 Subtracts a two-dimensional Legendre polynomial fit from a data field. 4489 4490 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4491 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4492 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4493 see L{DataField.area_fit_legendre}() for details. I{(const-gdouble*)} 4494 @return: 4495 """ 4496 return None
4497 - def area_subtract_legendre( col , row , width , height , col_degree , row_degree , coeffs ):
4498 """ 4499 Subtracts a two-dimensional Legendre polynomial fit from a rectangular part 4500 of a data field. 4501 4502 Due to the transform of coordinates to [-1,1] x [-1,1], this method can be 4503 used on an area of dimensions different than the area the coefficients were 4504 calculated for. 4505 4506 @param col: Upper-left column coordinate. I{(int)} 4507 @param row: Upper-left row coordinate. I{(int)} 4508 @param width: Area width (number of columns). I{(int)} 4509 @param height: Area height (number of rows). I{(int)} 4510 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 4511 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 4512 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 4513 see L{DataField.area_fit_legendre}() for details. I{(const-gdouble*)} 4514 @return: 4515 """ 4516 return None
4517 - def UNIMPLEMENTED_fit_poly_max( max_degree , coeffs ):
4518 """ 4519 Fits two-dimensional polynomial with limited total degree to a data field. 4520 4521 See L{DataField.area_fit_poly_max}() for details. 4522 4523 4524 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4525 in x^n y^m terms. I{(int)} 4526 @param coeffs: An array of size (B{C{max_degree}}+1)*(B{C{max_degree}}+2)/2 to store the 4527 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4528 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4529 with coefficients. 4530 4531 """ 4532 return None
4533 - def UNIMPLEMENTED_area_fit_poly_max( col , row , width , height , max_degree , coeffs ):
4534 """ 4535 Fits two-dimensional polynomial with limited total degree to a rectangular 4536 part of a data field. 4537 4538 See L{DataField.area_fit_legendre}() for description. This function 4539 differs by limiting the total maximum degree, while 4540 L{DataField.area_fit_legendre}() limits the maximum degrees in horizontal 4541 and vertical directions independently. 4542 4543 4544 @param col: Upper-left column coordinate. I{(int)} 4545 @param row: Upper-left row coordinate. I{(int)} 4546 @param width: Area width (number of columns). I{(int)} 4547 @param height: Area height (number of rows). I{(int)} 4548 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4549 in x^n y^m terms. I{(int)} 4550 @param coeffs: An array of size (B{C{max_degree}}+1)*(B{C{max_degree}}+2)/2 to store the 4551 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 4552 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4553 with coefficients. 4554 4555 """ 4556 return None
4557 - def subtract_poly_max( max_degree , coeffs ):
4558 """ 4559 Subtracts a two-dimensional polynomial with limited total degree from 4560 a data field. 4561 4562 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4563 in x^n y^m terms. I{(int)} 4564 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+2)/2 with 4565 coefficients, see L{DataField.area_fit_poly_max}() for details. I{(const-gdouble*)} 4566 @return: 4567 """ 4568 return None
4569 - def area_subtract_poly_max( col , row , width , height , max_degree , coeffs ):
4570 """ 4571 Subtracts a two-dimensional polynomial with limited total degree from a 4572 rectangular part of a data field. 4573 4574 Due to the transform of coordinates to [-1,1] x [-1,1], this method can be 4575 used on an area of dimensions different than the area the coefficients were 4576 calculated for. 4577 4578 @param col: Upper-left column coordinate. I{(int)} 4579 @param row: Upper-left row coordinate. I{(int)} 4580 @param width: Area width (number of columns). I{(int)} 4581 @param height: Area height (number of rows). I{(int)} 4582 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 4583 in x^n y^m terms. I{(int)} 4584 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+2)/2 with 4585 coefficients, see L{DataField.area_fit_poly_max}() for details. I{(const-gdouble*)} 4586 @return: 4587 """ 4588 return None
4589 - def fit_poly( mask_field , nterms , term_powers , exclude , coeffs ):
4590 """ 4591 Fit a given set of polynomial terms to a data field. 4592 4593 Since: 2.11 4594 4595 @param mask_field: Mask of values to take values into account, or B{C{NULL}} for full 4596 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4597 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4598 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4599 for values inside (0.0, 1.0) is undefined (it may be specified 4600 in the future). I{(L{DataField})} 4601 @param nterms: The number of polynomial terms to take into account (half the 4602 number of items in B{C{term_powers}}). I{(int)} 4603 @param term_powers: Array of size 2*B{C{nterms}} describing the terms to fit. Each 4604 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4605 @param exclude: Interpret values B{C{w}} in the mask as 1.0-B{C{w}}. I{(bool)} 4606 @param coeffs: Array of size B{C{nterms}} to store the coefficients to, or B{C{NULL}} to 4607 allocate a new array. I{(gdouble*)} 4608 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4609 with coefficients. 4610 4611 4612 """ 4613 return None
4614 - def area_fit_poly( mask_field , col , row , width , height , nterms , term_powers , exclude , coeffs ):
4615 """ 4616 Fit a given set of polynomial terms to a rectangular part of a data field. 4617 4618 The polynomial coefficients correspond to normalized coordinates that 4619 are always from the interval [-1,1] where -1 corresponds to the left/topmost 4620 pixel and 1 corresponds to the bottom/rightmost pixel of the area. 4621 4622 Since: 2.11 4623 4624 @param mask_field: Mask of values to take values into account, or B{C{NULL}} for full 4625 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 4626 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 4627 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 4628 for values inside (0.0, 1.0) is undefined (it may be specified 4629 in the future). I{(L{DataField})} 4630 @param col: Upper-left column coordinate. I{(int)} 4631 @param row: Upper-left row coordinate. I{(int)} 4632 @param width: Area width (number of columns). I{(int)} 4633 @param height: Area height (number of rows). I{(int)} 4634 @param nterms: The number of polynomial terms to take into account (half the 4635 number of items in B{C{term_powers}}). I{(int)} 4636 @param term_powers: Array of size 2*B{C{nterms}} describing the terms to fit. Each 4637 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4638 @param exclude: Interpret values B{C{w}} in the mask as 1.0-B{C{w}}. I{(bool)} 4639 @param coeffs: Array of size B{C{nterms}} to store the coefficients to, or B{C{NULL}} to 4640 allocate a new array. I{(gdouble*)} 4641 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 4642 with coefficients. 4643 4644 4645 """ 4646 return None
4647 - def subtract_poly( nterms , term_powers , coeffs ):
4648 """ 4649 Subtract a given set of polynomial terms from a data field. 4650 4651 Since: 2.11 4652 4653 @param nterms: The number of polynomial terms to take into account (half the 4654 number of items in B{C{term_powers}}). I{(int)} 4655 @param term_powers: Array of size 2*B{C{nterms}} describing the fitter terms. Each 4656 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4657 @param coeffs: Array of size B{C{nterms}} to store with the coefficients. I{(const-gdouble*)} 4658 @return: 4659 """ 4660 return None
4661 - def area_subtract_poly( col , row , width , height , nterms , term_powers , coeffs ):
4662 """ 4663 Subtract a given set of polynomial terms from a rectangular part of a data 4664 field. 4665 4666 Since: 2.11 4667 4668 @param col: Upper-left column coordinate. I{(int)} 4669 @param row: Upper-left row coordinate. I{(int)} 4670 @param width: Area width (number of columns). I{(int)} 4671 @param height: Area height (number of rows). I{(int)} 4672 @param nterms: The number of polynomial terms to take into account (half the 4673 number of items in B{C{term_powers}}). I{(int)} 4674 @param term_powers: Array of size 2*B{C{nterms}} describing the fitted terms. Each 4675 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 4676 @param coeffs: Array of size B{C{nterms}} to store with the coefficients. I{(const-gdouble*)} 4677 @return: 4678 """ 4679 return None
4680 - def UNIMPLEMENTED_area_fit_local_planes( size , col , row , width , height , nresults , types , results ):
4681 """ 4682 Fits a plane through neighbourhood of each sample in a rectangular part 4683 of a data field. 4684 4685 The sample is always in the origin of its local (x,y) coordinate system, 4686 even if the neighbourhood is not centered about it (e.g. because sample 4687 is on the edge of data field). Z-coordinate is however not centered, 4688 that is B{C{PLANE_FIT_A}} is normal mean value. 4689 4690 4691 @param size: Neighbourhood size (must be at least 2). It is centered around 4692 each pixel, unless B{C{size}} is even when it sticks to the right. I{(int)} 4693 @param col: Upper-left column coordinate. I{(int)} 4694 @param row: Upper-left row coordinate. I{(int)} 4695 @param width: Area width (number of columns). I{(int)} 4696 @param height: Area height (number of rows). I{(int)} 4697 @param nresults: The number of requested quantities. I{(int)} 4698 @param types: The types of requested quantities. I{(const-PlaneFitQuantity*)} 4699 @param results: An array to store quantities to, may be B{C{NULL}} to allocate a new 4700 one which must be freed by caller then. If any item is B{C{NULL}}, 4701 a new data field is allocated for it, existing data fields 4702 are resized to B{C{width}} x B{C{height}}. I{(DataField**)} 4703 @return: An array of data fields with requested quantities, that is 4704 B{C{results}} unless it was B{C{NULL}} and a new array was allocated. 4705 4706 """ 4707 return None
4708 - def area_local_plane_quantity( size , col , row , width , height , type , result ):
4709 """ 4710 Convenience function to get just one quantity from 4711 L{DataField.area_fit_local_planes}(). 4712 4713 4714 @param size: Neighbourhood size. I{(int)} 4715 @param col: Upper-left column coordinate. I{(int)} 4716 @param row: Upper-left row coordinate. I{(int)} 4717 @param width: Area width (number of columns). I{(int)} 4718 @param height: Area height (number of rows). I{(int)} 4719 @param type: The type of requested quantity. I{(PlaneFitQuantity)} 4720 @param result: A data field to store result to, or B{C{NULL}} to allocate a new one. I{(L{DataField})} 4721 @return: B{C{result}} if it isn't B{C{NULL}}, otherwise a newly allocated data field. 4722 4723 """ 4724 return None
4725 - def UNIMPLEMENTED_fit_local_planes( size , nresults , types , results ):
4726 """ 4727 Fits a plane through neighbourhood of each sample in a data field. 4728 4729 See L{DataField.area_fit_local_planes}() for details. 4730 4731 4732 @param size: Neighbourhood size. I{(int)} 4733 @param nresults: The number of requested quantities. I{(int)} 4734 @param types: The types of requested quantities. I{(const-PlaneFitQuantity*)} 4735 @param results: An array to store quantities to. I{(DataField**)} 4736 @return: An array of data fields with requested quantities. 4737 4738 """ 4739 return None
4740 - def local_plane_quantity( size , type , result ):
4741 """ 4742 Convenience function to get just one quantity from 4743 L{DataField.fit_local_planes}(). 4744 4745 4746 @param size: Neighbourhood size. I{(int)} 4747 @param type: The type of requested quantity. I{(PlaneFitQuantity)} 4748 @param result: A data field to store result to, or B{C{NULL}} to allocate a new one. I{(L{DataField})} 4749 @return: B{C{result}} if it isn't B{C{NULL}}, otherwise a newly allocated data field. 4750 4751 """ 4752 return None
4753 - def get_max( ):
4754 """ 4755 Finds the maximum value of a data field. 4756 4757 This quantity is cached. 4758 4759 4760 @return: The maximum value. 4761 4762 """ 4763 return None
4764 - def get_min( ):
4765 """ 4766 Finds the minimum value of a data field. 4767 4768 This quantity is cached. 4769 4770 4771 @return: The minimum value. 4772 4773 """ 4774 return None
4775 - def get_min_max( min , max ):
4776 """ 4777 Finds minimum and maximum values of a data field. 4778 4779 @param min: Location to store minimum to. I{(float)} 4780 @param max: Location to store maximum to. I{(float)} 4781 @return: 4782 """ 4783 return None
4784 - def get_avg( ):
4785 """ 4786 Computes average value of a data field. 4787 4788 This quantity is cached. 4789 4790 4791 @return: The average value. 4792 4793 """ 4794 return None
4795 - def get_rms( ):
4796 """ 4797 Computes root mean square value of a data field. 4798 4799 This quantity is cached. 4800 4801 4802 @return: The root mean square value. 4803 4804 """ 4805 return None
4806 - def get_sum( ):
4807 """ 4808 Sums all values in a data field. 4809 4810 This quantity is cached. 4811 4812 4813 @return: The sum of all values. 4814 4815 """ 4816 return None
4817 - def get_median( ):
4818 """ 4819 Computes median value of a data field. 4820 4821 This quantity is cached. 4822 4823 4824 @return: The median value. 4825 4826 """ 4827 return None
4828 - def get_surface_area( ):
4829 """ 4830 Computes surface area of a data field. 4831 4832 This quantity is cached. 4833 4834 4835 @return: surface area 4836 4837 """ 4838 return None
4839 - def area_get_max( mask , col , row , width , height ):
4840 """ 4841 Finds the maximum value in a rectangular part of a data field. 4842 4843 4844 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4845 @param col: Upper-left column coordinate. I{(int)} 4846 @param row: Upper-left row coordinate. I{(int)} 4847 @param width: Area width (number of columns). I{(int)} 4848 @param height: Area height (number of rows). I{(int)} 4849 @return: The maximum value. When the number of samples to calculate 4850 maximum of is zero, -B{C{G_MAXDOUBLE}} is returned. 4851 4852 """ 4853 return None
4854 - def area_get_min( mask , col , row , width , height ):
4855 """ 4856 Finds the minimum value in a rectangular part of a data field. 4857 4858 4859 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4860 @param col: Upper-left column coordinate. I{(int)} 4861 @param row: Upper-left row coordinate. I{(int)} 4862 @param width: Area width (number of columns). I{(int)} 4863 @param height: Area height (number of rows). I{(int)} 4864 @return: The minimum value. When the number of samples to calculate 4865 minimum of is zero, -B{C{G_MAXDOUBLE}} is returned. 4866 4867 """ 4868 return None
4869 - def UNIMPLEMENTED_area_get_min_max( mask , col , row , width , height , min , max ):
4870 """ 4871 Finds minimum and maximum values in a rectangular part of a data field. 4872 4873 This function is equivalent to calling 4874 B{C{L{DataField.area_get_min_max_mask}}}() 4875 with masking mode B{C{MASK_INCLUDE}}. 4876 4877 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4878 @param col: Upper-left column coordinate. I{(int)} 4879 @param row: Upper-left row coordinate. I{(int)} 4880 @param width: Area width (number of columns). I{(int)} 4881 @param height: Area height (number of rows). I{(int)} 4882 @param min: Location to store minimum to. I{(gdouble*)} 4883 @param max: Location to store maximum to. I{(gdouble*)} 4884 @return: 4885 """ 4886 return None
4887 - def UNIMPLEMENTED_area_get_min_max_mask( mask , mode , col , row , width , height , min , max ):
4888 """ 4889 Finds minimum and maximum values in a rectangular part of a data field. 4890 4891 Since: 2.18 4892 4893 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4894 @param mode: Masking mode to use. See the introduction for description of 4895 masking modes. I{(MaskingType)} 4896 @param col: Upper-left column coordinate. I{(int)} 4897 @param row: Upper-left row coordinate. I{(int)} 4898 @param width: Area width (number of columns). I{(int)} 4899 @param height: Area height (number of rows). I{(int)} 4900 @param min: Location to store minimum to. I{(gdouble*)} 4901 @param max: Location to store maximum to. I{(gdouble*)} 4902 @return: 4903 """ 4904 return None
4905 - def area_get_avg( mask , col , row , width , height ):
4906 """ 4907 Computes average value of a rectangular part of a data field. 4908 4909 This function is equivalent to calling B{C{L{DataField.area_get_avg_mask}}}() 4910 with masking mode B{C{MASK_INCLUDE}}. 4911 4912 4913 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4914 @param col: Upper-left column coordinate. I{(int)} 4915 @param row: Upper-left row coordinate. I{(int)} 4916 @param width: Area width (number of columns). I{(int)} 4917 @param height: Area height (number of rows). I{(int)} 4918 @return: The average value. 4919 4920 """ 4921 return None
4922 - def area_get_avg_mask( mask , mode , col , row , width , height ):
4923 """ 4924 Computes average value of a rectangular part of a data field. 4925 4926 Since: 2.18 4927 4928 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4929 @param mode: Masking mode to use. See the introduction for description of 4930 masking modes. I{(MaskingType)} 4931 @param col: Upper-left column coordinate. I{(int)} 4932 @param row: Upper-left row coordinate. I{(int)} 4933 @param width: Area width (number of columns). I{(int)} 4934 @param height: Area height (number of rows). I{(int)} 4935 @return: The average value. 4936 4937 4938 """ 4939 return None
4940 - def area_get_rms( mask , col , row , width , height ):
4941 """ 4942 Computes root mean square value of a rectangular part of a data field. 4943 4944 4945 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4946 @param col: Upper-left column coordinate. I{(int)} 4947 @param row: Upper-left row coordinate. I{(int)} 4948 @param width: Area width (number of columns). I{(int)} 4949 @param height: Area height (number of rows). I{(int)} 4950 @return: The root mean square value. 4951 4952 This function is equivalent to calling B{C{L{DataField.area_get_rms_mask}}}() 4953 with masking mode B{C{MASK_INCLUDE}}. 4954 4955 """ 4956 return None
4957 - def area_get_rms_mask( mask , mode , col , row , width , height ):
4958 """ 4959 Computes root mean square value of deviations of a rectangular part of a 4960 data field. 4961 4962 Since: 2.18 4963 4964 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4965 @param mode: Masking mode to use. See the introduction for description of 4966 masking modes. I{(MaskingType)} 4967 @param col: Upper-left column coordinate. I{(int)} 4968 @param row: Upper-left row coordinate. I{(int)} 4969 @param width: Area width (number of columns). I{(int)} 4970 @param height: Area height (number of rows). I{(int)} 4971 @return: The root mean square value of deviations from the mean value. 4972 4973 4974 """ 4975 return None
4976 - def area_get_grainwise_rms( mask , mode , col , row , width , height ):
4977 """ 4978 Computes grain-wise root mean square value of deviations of a rectangular 4979 part of a data field. 4980 4981 Grain-wise means that the mean value is determined for each grain (i.e. 4982 cotinguous part of the mask or inverted mask) separately and the deviations 4983 are calculated from these mean values. 4984 4985 Since: 2.29 4986 4987 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4988 @param mode: Masking mode to use. See the introduction for description of 4989 masking modes. I{(MaskingType)} 4990 @param col: Upper-left column coordinate. I{(int)} 4991 @param row: Upper-left row coordinate. I{(int)} 4992 @param width: Area width (number of columns). I{(int)} 4993 @param height: Area height (number of rows). I{(int)} 4994 @return: The root mean square value of deviations from the mean value. 4995 4996 4997 """ 4998 return None
4999 - def area_get_sum( mask , col , row , width , height ):
5000 """ 5001 Sums values of a rectangular part of a data field. 5002 5003 This function is equivalent to calling B{C{L{DataField.area_get_sum_mask}}}() 5004 with masking mode B{C{MASK_INCLUDE}}. 5005 5006 5007 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5008 @param col: Upper-left column coordinate. I{(int)} 5009 @param row: Upper-left row coordinate. I{(int)} 5010 @param width: Area width (number of columns). I{(int)} 5011 @param height: Area height (number of rows). I{(int)} 5012 @return: The sum of all values inside area. 5013 5014 """ 5015 return None
5016 - def area_get_sum_mask( mask , mode , col , row , width , height ):
5017 """ 5018 Sums values of a rectangular part of a data field. 5019 5020 Since: 2.18 5021 5022 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5023 @param mode: Masking mode to use. See the introduction for description of 5024 masking modes. I{(MaskingType)} 5025 @param col: Upper-left column coordinate. I{(int)} 5026 @param row: Upper-left row coordinate. I{(int)} 5027 @param width: Area width (number of columns). I{(int)} 5028 @param height: Area height (number of rows). I{(int)} 5029 @return: The sum of all values inside area. 5030 5031 5032 """ 5033 return None
5034 - def area_get_median( mask , col , row , width , height ):
5035 """ 5036 Computes median value of a data field area. 5037 5038 This function is equivalent to calling 5039 B{C{L{DataField.area_get_median_mask}}}() 5040 with masking mode B{C{MASK_INCLUDE}}. 5041 5042 5043 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5044 @param col: Upper-left column coordinate. I{(int)} 5045 @param row: Upper-left row coordinate. I{(int)} 5046 @param width: Area width (number of columns). I{(int)} 5047 @param height: Area height (number of rows). I{(int)} 5048 @return: The median value. 5049 5050 """ 5051 return None
5052 - def area_get_median_mask( mask , mode , col , row , width , height ):
5053 """ 5054 Computes median value of a data field area. 5055 5056 Since: 2.18 5057 5058 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5059 @param mode: Masking mode to use. See the introduction for description of 5060 masking modes. I{(MaskingType)} 5061 @param col: Upper-left column coordinate. I{(int)} 5062 @param row: Upper-left row coordinate. I{(int)} 5063 @param width: Area width (number of columns). I{(int)} 5064 @param height: Area height (number of rows). I{(int)} 5065 @return: The median value. 5066 5067 5068 """ 5069 return None
5070 - def area_get_surface_area( mask , col , row , width , height ):
5071 return None
5072 - def area_get_surface_area_mask( mask , mode , col , row , width , height ):
5073 """ 5074 Computes surface area of a rectangular part of a data field. 5075 5076 This quantity makes sense only if the lateral dimensions and values of 5077 B{C{data_field}} are the same physical quantities. 5078 5079 Since: 2.18 5080 5081 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5082 @param mode: Masking mode to use. See the introduction for description of 5083 masking modes. I{(MaskingType)} 5084 @param col: Upper-left column coordinate. I{(int)} 5085 @param row: Upper-left row coordinate. I{(int)} 5086 @param width: Area width (number of columns). I{(int)} 5087 @param height: Area height (number of rows). I{(int)} 5088 @return: The surface area. 5089 5090 5091 """ 5092 return None
5093 - def area_get_volume( basis , mask , col , row , width , height ):
5094 """ 5095 Computes volume of a rectangular part of a data field. 5096 5097 Since: 2.3 5098 5099 @param basis: The basis or background for volume calculation if not B{C{NULL}}. 5100 The height of each vertex is then the difference between 5101 B{C{data_field}} value and B{C{basis}} value. Value B{C{NULL}} is the same 5102 as passing all zeroes for the basis. I{(L{DataField})} 5103 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5104 @param col: Upper-left column coordinate. I{(int)} 5105 @param row: Upper-left row coordinate. I{(int)} 5106 @param width: Area width (number of columns). I{(int)} 5107 @param height: Area height (number of rows). I{(int)} 5108 @return: The volume. 5109 5110 5111 """ 5112 return None
5113 - def UNIMPLEMENTED_get_autorange( _from , to ):
5114 """ 5115 Computes value range with outliers cut-off. 5116 5117 The purpose of this function is to find a range is suitable for false color 5118 mapping. The precise method how it is calculated is unspecified and may be 5119 subject to changes. 5120 5121 However, it is guaranteed minimum <= B{C{from}} <= B{C{to}} <= maximum. 5122 5123 This quantity is cached. 5124 5125 @param _from: Location to store range start. I{(gdouble*)} 5126 @param to: Location to store range end. I{(gdouble*)} 5127 @return: 5128 """ 5129 return None
5130 - def get_stats( avg , ra , rms , skew , kurtosis ):
5131 """ 5132 Computes basic statistical quantities of a data field. 5133 5134 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(float)} 5135 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(float)} 5136 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5137 or B{C{NULL}}. I{(float)} 5138 @param skew: Where skew (symmetry of height distribution) should be stored, or 5139 B{C{NULL}}. I{(float)} 5140 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5141 stored, or B{C{NULL}}. I{(float)} 5142 @return: 5143 """ 5144 return None
5145 - def area_get_stats( mask , col , row , width , height , avg , ra , rms , skew , kurtosis ):
5146 """ 5147 Computes basic statistical quantities of a rectangular part of a data field. 5148 5149 This function is equivalent to calling B{C{L{DataField.area_get_stats_mask}}}() 5150 with masking mode B{C{MASK_INCLUDE}}. 5151 5152 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5153 @param col: Upper-left column coordinate. I{(int)} 5154 @param row: Upper-left row coordinate. I{(int)} 5155 @param width: Area width (number of columns). I{(int)} 5156 @param height: Area height (number of rows). I{(int)} 5157 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(float)} 5158 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(float)} 5159 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5160 or B{C{NULL}}. I{(float)} 5161 @param skew: Where skew (symmetry of height distribution) should be stored, or 5162 B{C{NULL}}. I{(float)} 5163 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5164 stored, or B{C{NULL}}. I{(float)} 5165 @return: 5166 """ 5167 return None
5168 - def UNIMPLEMENTED_area_get_stats_mask( mask , mode , col , row , width , height , avg , ra , rms , skew , kurtosis ):
5169 """ 5170 Computes basic statistical quantities of a rectangular part of a data field. 5171 5172 Since: 2.18 5173 5174 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5175 @param mode: Masking mode to use. See the introduction for description of 5176 masking modes. I{(MaskingType)} 5177 @param col: Upper-left column coordinate. I{(int)} 5178 @param row: Upper-left row coordinate. I{(int)} 5179 @param width: Area width (number of columns). I{(int)} 5180 @param height: Area height (number of rows). I{(int)} 5181 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(gdouble*)} 5182 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(gdouble*)} 5183 @param rms: Where root mean square value of irregularities (Rq) should be stored, 5184 or B{C{NULL}}. I{(gdouble*)} 5185 @param skew: Where skew (symmetry of height distribution) should be stored, or 5186 B{C{NULL}}. I{(gdouble*)} 5187 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 5188 stored, or B{C{NULL}}. I{(gdouble*)} 5189 @return: 5190 """ 5191 return None
5192 - def area_count_in_range( mask , col , row , width , height , below , above , nbelow , nabove ):
5193 """ 5194 Counts data samples in given range. 5195 5196 No assertion is made about the values of B{C{above}} and B{C{below}}, in other words 5197 B{C{above}} may be larger than B{C{below}}. To count samples in an open interval 5198 instead of a closed interval, exchange B{C{below}} and B{C{above}} and then subtract 5199 the B{C{nabove}} and B{C{nbelow}} from B{C{width}}*B{C{height}} to get the complementary counts. 5200 5201 With this trick the common task of counting positive values can be 5202 realized: 5203 <informalexample><programlisting> 5204 L{DataField.area_count_in_range}(data_field, NULL, 5205 col, row, width, height, 5206 0.0, 0.0, &amp;count, NULL); 5207 count = width*height - count; 5208 </programlisting></informalexample> 5209 5210 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5211 @param col: Upper-left column coordinate. I{(int)} 5212 @param row: Upper-left row coordinate. I{(int)} 5213 @param width: Area width (number of columns). I{(int)} 5214 @param height: Area height (number of rows). I{(int)} 5215 @param below: Upper bound to compare data to. The number of samples less 5216 than or equal to B{C{below}} is stored in B{C{nbelow}}. I{(float)} 5217 @param above: Lower bound to compare data to. The number of samples greater 5218 than or equal to B{C{above}} is stored in B{C{nabove}}. I{(float)} 5219 @param nbelow: Location to store the number of samples less than or equal 5220 to B{C{below}}, or B{C{NULL}}. I{(int)} 5221 @param nabove: Location to store the number of samples greater than or equal 5222 to B{C{above}}, or B{C{NULL}}. I{(int)} 5223 @return: 5224 """ 5225 return None
5226 - def area_dh( mask , target_line , col , row , width , height , nstats ):
5227 """ 5228 Calculates distribution of heights in a rectangular part of data field. 5229 5230 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5231 @param target_line: A data line to store the distribution to. It will be 5232 resampled to requested width. I{(L{DataLine})} 5233 @param col: Upper-left column coordinate. I{(int)} 5234 @param row: Upper-left row coordinate. I{(int)} 5235 @param width: Area width (number of columns). I{(int)} 5236 @param height: Area height (number of rows). I{(int)} 5237 @param nstats: The number of samples to take on the distribution function. If 5238 nonpositive, a suitable resolution is determined automatically. I{(int)} 5239 @return: 5240 """ 5241 return None
5242 - def dh( target_line , nstats ):
5243 """ 5244 Calculates distribution of heights in a data field. 5245 5246 @param target_line: A data line to store the distribution to. It will be 5247 resampled to requested width. I{(L{DataLine})} 5248 @param nstats: The number of samples to take on the distribution function. If 5249 nonpositive, a suitable resolution is determined automatically. I{(int)} 5250 @return: 5251 """ 5252 return None
5253 - def area_cdh( mask , target_line , col , row , width , height , nstats ):
5254 """ 5255 Calculates uncertainty of the cumulative distribution of heights in a 5256 rectangular part of the data field. 5257 5258 Since: 2.23 5259 5260 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 5261 @param uncz_field: Corresponding uncertainty data field. 5262 @param target_line: A data line to store the distribution to. It will be 5263 resampled to requested width. I{(L{DataLine})} 5264 @param col: Upper-left column coordinate. I{(int)} 5265 @param row: Upper-left row coordinate. I{(int)} 5266 @param width: Area width (number of columns). I{(int)} 5267 @param height: Area height (number of rows). I{(int)} 5268 @param nstats: The number of samples to take on the distribution function. If 5269 nonpositive, a suitable resolution is determined automatically. I{(int)} 5270 @return: 5271 """ 5272 return None
5273 - def cdh( target_line , nstats ):
5274 """ 5275 Calculates cumulative distribution of heights in a data field. 5276 5277 @param target_line: A data line to store the distribution to. It will be 5278 resampled to requested width. I{(L{DataLine})} 5279 @param nstats: The number of samples to take on the distribution function. If 5280 nonpositive, a suitable resolution is determined automatically. I{(int)} 5281 @return: 5282 """ 5283 return None
5284 - def area_da( target_line , col , row , width , height , orientation , nstats ):
5285 """ 5286 Calculates distribution of slopes in a rectangular part of data field. 5287 5288 @param target_line: A data line to store the distribution to. It will be 5289 resampled to requested width. I{(L{DataLine})} 5290 @param col: Upper-left column coordinate. I{(int)} 5291 @param row: Upper-left row coordinate. I{(int)} 5292 @param width: Area width (number of columns). I{(int)} 5293 @param height: Area height (number of rows). I{(int)} 5294 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 5295 @param nstats: The number of samples to take on the distribution function. If 5296 nonpositive, a suitable resolution is determined automatically. I{(int)} 5297 @return: 5298 """ 5299 return None
5300 - def da( target_line , orientation , nstats ):
5301 """ 5302 Calculates distribution of slopes in a data field. 5303 5304 @param target_line: A data line to store the distribution to. It will be 5305 resampled to requested width. I{(L{DataLine})} 5306 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 5307 @param nstats: The number of samples to take on the distribution function. If 5308 nonpositive, a suitable resolution is determined automatically. I{(int)} 5309 @return: 5310 """ 5311 return None
5312 - def area_cda( target_line , col , row , width , height , orientation , nstats ):
5313 """ 5314 Calculates cumulative distribution of slopes in a rectangular part of data 5315 field. 5316 5317 @param target_line: A data line to store the distribution to. It will be 5318 resampled to requested width. I{(L{DataLine})} 5319 @param col: Upper-left column coordinate. I{(int)} 5320 @param row: Upper-left row coordinate. I{(int)} 5321 @param width: Area width (number of columns). I{(int)} 5322 @param height: Area height (number of rows). I{(int)} 5323 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 5324 @param nstats: The number of samples to take on the distribution function. If 5325 nonpositive, a suitable resolution is determined automatically. I{(int)} 5326 @return: 5327 """ 5328 return None
5329 - def cda( target_line , orientation , nstats ):
5330 """ 5331 Calculates cumulative distribution of slopes in a data field. 5332 5333 @param target_line: A data line to store the distribution to. It will be 5334 resampled to requested width. I{(L{DataLine})} 5335 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 5336 @param nstats: The number of samples to take on the distribution function. If 5337 nonpositive, a suitable resolution is determined automatically. I{(int)} 5338 @return: 5339 """ 5340 return None
5341 - def area_acf( target_line , col , row , width , height , orientation , interpolation , nstats ):
5342 """ 5343 Calculates one-dimensional autocorrelation function of a rectangular part of 5344 a data field. 5345 5346 @param target_line: A data line to store the distribution to. It will be 5347 resampled to requested width. I{(L{DataLine})} 5348 @param col: Upper-left column coordinate. I{(int)} 5349 @param row: Upper-left row coordinate. I{(int)} 5350 @param width: Area width (number of columns). I{(int)} 5351 @param height: Area height (number of rows). I{(int)} 5352 @param orientation: Orientation of lines (ACF is simply averaged over the 5353 other orientation). I{(Orientation)} 5354 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 5355 resampling. I{(InterpolationType)} 5356 @param nstats: The number of samples to take on the distribution function. If 5357 nonpositive, B{C{width}} (B{C{height}}) is used. I{(int)} 5358 @return: 5359 """ 5360 return None
5361 - def acf( target_line , orientation , interpolation , nstats ):
5362 """ 5363 Calculates one-dimensional autocorrelation function of a data field. 5364 5365 @param target_line: A data line to store the distribution to. It will be 5366 resampled to requested width. I{(L{DataLine})} 5367 @param orientation: Orientation of lines (ACF is simply averaged over the 5368 other orientation). I{(Orientation)} 5369 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 5370 resampling. I{(InterpolationType)} 5371 @param nstats: The number of samples to take on the distribution function. If 5372 nonpositive, data field width (height) is used. I{(int)} 5373 @return: 5374 """ 5375 return None
5376 - def area_hhcf( target_line , col , row , width , height , orientation , interpolation , nstats ):
5377 """ 5378 Calculates one-dimensional autocorrelation function of a rectangular part of 5379 a data field. 5380 5381 @param target_line: A data line to store the distribution to. It will be 5382 resampled to requested width. I{(L{DataLine})} 5383 @param col: Upper-left column coordinate. I{(int)} 5384 @param row: Upper-left row coordinate. I{(int)} 5385 @param width: Area width (number of columns). I{(int)} 5386 @param height: Area height (number of rows). I{(int)} 5387 @param orientation: Orientation of lines (HHCF is simply averaged over the 5388 other orientation). I{(Orientation)} 5389 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 5390 resampling. I{(InterpolationType)} 5391 @param nstats: The number of samples to take on the distribution function. If 5392 nonpositive, B{C{width}} (B{C{height}}) is used. I{(int)} 5393 @return: 5394 """ 5395 return None
5396 - def hhcf( target_line , orientation , interpolation , nstats ):
5397 """ 5398 Calculates one-dimensional autocorrelation function of a data field. 5399 5400 @param target_line: A data line to store the distribution to. It will be 5401 resampled to requested width. I{(L{DataLine})} 5402 @param orientation: Orientation of lines (HHCF is simply averaged over the 5403 other orientation). I{(Orientation)} 5404 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 5405 resampling. I{(InterpolationType)} 5406 @param nstats: The number of samples to take on the distribution function. If