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