vips-cpp 8.11
libvips C++ binding
Loading...
Searching...
No Matches
vips-operators.cpp
1// bodies for vips operations
2// Wed May 12 11:30:00 AM CEST 2021
3// this file is generated automatically, do not edit!
4
5VImage VImage::CMC2LCh( VOption *options ) const
6{
8
9 call( "CMC2LCh",
10 (options ? options : VImage::option())->
11 set( "in", *this )->
12 set( "out", &out ) );
13
14 return( out );
15}
16
18{
19 VImage out;
20
21 call( "CMYK2XYZ",
22 (options ? options : VImage::option())->
23 set( "in", *this )->
24 set( "out", &out ) );
25
26 return( out );
27}
28
30{
31 VImage out;
32
33 call( "HSV2sRGB",
34 (options ? options : VImage::option())->
35 set( "in", *this )->
36 set( "out", &out ) );
37
38 return( out );
39}
40
42{
43 VImage out;
44
45 call( "LCh2CMC",
46 (options ? options : VImage::option())->
47 set( "in", *this )->
48 set( "out", &out ) );
49
50 return( out );
51}
52
54{
55 VImage out;
56
57 call( "LCh2Lab",
58 (options ? options : VImage::option())->
59 set( "in", *this )->
60 set( "out", &out ) );
61
62 return( out );
63}
64
66{
67 VImage out;
68
69 call( "Lab2LCh",
70 (options ? options : VImage::option())->
71 set( "in", *this )->
72 set( "out", &out ) );
73
74 return( out );
75}
76
78{
79 VImage out;
80
81 call( "Lab2LabQ",
82 (options ? options : VImage::option())->
83 set( "in", *this )->
84 set( "out", &out ) );
85
86 return( out );
87}
88
90{
91 VImage out;
92
93 call( "Lab2LabS",
94 (options ? options : VImage::option())->
95 set( "in", *this )->
96 set( "out", &out ) );
97
98 return( out );
99}
100
102{
103 VImage out;
104
105 call( "Lab2XYZ",
106 (options ? options : VImage::option())->
107 set( "in", *this )->
108 set( "out", &out ) );
109
110 return( out );
111}
112
114{
115 VImage out;
116
117 call( "LabQ2Lab",
118 (options ? options : VImage::option())->
119 set( "in", *this )->
120 set( "out", &out ) );
121
122 return( out );
123}
124
126{
127 VImage out;
128
129 call( "LabQ2LabS",
130 (options ? options : VImage::option())->
131 set( "in", *this )->
132 set( "out", &out ) );
133
134 return( out );
135}
136
138{
139 VImage out;
140
141 call( "LabQ2sRGB",
142 (options ? options : VImage::option())->
143 set( "in", *this )->
144 set( "out", &out ) );
145
146 return( out );
147}
148
150{
151 VImage out;
152
153 call( "LabS2Lab",
154 (options ? options : VImage::option())->
155 set( "in", *this )->
156 set( "out", &out ) );
157
158 return( out );
159}
160
162{
163 VImage out;
164
165 call( "LabS2LabQ",
166 (options ? options : VImage::option())->
167 set( "in", *this )->
168 set( "out", &out ) );
169
170 return( out );
171}
172
174{
175 VImage out;
176
177 call( "XYZ2CMYK",
178 (options ? options : VImage::option())->
179 set( "in", *this )->
180 set( "out", &out ) );
181
182 return( out );
183}
184
186{
187 VImage out;
188
189 call( "XYZ2Lab",
190 (options ? options : VImage::option())->
191 set( "in", *this )->
192 set( "out", &out ) );
193
194 return( out );
195}
196
198{
199 VImage out;
200
201 call( "XYZ2Yxy",
202 (options ? options : VImage::option())->
203 set( "in", *this )->
204 set( "out", &out ) );
205
206 return( out );
207}
208
210{
211 VImage out;
212
213 call( "XYZ2scRGB",
214 (options ? options : VImage::option())->
215 set( "in", *this )->
216 set( "out", &out ) );
217
218 return( out );
219}
220
222{
223 VImage out;
224
225 call( "Yxy2XYZ",
226 (options ? options : VImage::option())->
227 set( "in", *this )->
228 set( "out", &out ) );
229
230 return( out );
231}
232
233VImage VImage::abs( VOption *options ) const
234{
235 VImage out;
236
237 call( "abs",
238 (options ? options : VImage::option())->
239 set( "in", *this )->
240 set( "out", &out ) );
241
242 return( out );
243}
244
245VImage VImage::add( VImage right, VOption *options ) const
246{
247 VImage out;
248
249 call( "add",
250 (options ? options : VImage::option())->
251 set( "left", *this )->
252 set( "out", &out )->
253 set( "right", right ) );
254
255 return( out );
256}
257
258VImage VImage::affine( std::vector<double> matrix, VOption *options ) const
259{
260 VImage out;
261
262 call( "affine",
263 (options ? options : VImage::option())->
264 set( "in", *this )->
265 set( "out", &out )->
266 set( "matrix", matrix ) );
267
268 return( out );
269}
270
271VImage VImage::analyzeload( const char *filename, VOption *options )
272{
273 VImage out;
274
275 call( "analyzeload",
276 (options ? options : VImage::option())->
277 set( "out", &out )->
278 set( "filename", filename ) );
279
280 return( out );
281}
282
283VImage VImage::arrayjoin( std::vector<VImage> in, VOption *options )
284{
285 VImage out;
286
287 call( "arrayjoin",
288 (options ? options : VImage::option())->
289 set( "out", &out )->
290 set( "in", in ) );
291
292 return( out );
293}
294
296{
297 VImage out;
298
299 call( "autorot",
300 (options ? options : VImage::option())->
301 set( "in", *this )->
302 set( "out", &out ) );
303
304 return( out );
305}
306
307double VImage::avg( VOption *options ) const
308{
309 double out;
310
311 call( "avg",
312 (options ? options : VImage::option())->
313 set( "in", *this )->
314 set( "out", &out ) );
315
316 return( out );
317}
318
319VImage VImage::bandbool( VipsOperationBoolean boolean, VOption *options ) const
320{
321 VImage out;
322
323 call( "bandbool",
324 (options ? options : VImage::option())->
325 set( "in", *this )->
326 set( "out", &out )->
327 set( "boolean", boolean ) );
328
329 return( out );
330}
331
333{
334 VImage out;
335
336 call( "bandfold",
337 (options ? options : VImage::option())->
338 set( "in", *this )->
339 set( "out", &out ) );
340
341 return( out );
342}
343
344VImage VImage::bandjoin( std::vector<VImage> in, VOption *options )
345{
346 VImage out;
347
348 call( "bandjoin",
349 (options ? options : VImage::option())->
350 set( "out", &out )->
351 set( "in", in ) );
352
353 return( out );
354}
355
356VImage VImage::bandjoin_const( std::vector<double> c, VOption *options ) const
357{
358 VImage out;
359
360 call( "bandjoin_const",
361 (options ? options : VImage::option())->
362 set( "in", *this )->
363 set( "out", &out )->
364 set( "c", c ) );
365
366 return( out );
367}
368
370{
371 VImage out;
372
373 call( "bandmean",
374 (options ? options : VImage::option())->
375 set( "in", *this )->
376 set( "out", &out ) );
377
378 return( out );
379}
380
381VImage VImage::bandrank( std::vector<VImage> in, VOption *options )
382{
383 VImage out;
384
385 call( "bandrank",
386 (options ? options : VImage::option())->
387 set( "out", &out )->
388 set( "in", in ) );
389
390 return( out );
391}
392
394{
395 VImage out;
396
397 call( "bandunfold",
398 (options ? options : VImage::option())->
399 set( "in", *this )->
400 set( "out", &out ) );
401
402 return( out );
403}
404
405VImage VImage::black( int width, int height, VOption *options )
406{
407 VImage out;
408
409 call( "black",
410 (options ? options : VImage::option())->
411 set( "out", &out )->
412 set( "width", width )->
413 set( "height", height ) );
414
415 return( out );
416}
417
418VImage VImage::boolean( VImage right, VipsOperationBoolean boolean, VOption *options ) const
419{
420 VImage out;
421
422 call( "boolean",
423 (options ? options : VImage::option())->
424 set( "left", *this )->
425 set( "out", &out )->
426 set( "right", right )->
427 set( "boolean", boolean ) );
428
429 return( out );
430}
431
432VImage VImage::boolean_const( VipsOperationBoolean boolean, std::vector<double> c, VOption *options ) const
433{
434 VImage out;
435
436 call( "boolean_const",
437 (options ? options : VImage::option())->
438 set( "in", *this )->
439 set( "out", &out )->
440 set( "boolean", boolean )->
441 set( "c", c ) );
442
443 return( out );
444}
445
447{
448 VImage out;
449
450 call( "buildlut",
451 (options ? options : VImage::option())->
452 set( "in", *this )->
453 set( "out", &out ) );
454
455 return( out );
456}
457
459{
460 VImage out;
461
462 call( "byteswap",
463 (options ? options : VImage::option())->
464 set( "in", *this )->
465 set( "out", &out ) );
466
467 return( out );
468}
469
470VImage VImage::cache( VOption *options ) const
471{
472 VImage out;
473
474 call( "cache",
475 (options ? options : VImage::option())->
476 set( "in", *this )->
477 set( "out", &out ) );
478
479 return( out );
480}
481
482VImage VImage::canny( VOption *options ) const
483{
484 VImage out;
485
486 call( "canny",
487 (options ? options : VImage::option())->
488 set( "in", *this )->
489 set( "out", &out ) );
490
491 return( out );
492}
493
494VImage VImage::case_image( std::vector<VImage> cases, VOption *options ) const
495{
496 VImage out;
497
498 call( "case",
499 (options ? options : VImage::option())->
500 set( "index", *this )->
501 set( "out", &out )->
502 set( "cases", cases ) );
503
504 return( out );
505}
506
507VImage VImage::cast( VipsBandFormat format, VOption *options ) const
508{
509 VImage out;
510
511 call( "cast",
512 (options ? options : VImage::option())->
513 set( "in", *this )->
514 set( "out", &out )->
515 set( "format", format ) );
516
517 return( out );
518}
519
520VImage VImage::colourspace( VipsInterpretation space, VOption *options ) const
521{
522 VImage out;
523
524 call( "colourspace",
525 (options ? options : VImage::option())->
526 set( "in", *this )->
527 set( "out", &out )->
528 set( "space", space ) );
529
530 return( out );
531}
532
533VImage VImage::compass( VImage mask, VOption *options ) const
534{
535 VImage out;
536
537 call( "compass",
538 (options ? options : VImage::option())->
539 set( "in", *this )->
540 set( "out", &out )->
541 set( "mask", mask ) );
542
543 return( out );
544}
545
546VImage VImage::complex( VipsOperationComplex cmplx, VOption *options ) const
547{
548 VImage out;
549
550 call( "complex",
551 (options ? options : VImage::option())->
552 set( "in", *this )->
553 set( "out", &out )->
554 set( "cmplx", cmplx ) );
555
556 return( out );
557}
558
559VImage VImage::complex2( VImage right, VipsOperationComplex2 cmplx, VOption *options ) const
560{
561 VImage out;
562
563 call( "complex2",
564 (options ? options : VImage::option())->
565 set( "left", *this )->
566 set( "out", &out )->
567 set( "right", right )->
568 set( "cmplx", cmplx ) );
569
570 return( out );
571}
572
573VImage VImage::complexform( VImage right, VOption *options ) const
574{
575 VImage out;
576
577 call( "complexform",
578 (options ? options : VImage::option())->
579 set( "left", *this )->
580 set( "out", &out )->
581 set( "right", right ) );
582
583 return( out );
584}
585
586VImage VImage::complexget( VipsOperationComplexget get, VOption *options ) const
587{
588 VImage out;
589
590 call( "complexget",
591 (options ? options : VImage::option())->
592 set( "in", *this )->
593 set( "out", &out )->
594 set( "get", get ) );
595
596 return( out );
597}
598
599VImage VImage::composite( std::vector<VImage> in, std::vector<int> mode, VOption *options )
600{
601 VImage out;
602
603 call( "composite",
604 (options ? options : VImage::option())->
605 set( "out", &out )->
606 set( "in", in )->
607 set( "mode", mode ) );
608
609 return( out );
610}
611
612VImage VImage::composite2( VImage overlay, VipsBlendMode mode, VOption *options ) const
613{
614 VImage out;
615
616 call( "composite2",
617 (options ? options : VImage::option())->
618 set( "base", *this )->
619 set( "out", &out )->
620 set( "overlay", overlay )->
621 set( "mode", mode ) );
622
623 return( out );
624}
625
626VImage VImage::conv( VImage mask, VOption *options ) const
627{
628 VImage out;
629
630 call( "conv",
631 (options ? options : VImage::option())->
632 set( "in", *this )->
633 set( "out", &out )->
634 set( "mask", mask ) );
635
636 return( out );
637}
638
639VImage VImage::conva( VImage mask, VOption *options ) const
640{
641 VImage out;
642
643 call( "conva",
644 (options ? options : VImage::option())->
645 set( "in", *this )->
646 set( "out", &out )->
647 set( "mask", mask ) );
648
649 return( out );
650}
651
652VImage VImage::convasep( VImage mask, VOption *options ) const
653{
654 VImage out;
655
656 call( "convasep",
657 (options ? options : VImage::option())->
658 set( "in", *this )->
659 set( "out", &out )->
660 set( "mask", mask ) );
661
662 return( out );
663}
664
665VImage VImage::convf( VImage mask, VOption *options ) const
666{
667 VImage out;
668
669 call( "convf",
670 (options ? options : VImage::option())->
671 set( "in", *this )->
672 set( "out", &out )->
673 set( "mask", mask ) );
674
675 return( out );
676}
677
678VImage VImage::convi( VImage mask, VOption *options ) const
679{
680 VImage out;
681
682 call( "convi",
683 (options ? options : VImage::option())->
684 set( "in", *this )->
685 set( "out", &out )->
686 set( "mask", mask ) );
687
688 return( out );
689}
690
691VImage VImage::convsep( VImage mask, VOption *options ) const
692{
693 VImage out;
694
695 call( "convsep",
696 (options ? options : VImage::option())->
697 set( "in", *this )->
698 set( "out", &out )->
699 set( "mask", mask ) );
700
701 return( out );
702}
703
704VImage VImage::copy( VOption *options ) const
705{
706 VImage out;
707
708 call( "copy",
709 (options ? options : VImage::option())->
710 set( "in", *this )->
711 set( "out", &out ) );
712
713 return( out );
714}
715
716double VImage::countlines( VipsDirection direction, VOption *options ) const
717{
718 double nolines;
719
720 call( "countlines",
721 (options ? options : VImage::option())->
722 set( "in", *this )->
723 set( "nolines", &nolines )->
724 set( "direction", direction ) );
725
726 return( nolines );
727}
728
729VImage VImage::crop( int left, int top, int width, int height, VOption *options ) const
730{
731 VImage out;
732
733 call( "crop",
734 (options ? options : VImage::option())->
735 set( "input", *this )->
736 set( "out", &out )->
737 set( "left", left )->
738 set( "top", top )->
739 set( "width", width )->
740 set( "height", height ) );
741
742 return( out );
743}
744
745VImage VImage::csvload( const char *filename, VOption *options )
746{
747 VImage out;
748
749 call( "csvload",
750 (options ? options : VImage::option())->
751 set( "out", &out )->
752 set( "filename", filename ) );
753
754 return( out );
755}
756
758{
759 VImage out;
760
761 call( "csvload_source",
762 (options ? options : VImage::option())->
763 set( "out", &out )->
764 set( "source", source ) );
765
766 return( out );
767}
768
769void VImage::csvsave( const char *filename, VOption *options ) const
770{
771 call( "csvsave",
772 (options ? options : VImage::option())->
773 set( "in", *this )->
774 set( "filename", filename ) );
775}
776
777void VImage::csvsave_target( VTarget target, VOption *options ) const
778{
779 call( "csvsave_target",
780 (options ? options : VImage::option())->
781 set( "in", *this )->
782 set( "target", target ) );
783}
784
785VImage VImage::dE00( VImage right, VOption *options ) const
786{
787 VImage out;
788
789 call( "dE00",
790 (options ? options : VImage::option())->
791 set( "left", *this )->
792 set( "out", &out )->
793 set( "right", right ) );
794
795 return( out );
796}
797
798VImage VImage::dE76( VImage right, VOption *options ) const
799{
800 VImage out;
801
802 call( "dE76",
803 (options ? options : VImage::option())->
804 set( "left", *this )->
805 set( "out", &out )->
806 set( "right", right ) );
807
808 return( out );
809}
810
811VImage VImage::dECMC( VImage right, VOption *options ) const
812{
813 VImage out;
814
815 call( "dECMC",
816 (options ? options : VImage::option())->
817 set( "left", *this )->
818 set( "out", &out )->
819 set( "right", right ) );
820
821 return( out );
822}
823
824double VImage::deviate( VOption *options ) const
825{
826 double out;
827
828 call( "deviate",
829 (options ? options : VImage::option())->
830 set( "in", *this )->
831 set( "out", &out ) );
832
833 return( out );
834}
835
836VImage VImage::divide( VImage right, VOption *options ) const
837{
838 VImage out;
839
840 call( "divide",
841 (options ? options : VImage::option())->
842 set( "left", *this )->
843 set( "out", &out )->
844 set( "right", right ) );
845
846 return( out );
847}
848
849void VImage::draw_circle( std::vector<double> ink, int cx, int cy, int radius, VOption *options ) const
850{
851 call( "draw_circle",
852 (options ? options : VImage::option())->
853 set( "image", *this )->
854 set( "ink", ink )->
855 set( "cx", cx )->
856 set( "cy", cy )->
857 set( "radius", radius ) );
858}
859
860void VImage::draw_flood( std::vector<double> ink, int x, int y, VOption *options ) const
861{
862 call( "draw_flood",
863 (options ? options : VImage::option())->
864 set( "image", *this )->
865 set( "ink", ink )->
866 set( "x", x )->
867 set( "y", y ) );
868}
869
870void VImage::draw_image( VImage sub, int x, int y, VOption *options ) const
871{
872 call( "draw_image",
873 (options ? options : VImage::option())->
874 set( "image", *this )->
875 set( "sub", sub )->
876 set( "x", x )->
877 set( "y", y ) );
878}
879
880void VImage::draw_line( std::vector<double> ink, int x1, int y1, int x2, int y2, VOption *options ) const
881{
882 call( "draw_line",
883 (options ? options : VImage::option())->
884 set( "image", *this )->
885 set( "ink", ink )->
886 set( "x1", x1 )->
887 set( "y1", y1 )->
888 set( "x2", x2 )->
889 set( "y2", y2 ) );
890}
891
892void VImage::draw_mask( std::vector<double> ink, VImage mask, int x, int y, VOption *options ) const
893{
894 call( "draw_mask",
895 (options ? options : VImage::option())->
896 set( "image", *this )->
897 set( "ink", ink )->
898 set( "mask", mask )->
899 set( "x", x )->
900 set( "y", y ) );
901}
902
903void VImage::draw_rect( std::vector<double> ink, int left, int top, int width, int height, VOption *options ) const
904{
905 call( "draw_rect",
906 (options ? options : VImage::option())->
907 set( "image", *this )->
908 set( "ink", ink )->
909 set( "left", left )->
910 set( "top", top )->
911 set( "width", width )->
912 set( "height", height ) );
913}
914
915void VImage::draw_smudge( int left, int top, int width, int height, VOption *options ) const
916{
917 call( "draw_smudge",
918 (options ? options : VImage::option())->
919 set( "image", *this )->
920 set( "left", left )->
921 set( "top", top )->
922 set( "width", width )->
923 set( "height", height ) );
924}
925
926void VImage::dzsave( const char *filename, VOption *options ) const
927{
928 call( "dzsave",
929 (options ? options : VImage::option())->
930 set( "in", *this )->
931 set( "filename", filename ) );
932}
933
934VipsBlob *VImage::dzsave_buffer( VOption *options ) const
935{
937
938 call( "dzsave_buffer",
939 (options ? options : VImage::option())->
940 set( "in", *this )->
941 set( "buffer", &buffer ) );
942
943 return( buffer );
944}
945
946VImage VImage::embed( int x, int y, int width, int height, VOption *options ) const
947{
948 VImage out;
949
950 call( "embed",
951 (options ? options : VImage::option())->
952 set( "in", *this )->
953 set( "out", &out )->
954 set( "x", x )->
955 set( "y", y )->
956 set( "width", width )->
957 set( "height", height ) );
958
959 return( out );
960}
961
962VImage VImage::extract_area( int left, int top, int width, int height, VOption *options ) const
963{
964 VImage out;
965
966 call( "extract_area",
967 (options ? options : VImage::option())->
968 set( "input", *this )->
969 set( "out", &out )->
970 set( "left", left )->
971 set( "top", top )->
972 set( "width", width )->
973 set( "height", height ) );
974
975 return( out );
976}
977
978VImage VImage::extract_band( int band, VOption *options ) const
979{
980 VImage out;
981
982 call( "extract_band",
983 (options ? options : VImage::option())->
984 set( "in", *this )->
985 set( "out", &out )->
986 set( "band", band ) );
987
988 return( out );
989}
990
991VImage VImage::eye( int width, int height, VOption *options )
992{
993 VImage out;
994
995 call( "eye",
996 (options ? options : VImage::option())->
997 set( "out", &out )->
998 set( "width", width )->
999 set( "height", height ) );
1000
1001 return( out );
1002}
1003
1005{
1006 VImage out;
1007
1008 call( "falsecolour",
1009 (options ? options : VImage::option())->
1010 set( "in", *this )->
1011 set( "out", &out ) );
1012
1013 return( out );
1014}
1015
1016VImage VImage::fastcor( VImage ref, VOption *options ) const
1017{
1018 VImage out;
1019
1020 call( "fastcor",
1021 (options ? options : VImage::option())->
1022 set( "in", *this )->
1023 set( "out", &out )->
1024 set( "ref", ref ) );
1025
1026 return( out );
1027}
1028
1030{
1031 VImage out;
1032
1033 call( "fill_nearest",
1034 (options ? options : VImage::option())->
1035 set( "in", *this )->
1036 set( "out", &out ) );
1037
1038 return( out );
1039}
1040
1041int VImage::find_trim( int *top, int *width, int *height, VOption *options ) const
1042{
1043 int left;
1044
1045 call( "find_trim",
1046 (options ? options : VImage::option())->
1047 set( "in", *this )->
1048 set( "left", &left )->
1049 set( "top", top )->
1050 set( "width", width )->
1051 set( "height", height ) );
1052
1053 return( left );
1054}
1055
1056VImage VImage::fitsload( const char *filename, VOption *options )
1057{
1058 VImage out;
1059
1060 call( "fitsload",
1061 (options ? options : VImage::option())->
1062 set( "out", &out )->
1063 set( "filename", filename ) );
1064
1065 return( out );
1066}
1067
1069{
1070 VImage out;
1071
1072 call( "fitsload_source",
1073 (options ? options : VImage::option())->
1074 set( "out", &out )->
1075 set( "source", source ) );
1076
1077 return( out );
1078}
1079
1080void VImage::fitssave( const char *filename, VOption *options ) const
1081{
1082 call( "fitssave",
1083 (options ? options : VImage::option())->
1084 set( "in", *this )->
1085 set( "filename", filename ) );
1086}
1087
1089{
1090 VImage out;
1091
1092 call( "flatten",
1093 (options ? options : VImage::option())->
1094 set( "in", *this )->
1095 set( "out", &out ) );
1096
1097 return( out );
1098}
1099
1100VImage VImage::flip( VipsDirection direction, VOption *options ) const
1101{
1102 VImage out;
1103
1104 call( "flip",
1105 (options ? options : VImage::option())->
1106 set( "in", *this )->
1107 set( "out", &out )->
1108 set( "direction", direction ) );
1109
1110 return( out );
1111}
1112
1114{
1115 VImage out;
1116
1117 call( "float2rad",
1118 (options ? options : VImage::option())->
1119 set( "in", *this )->
1120 set( "out", &out ) );
1121
1122 return( out );
1123}
1124
1125VImage VImage::fractsurf( int width, int height, double fractal_dimension, VOption *options )
1126{
1127 VImage out;
1128
1129 call( "fractsurf",
1130 (options ? options : VImage::option())->
1131 set( "out", &out )->
1132 set( "width", width )->
1133 set( "height", height )->
1134 set( "fractal_dimension", fractal_dimension ) );
1135
1136 return( out );
1137}
1138
1139VImage VImage::freqmult( VImage mask, VOption *options ) const
1140{
1141 VImage out;
1142
1143 call( "freqmult",
1144 (options ? options : VImage::option())->
1145 set( "in", *this )->
1146 set( "out", &out )->
1147 set( "mask", mask ) );
1148
1149 return( out );
1150}
1151
1153{
1154 VImage out;
1155
1156 call( "fwfft",
1157 (options ? options : VImage::option())->
1158 set( "in", *this )->
1159 set( "out", &out ) );
1160
1161 return( out );
1162}
1163
1165{
1166 VImage out;
1167
1168 call( "gamma",
1169 (options ? options : VImage::option())->
1170 set( "in", *this )->
1171 set( "out", &out ) );
1172
1173 return( out );
1174}
1175
1176VImage VImage::gaussblur( double sigma, VOption *options ) const
1177{
1178 VImage out;
1179
1180 call( "gaussblur",
1181 (options ? options : VImage::option())->
1182 set( "in", *this )->
1183 set( "out", &out )->
1184 set( "sigma", sigma ) );
1185
1186 return( out );
1187}
1188
1189VImage VImage::gaussmat( double sigma, double min_ampl, VOption *options )
1190{
1191 VImage out;
1192
1193 call( "gaussmat",
1194 (options ? options : VImage::option())->
1195 set( "out", &out )->
1196 set( "sigma", sigma )->
1197 set( "min_ampl", min_ampl ) );
1198
1199 return( out );
1200}
1201
1202VImage VImage::gaussnoise( int width, int height, VOption *options )
1203{
1204 VImage out;
1205
1206 call( "gaussnoise",
1207 (options ? options : VImage::option())->
1208 set( "out", &out )->
1209 set( "width", width )->
1210 set( "height", height ) );
1211
1212 return( out );
1213}
1214
1215std::vector<double> VImage::getpoint( int x, int y, VOption *options ) const
1216{
1217 std::vector<double> out_array;
1218
1219 call( "getpoint",
1220 (options ? options : VImage::option())->
1221 set( "in", *this )->
1222 set( "out_array", &out_array )->
1223 set( "x", x )->
1224 set( "y", y ) );
1225
1226 return( out_array );
1227}
1228
1229VImage VImage::gifload( const char *filename, VOption *options )
1230{
1231 VImage out;
1232
1233 call( "gifload",
1234 (options ? options : VImage::option())->
1235 set( "out", &out )->
1236 set( "filename", filename ) );
1237
1238 return( out );
1239}
1240
1241VImage VImage::gifload_buffer( VipsBlob *buffer, VOption *options )
1242{
1243 VImage out;
1244
1245 call( "gifload_buffer",
1246 (options ? options : VImage::option())->
1247 set( "out", &out )->
1248 set( "buffer", buffer ) );
1249
1250 return( out );
1251}
1252
1254{
1255 VImage out;
1256
1257 call( "gifload_source",
1258 (options ? options : VImage::option())->
1259 set( "out", &out )->
1260 set( "source", source ) );
1261
1262 return( out );
1263}
1264
1266{
1267 VImage out;
1268
1269 call( "globalbalance",
1270 (options ? options : VImage::option())->
1271 set( "in", *this )->
1272 set( "out", &out ) );
1273
1274 return( out );
1275}
1276
1277VImage VImage::gravity( VipsCompassDirection direction, int width, int height, VOption *options ) const
1278{
1279 VImage out;
1280
1281 call( "gravity",
1282 (options ? options : VImage::option())->
1283 set( "in", *this )->
1284 set( "out", &out )->
1285 set( "direction", direction )->
1286 set( "width", width )->
1287 set( "height", height ) );
1288
1289 return( out );
1290}
1291
1292VImage VImage::grey( int width, int height, VOption *options )
1293{
1294 VImage out;
1295
1296 call( "grey",
1297 (options ? options : VImage::option())->
1298 set( "out", &out )->
1299 set( "width", width )->
1300 set( "height", height ) );
1301
1302 return( out );
1303}
1304
1305VImage VImage::grid( int tile_height, int across, int down, VOption *options ) const
1306{
1307 VImage out;
1308
1309 call( "grid",
1310 (options ? options : VImage::option())->
1311 set( "in", *this )->
1312 set( "out", &out )->
1313 set( "tile_height", tile_height )->
1314 set( "across", across )->
1315 set( "down", down ) );
1316
1317 return( out );
1318}
1319
1320VImage VImage::heifload( const char *filename, VOption *options )
1321{
1322 VImage out;
1323
1324 call( "heifload",
1325 (options ? options : VImage::option())->
1326 set( "out", &out )->
1327 set( "filename", filename ) );
1328
1329 return( out );
1330}
1331
1332VImage VImage::heifload_buffer( VipsBlob *buffer, VOption *options )
1333{
1334 VImage out;
1335
1336 call( "heifload_buffer",
1337 (options ? options : VImage::option())->
1338 set( "out", &out )->
1339 set( "buffer", buffer ) );
1340
1341 return( out );
1342}
1343
1345{
1346 VImage out;
1347
1348 call( "heifload_source",
1349 (options ? options : VImage::option())->
1350 set( "out", &out )->
1351 set( "source", source ) );
1352
1353 return( out );
1354}
1355
1356void VImage::heifsave( const char *filename, VOption *options ) const
1357{
1358 call( "heifsave",
1359 (options ? options : VImage::option())->
1360 set( "in", *this )->
1361 set( "filename", filename ) );
1362}
1363
1364VipsBlob *VImage::heifsave_buffer( VOption *options ) const
1365{
1367
1368 call( "heifsave_buffer",
1369 (options ? options : VImage::option())->
1370 set( "in", *this )->
1371 set( "buffer", &buffer ) );
1372
1373 return( buffer );
1374}
1375
1376void VImage::heifsave_target( VTarget target, VOption *options ) const
1377{
1378 call( "heifsave_target",
1379 (options ? options : VImage::option())->
1380 set( "in", *this )->
1381 set( "target", target ) );
1382}
1383
1385{
1386 VImage out;
1387
1388 call( "hist_cum",
1389 (options ? options : VImage::option())->
1390 set( "in", *this )->
1391 set( "out", &out ) );
1392
1393 return( out );
1394}
1395
1396double VImage::hist_entropy( VOption *options ) const
1397{
1398 double out;
1399
1400 call( "hist_entropy",
1401 (options ? options : VImage::option())->
1402 set( "in", *this )->
1403 set( "out", &out ) );
1404
1405 return( out );
1406}
1407
1409{
1410 VImage out;
1411
1412 call( "hist_equal",
1413 (options ? options : VImage::option())->
1414 set( "in", *this )->
1415 set( "out", &out ) );
1416
1417 return( out );
1418}
1419
1421{
1422 VImage out;
1423
1424 call( "hist_find",
1425 (options ? options : VImage::option())->
1426 set( "in", *this )->
1427 set( "out", &out ) );
1428
1429 return( out );
1430}
1431
1433{
1434 VImage out;
1435
1436 call( "hist_find_indexed",
1437 (options ? options : VImage::option())->
1438 set( "in", *this )->
1439 set( "out", &out )->
1440 set( "index", index ) );
1441
1442 return( out );
1443}
1444
1446{
1447 VImage out;
1448
1449 call( "hist_find_ndim",
1450 (options ? options : VImage::option())->
1451 set( "in", *this )->
1452 set( "out", &out ) );
1453
1454 return( out );
1455}
1456
1457bool VImage::hist_ismonotonic( VOption *options ) const
1458{
1459 bool monotonic;
1460
1461 call( "hist_ismonotonic",
1462 (options ? options : VImage::option())->
1463 set( "in", *this )->
1464 set( "monotonic", &monotonic ) );
1465
1466 return( monotonic );
1467}
1468
1469VImage VImage::hist_local( int width, int height, VOption *options ) const
1470{
1471 VImage out;
1472
1473 call( "hist_local",
1474 (options ? options : VImage::option())->
1475 set( "in", *this )->
1476 set( "out", &out )->
1477 set( "width", width )->
1478 set( "height", height ) );
1479
1480 return( out );
1481}
1482
1484{
1485 VImage out;
1486
1487 call( "hist_match",
1488 (options ? options : VImage::option())->
1489 set( "in", *this )->
1490 set( "out", &out )->
1491 set( "ref", ref ) );
1492
1493 return( out );
1494}
1495
1497{
1498 VImage out;
1499
1500 call( "hist_norm",
1501 (options ? options : VImage::option())->
1502 set( "in", *this )->
1503 set( "out", &out ) );
1504
1505 return( out );
1506}
1507
1509{
1510 VImage out;
1511
1512 call( "hist_plot",
1513 (options ? options : VImage::option())->
1514 set( "in", *this )->
1515 set( "out", &out ) );
1516
1517 return( out );
1518}
1519
1521{
1522 VImage out;
1523
1524 call( "hough_circle",
1525 (options ? options : VImage::option())->
1526 set( "in", *this )->
1527 set( "out", &out ) );
1528
1529 return( out );
1530}
1531
1533{
1534 VImage out;
1535
1536 call( "hough_line",
1537 (options ? options : VImage::option())->
1538 set( "in", *this )->
1539 set( "out", &out ) );
1540
1541 return( out );
1542}
1543
1545{
1546 VImage out;
1547
1548 call( "icc_export",
1549 (options ? options : VImage::option())->
1550 set( "in", *this )->
1551 set( "out", &out ) );
1552
1553 return( out );
1554}
1555
1557{
1558 VImage out;
1559
1560 call( "icc_import",
1561 (options ? options : VImage::option())->
1562 set( "in", *this )->
1563 set( "out", &out ) );
1564
1565 return( out );
1566}
1567
1568VImage VImage::icc_transform( const char *output_profile, VOption *options ) const
1569{
1570 VImage out;
1571
1572 call( "icc_transform",
1573 (options ? options : VImage::option())->
1574 set( "in", *this )->
1575 set( "out", &out )->
1576 set( "output_profile", output_profile ) );
1577
1578 return( out );
1579}
1580
1582{
1583 VImage out;
1584
1585 call( "identity",
1586 (options ? options : VImage::option())->
1587 set( "out", &out ) );
1588
1589 return( out );
1590}
1591
1592VImage VImage::ifthenelse( VImage in1, VImage in2, VOption *options ) const
1593{
1594 VImage out;
1595
1596 call( "ifthenelse",
1597 (options ? options : VImage::option())->
1598 set( "cond", *this )->
1599 set( "out", &out )->
1600 set( "in1", in1 )->
1601 set( "in2", in2 ) );
1602
1603 return( out );
1604}
1605
1606VImage VImage::insert( VImage sub, int x, int y, VOption *options ) const
1607{
1608 VImage out;
1609
1610 call( "insert",
1611 (options ? options : VImage::option())->
1612 set( "main", *this )->
1613 set( "out", &out )->
1614 set( "sub", sub )->
1615 set( "x", x )->
1616 set( "y", y ) );
1617
1618 return( out );
1619}
1620
1622{
1623 VImage out;
1624
1625 call( "invert",
1626 (options ? options : VImage::option())->
1627 set( "in", *this )->
1628 set( "out", &out ) );
1629
1630 return( out );
1631}
1632
1634{
1635 VImage out;
1636
1637 call( "invertlut",
1638 (options ? options : VImage::option())->
1639 set( "in", *this )->
1640 set( "out", &out ) );
1641
1642 return( out );
1643}
1644
1646{
1647 VImage out;
1648
1649 call( "invfft",
1650 (options ? options : VImage::option())->
1651 set( "in", *this )->
1652 set( "out", &out ) );
1653
1654 return( out );
1655}
1656
1657VImage VImage::join( VImage in2, VipsDirection direction, VOption *options ) const
1658{
1659 VImage out;
1660
1661 call( "join",
1662 (options ? options : VImage::option())->
1663 set( "in1", *this )->
1664 set( "out", &out )->
1665 set( "in2", in2 )->
1666 set( "direction", direction ) );
1667
1668 return( out );
1669}
1670
1671VImage VImage::jp2kload( const char *filename, VOption *options )
1672{
1673 VImage out;
1674
1675 call( "jp2kload",
1676 (options ? options : VImage::option())->
1677 set( "out", &out )->
1678 set( "filename", filename ) );
1679
1680 return( out );
1681}
1682
1683VImage VImage::jp2kload_buffer( VipsBlob *buffer, VOption *options )
1684{
1685 VImage out;
1686
1687 call( "jp2kload_buffer",
1688 (options ? options : VImage::option())->
1689 set( "out", &out )->
1690 set( "buffer", buffer ) );
1691
1692 return( out );
1693}
1694
1696{
1697 VImage out;
1698
1699 call( "jp2kload_source",
1700 (options ? options : VImage::option())->
1701 set( "out", &out )->
1702 set( "source", source ) );
1703
1704 return( out );
1705}
1706
1707void VImage::jp2ksave( const char *filename, VOption *options ) const
1708{
1709 call( "jp2ksave",
1710 (options ? options : VImage::option())->
1711 set( "in", *this )->
1712 set( "filename", filename ) );
1713}
1714
1715VipsBlob *VImage::jp2ksave_buffer( VOption *options ) const
1716{
1718
1719 call( "jp2ksave_buffer",
1720 (options ? options : VImage::option())->
1721 set( "in", *this )->
1722 set( "buffer", &buffer ) );
1723
1724 return( buffer );
1725}
1726
1727void VImage::jp2ksave_target( VTarget target, VOption *options ) const
1728{
1729 call( "jp2ksave_target",
1730 (options ? options : VImage::option())->
1731 set( "in", *this )->
1732 set( "target", target ) );
1733}
1734
1735VImage VImage::jpegload( const char *filename, VOption *options )
1736{
1737 VImage out;
1738
1739 call( "jpegload",
1740 (options ? options : VImage::option())->
1741 set( "out", &out )->
1742 set( "filename", filename ) );
1743
1744 return( out );
1745}
1746
1747VImage VImage::jpegload_buffer( VipsBlob *buffer, VOption *options )
1748{
1749 VImage out;
1750
1751 call( "jpegload_buffer",
1752 (options ? options : VImage::option())->
1753 set( "out", &out )->
1754 set( "buffer", buffer ) );
1755
1756 return( out );
1757}
1758
1760{
1761 VImage out;
1762
1763 call( "jpegload_source",
1764 (options ? options : VImage::option())->
1765 set( "out", &out )->
1766 set( "source", source ) );
1767
1768 return( out );
1769}
1770
1771void VImage::jpegsave( const char *filename, VOption *options ) const
1772{
1773 call( "jpegsave",
1774 (options ? options : VImage::option())->
1775 set( "in", *this )->
1776 set( "filename", filename ) );
1777}
1778
1779VipsBlob *VImage::jpegsave_buffer( VOption *options ) const
1780{
1782
1783 call( "jpegsave_buffer",
1784 (options ? options : VImage::option())->
1785 set( "in", *this )->
1786 set( "buffer", &buffer ) );
1787
1788 return( buffer );
1789}
1790
1791void VImage::jpegsave_mime( VOption *options ) const
1792{
1793 call( "jpegsave_mime",
1794 (options ? options : VImage::option())->
1795 set( "in", *this ) );
1796}
1797
1798void VImage::jpegsave_target( VTarget target, VOption *options ) const
1799{
1800 call( "jpegsave_target",
1801 (options ? options : VImage::option())->
1802 set( "in", *this )->
1803 set( "target", target ) );
1804}
1805
1806VImage VImage::jxlload( const char *filename, VOption *options )
1807{
1808 VImage out;
1809
1810 call( "jxlload",
1811 (options ? options : VImage::option())->
1812 set( "out", &out )->
1813 set( "filename", filename ) );
1814
1815 return( out );
1816}
1817
1818VImage VImage::jxlload_buffer( VipsBlob *buffer, VOption *options )
1819{
1820 VImage out;
1821
1822 call( "jxlload_buffer",
1823 (options ? options : VImage::option())->
1824 set( "out", &out )->
1825 set( "buffer", buffer ) );
1826
1827 return( out );
1828}
1829
1831{
1832 VImage out;
1833
1834 call( "jxlload_source",
1835 (options ? options : VImage::option())->
1836 set( "out", &out )->
1837 set( "source", source ) );
1838
1839 return( out );
1840}
1841
1842void VImage::jxlsave( const char *filename, VOption *options ) const
1843{
1844 call( "jxlsave",
1845 (options ? options : VImage::option())->
1846 set( "in", *this )->
1847 set( "filename", filename ) );
1848}
1849
1850VipsBlob *VImage::jxlsave_buffer( VOption *options ) const
1851{
1853
1854 call( "jxlsave_buffer",
1855 (options ? options : VImage::option())->
1856 set( "in", *this )->
1857 set( "buffer", &buffer ) );
1858
1859 return( buffer );
1860}
1861
1862void VImage::jxlsave_target( VTarget target, VOption *options ) const
1863{
1864 call( "jxlsave_target",
1865 (options ? options : VImage::option())->
1866 set( "in", *this )->
1867 set( "target", target ) );
1868}
1869
1871{
1872 VImage mask;
1873
1874 call( "labelregions",
1875 (options ? options : VImage::option())->
1876 set( "in", *this )->
1877 set( "mask", &mask ) );
1878
1879 return( mask );
1880}
1881
1882VImage VImage::linear( std::vector<double> a, std::vector<double> b, VOption *options ) const
1883{
1884 VImage out;
1885
1886 call( "linear",
1887 (options ? options : VImage::option())->
1888 set( "in", *this )->
1889 set( "out", &out )->
1890 set( "a", a )->
1891 set( "b", b ) );
1892
1893 return( out );
1894}
1895
1897{
1898 VImage out;
1899
1900 call( "linecache",
1901 (options ? options : VImage::option())->
1902 set( "in", *this )->
1903 set( "out", &out ) );
1904
1905 return( out );
1906}
1907
1908VImage VImage::logmat( double sigma, double min_ampl, VOption *options )
1909{
1910 VImage out;
1911
1912 call( "logmat",
1913 (options ? options : VImage::option())->
1914 set( "out", &out )->
1915 set( "sigma", sigma )->
1916 set( "min_ampl", min_ampl ) );
1917
1918 return( out );
1919}
1920
1921VImage VImage::magickload( const char *filename, VOption *options )
1922{
1923 VImage out;
1924
1925 call( "magickload",
1926 (options ? options : VImage::option())->
1927 set( "out", &out )->
1928 set( "filename", filename ) );
1929
1930 return( out );
1931}
1932
1933VImage VImage::magickload_buffer( VipsBlob *buffer, VOption *options )
1934{
1935 VImage out;
1936
1937 call( "magickload_buffer",
1938 (options ? options : VImage::option())->
1939 set( "out", &out )->
1940 set( "buffer", buffer ) );
1941
1942 return( out );
1943}
1944
1945void VImage::magicksave( const char *filename, VOption *options ) const
1946{
1947 call( "magicksave",
1948 (options ? options : VImage::option())->
1949 set( "in", *this )->
1950 set( "filename", filename ) );
1951}
1952
1953VipsBlob *VImage::magicksave_buffer( VOption *options ) const
1954{
1956
1957 call( "magicksave_buffer",
1958 (options ? options : VImage::option())->
1959 set( "in", *this )->
1960 set( "buffer", &buffer ) );
1961
1962 return( buffer );
1963}
1964
1965VImage VImage::mapim( VImage index, VOption *options ) const
1966{
1967 VImage out;
1968
1969 call( "mapim",
1970 (options ? options : VImage::option())->
1971 set( "in", *this )->
1972 set( "out", &out )->
1973 set( "index", index ) );
1974
1975 return( out );
1976}
1977
1978VImage VImage::maplut( VImage lut, VOption *options ) const
1979{
1980 VImage out;
1981
1982 call( "maplut",
1983 (options ? options : VImage::option())->
1984 set( "in", *this )->
1985 set( "out", &out )->
1986 set( "lut", lut ) );
1987
1988 return( out );
1989}
1990
1991VImage VImage::mask_butterworth( int width, int height, double order, double frequency_cutoff, double amplitude_cutoff, VOption *options )
1992{
1993 VImage out;
1994
1995 call( "mask_butterworth",
1996 (options ? options : VImage::option())->
1997 set( "out", &out )->
1998 set( "width", width )->
1999 set( "height", height )->
2000 set( "order", order )->
2001 set( "frequency_cutoff", frequency_cutoff )->
2002 set( "amplitude_cutoff", amplitude_cutoff ) );
2003
2004 return( out );
2005}
2006
2007VImage VImage::mask_butterworth_band( int width, int height, double order, double frequency_cutoff_x, double frequency_cutoff_y, double radius, double amplitude_cutoff, VOption *options )
2008{
2009 VImage out;
2010
2011 call( "mask_butterworth_band",
2012 (options ? options : VImage::option())->
2013 set( "out", &out )->
2014 set( "width", width )->
2015 set( "height", height )->
2016 set( "order", order )->
2017 set( "frequency_cutoff_x", frequency_cutoff_x )->
2018 set( "frequency_cutoff_y", frequency_cutoff_y )->
2019 set( "radius", radius )->
2020 set( "amplitude_cutoff", amplitude_cutoff ) );
2021
2022 return( out );
2023}
2024
2025VImage VImage::mask_butterworth_ring( int width, int height, double order, double frequency_cutoff, double amplitude_cutoff, double ringwidth, VOption *options )
2026{
2027 VImage out;
2028
2029 call( "mask_butterworth_ring",
2030 (options ? options : VImage::option())->
2031 set( "out", &out )->
2032 set( "width", width )->
2033 set( "height", height )->
2034 set( "order", order )->
2035 set( "frequency_cutoff", frequency_cutoff )->
2036 set( "amplitude_cutoff", amplitude_cutoff )->
2037 set( "ringwidth", ringwidth ) );
2038
2039 return( out );
2040}
2041
2042VImage VImage::mask_fractal( int width, int height, double fractal_dimension, VOption *options )
2043{
2044 VImage out;
2045
2046 call( "mask_fractal",
2047 (options ? options : VImage::option())->
2048 set( "out", &out )->
2049 set( "width", width )->
2050 set( "height", height )->
2051 set( "fractal_dimension", fractal_dimension ) );
2052
2053 return( out );
2054}
2055
2056VImage VImage::mask_gaussian( int width, int height, double frequency_cutoff, double amplitude_cutoff, VOption *options )
2057{
2058 VImage out;
2059
2060 call( "mask_gaussian",
2061 (options ? options : VImage::option())->
2062 set( "out", &out )->
2063 set( "width", width )->
2064 set( "height", height )->
2065 set( "frequency_cutoff", frequency_cutoff )->
2066 set( "amplitude_cutoff", amplitude_cutoff ) );
2067
2068 return( out );
2069}
2070
2071VImage VImage::mask_gaussian_band( int width, int height, double frequency_cutoff_x, double frequency_cutoff_y, double radius, double amplitude_cutoff, VOption *options )
2072{
2073 VImage out;
2074
2075 call( "mask_gaussian_band",
2076 (options ? options : VImage::option())->
2077 set( "out", &out )->
2078 set( "width", width )->
2079 set( "height", height )->
2080 set( "frequency_cutoff_x", frequency_cutoff_x )->
2081 set( "frequency_cutoff_y", frequency_cutoff_y )->
2082 set( "radius", radius )->
2083 set( "amplitude_cutoff", amplitude_cutoff ) );
2084
2085 return( out );
2086}
2087
2088VImage VImage::mask_gaussian_ring( int width, int height, double frequency_cutoff, double amplitude_cutoff, double ringwidth, VOption *options )
2089{
2090 VImage out;
2091
2092 call( "mask_gaussian_ring",
2093 (options ? options : VImage::option())->
2094 set( "out", &out )->
2095 set( "width", width )->
2096 set( "height", height )->
2097 set( "frequency_cutoff", frequency_cutoff )->
2098 set( "amplitude_cutoff", amplitude_cutoff )->
2099 set( "ringwidth", ringwidth ) );
2100
2101 return( out );
2102}
2103
2104VImage VImage::mask_ideal( int width, int height, double frequency_cutoff, VOption *options )
2105{
2106 VImage out;
2107
2108 call( "mask_ideal",
2109 (options ? options : VImage::option())->
2110 set( "out", &out )->
2111 set( "width", width )->
2112 set( "height", height )->
2113 set( "frequency_cutoff", frequency_cutoff ) );
2114
2115 return( out );
2116}
2117
2118VImage VImage::mask_ideal_band( int width, int height, double frequency_cutoff_x, double frequency_cutoff_y, double radius, VOption *options )
2119{
2120 VImage out;
2121
2122 call( "mask_ideal_band",
2123 (options ? options : VImage::option())->
2124 set( "out", &out )->
2125 set( "width", width )->
2126 set( "height", height )->
2127 set( "frequency_cutoff_x", frequency_cutoff_x )->
2128 set( "frequency_cutoff_y", frequency_cutoff_y )->
2129 set( "radius", radius ) );
2130
2131 return( out );
2132}
2133
2134VImage VImage::mask_ideal_ring( int width, int height, double frequency_cutoff, double ringwidth, VOption *options )
2135{
2136 VImage out;
2137
2138 call( "mask_ideal_ring",
2139 (options ? options : VImage::option())->
2140 set( "out", &out )->
2141 set( "width", width )->
2142 set( "height", height )->
2143 set( "frequency_cutoff", frequency_cutoff )->
2144 set( "ringwidth", ringwidth ) );
2145
2146 return( out );
2147}
2148
2149VImage VImage::match( VImage sec, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, VOption *options ) const
2150{
2151 VImage out;
2152
2153 call( "match",
2154 (options ? options : VImage::option())->
2155 set( "ref", *this )->
2156 set( "out", &out )->
2157 set( "sec", sec )->
2158 set( "xr1", xr1 )->
2159 set( "yr1", yr1 )->
2160 set( "xs1", xs1 )->
2161 set( "ys1", ys1 )->
2162 set( "xr2", xr2 )->
2163 set( "yr2", yr2 )->
2164 set( "xs2", xs2 )->
2165 set( "ys2", ys2 ) );
2166
2167 return( out );
2168}
2169
2170VImage VImage::math( VipsOperationMath math, VOption *options ) const
2171{
2172 VImage out;
2173
2174 call( "math",
2175 (options ? options : VImage::option())->
2176 set( "in", *this )->
2177 set( "out", &out )->
2178 set( "math", math ) );
2179
2180 return( out );
2181}
2182
2183VImage VImage::math2( VImage right, VipsOperationMath2 math2, VOption *options ) const
2184{
2185 VImage out;
2186
2187 call( "math2",
2188 (options ? options : VImage::option())->
2189 set( "left", *this )->
2190 set( "out", &out )->
2191 set( "right", right )->
2192 set( "math2", math2 ) );
2193
2194 return( out );
2195}
2196
2197VImage VImage::math2_const( VipsOperationMath2 math2, std::vector<double> c, VOption *options ) const
2198{
2199 VImage out;
2200
2201 call( "math2_const",
2202 (options ? options : VImage::option())->
2203 set( "in", *this )->
2204 set( "out", &out )->
2205 set( "math2", math2 )->
2206 set( "c", c ) );
2207
2208 return( out );
2209}
2210
2211VImage VImage::matload( const char *filename, VOption *options )
2212{
2213 VImage out;
2214
2215 call( "matload",
2216 (options ? options : VImage::option())->
2217 set( "out", &out )->
2218 set( "filename", filename ) );
2219
2220 return( out );
2221}
2222
2224{
2225 VImage out;
2226
2227 call( "matrixinvert",
2228 (options ? options : VImage::option())->
2229 set( "in", *this )->
2230 set( "out", &out ) );
2231
2232 return( out );
2233}
2234
2235VImage VImage::matrixload( const char *filename, VOption *options )
2236{
2237 VImage out;
2238
2239 call( "matrixload",
2240 (options ? options : VImage::option())->
2241 set( "out", &out )->
2242 set( "filename", filename ) );
2243
2244 return( out );
2245}
2246
2248{
2249 VImage out;
2250
2251 call( "matrixload_source",
2252 (options ? options : VImage::option())->
2253 set( "out", &out )->
2254 set( "source", source ) );
2255
2256 return( out );
2257}
2258
2259void VImage::matrixprint( VOption *options ) const
2260{
2261 call( "matrixprint",
2262 (options ? options : VImage::option())->
2263 set( "in", *this ) );
2264}
2265
2266void VImage::matrixsave( const char *filename, VOption *options ) const
2267{
2268 call( "matrixsave",
2269 (options ? options : VImage::option())->
2270 set( "in", *this )->
2271 set( "filename", filename ) );
2272}
2273
2274void VImage::matrixsave_target( VTarget target, VOption *options ) const
2275{
2276 call( "matrixsave_target",
2277 (options ? options : VImage::option())->
2278 set( "in", *this )->
2279 set( "target", target ) );
2280}
2281
2282double VImage::max( VOption *options ) const
2283{
2284 double out;
2285
2286 call( "max",
2287 (options ? options : VImage::option())->
2288 set( "in", *this )->
2289 set( "out", &out ) );
2290
2291 return( out );
2292}
2293
2294VImage VImage::measure( int h, int v, VOption *options ) const
2295{
2296 VImage out;
2297
2298 call( "measure",
2299 (options ? options : VImage::option())->
2300 set( "in", *this )->
2301 set( "out", &out )->
2302 set( "h", h )->
2303 set( "v", v ) );
2304
2305 return( out );
2306}
2307
2308VImage VImage::merge( VImage sec, VipsDirection direction, int dx, int dy, VOption *options ) const
2309{
2310 VImage out;
2311
2312 call( "merge",
2313 (options ? options : VImage::option())->
2314 set( "ref", *this )->
2315 set( "out", &out )->
2316 set( "sec", sec )->
2317 set( "direction", direction )->
2318 set( "dx", dx )->
2319 set( "dy", dy ) );
2320
2321 return( out );
2322}
2323
2324double VImage::min( VOption *options ) const
2325{
2326 double out;
2327
2328 call( "min",
2329 (options ? options : VImage::option())->
2330 set( "in", *this )->
2331 set( "out", &out ) );
2332
2333 return( out );
2334}
2335
2336VImage VImage::morph( VImage mask, VipsOperationMorphology morph, VOption *options ) const
2337{
2338 VImage out;
2339
2340 call( "morph",
2341 (options ? options : VImage::option())->
2342 set( "in", *this )->
2343 set( "out", &out )->
2344 set( "mask", mask )->
2345 set( "morph", morph ) );
2346
2347 return( out );
2348}
2349
2350VImage VImage::mosaic( VImage sec, VipsDirection direction, int xref, int yref, int xsec, int ysec, VOption *options ) const
2351{
2352 VImage out;
2353
2354 call( "mosaic",
2355 (options ? options : VImage::option())->
2356 set( "ref", *this )->
2357 set( "out", &out )->
2358 set( "sec", sec )->
2359 set( "direction", direction )->
2360 set( "xref", xref )->
2361 set( "yref", yref )->
2362 set( "xsec", xsec )->
2363 set( "ysec", ysec ) );
2364
2365 return( out );
2366}
2367
2368VImage VImage::mosaic1( VImage sec, VipsDirection direction, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, VOption *options ) const
2369{
2370 VImage out;
2371
2372 call( "mosaic1",
2373 (options ? options : VImage::option())->
2374 set( "ref", *this )->
2375 set( "out", &out )->
2376 set( "sec", sec )->
2377 set( "direction", direction )->
2378 set( "xr1", xr1 )->
2379 set( "yr1", yr1 )->
2380 set( "xs1", xs1 )->
2381 set( "ys1", ys1 )->
2382 set( "xr2", xr2 )->
2383 set( "yr2", yr2 )->
2384 set( "xs2", xs2 )->
2385 set( "ys2", ys2 ) );
2386
2387 return( out );
2388}
2389
2390VImage VImage::msb( VOption *options ) const
2391{
2392 VImage out;
2393
2394 call( "msb",
2395 (options ? options : VImage::option())->
2396 set( "in", *this )->
2397 set( "out", &out ) );
2398
2399 return( out );
2400}
2401
2402VImage VImage::multiply( VImage right, VOption *options ) const
2403{
2404 VImage out;
2405
2406 call( "multiply",
2407 (options ? options : VImage::option())->
2408 set( "left", *this )->
2409 set( "out", &out )->
2410 set( "right", right ) );
2411
2412 return( out );
2413}
2414
2415VImage VImage::niftiload( const char *filename, VOption *options )
2416{
2417 VImage out;
2418
2419 call( "niftiload",
2420 (options ? options : VImage::option())->
2421 set( "out", &out )->
2422 set( "filename", filename ) );
2423
2424 return( out );
2425}
2426
2428{
2429 VImage out;
2430
2431 call( "niftiload_source",
2432 (options ? options : VImage::option())->
2433 set( "out", &out )->
2434 set( "source", source ) );
2435
2436 return( out );
2437}
2438
2439void VImage::niftisave( const char *filename, VOption *options ) const
2440{
2441 call( "niftisave",
2442 (options ? options : VImage::option())->
2443 set( "in", *this )->
2444 set( "filename", filename ) );
2445}
2446
2447VImage VImage::openexrload( const char *filename, VOption *options )
2448{
2449 VImage out;
2450
2451 call( "openexrload",
2452 (options ? options : VImage::option())->
2453 set( "out", &out )->
2454 set( "filename", filename ) );
2455
2456 return( out );
2457}
2458
2459VImage VImage::openslideload( const char *filename, VOption *options )
2460{
2461 VImage out;
2462
2463 call( "openslideload",
2464 (options ? options : VImage::option())->
2465 set( "out", &out )->
2466 set( "filename", filename ) );
2467
2468 return( out );
2469}
2470
2472{
2473 VImage out;
2474
2475 call( "openslideload_source",
2476 (options ? options : VImage::option())->
2477 set( "out", &out )->
2478 set( "source", source ) );
2479
2480 return( out );
2481}
2482
2483VImage VImage::pdfload( const char *filename, VOption *options )
2484{
2485 VImage out;
2486
2487 call( "pdfload",
2488 (options ? options : VImage::option())->
2489 set( "out", &out )->
2490 set( "filename", filename ) );
2491
2492 return( out );
2493}
2494
2495VImage VImage::pdfload_buffer( VipsBlob *buffer, VOption *options )
2496{
2497 VImage out;
2498
2499 call( "pdfload_buffer",
2500 (options ? options : VImage::option())->
2501 set( "out", &out )->
2502 set( "buffer", buffer ) );
2503
2504 return( out );
2505}
2506
2508{
2509 VImage out;
2510
2511 call( "pdfload_source",
2512 (options ? options : VImage::option())->
2513 set( "out", &out )->
2514 set( "source", source ) );
2515
2516 return( out );
2517}
2518
2519int VImage::percent( double percent, VOption *options ) const
2520{
2521 int threshold;
2522
2523 call( "percent",
2524 (options ? options : VImage::option())->
2525 set( "in", *this )->
2526 set( "threshold", &threshold )->
2527 set( "percent", percent ) );
2528
2529 return( threshold );
2530}
2531
2532VImage VImage::perlin( int width, int height, VOption *options )
2533{
2534 VImage out;
2535
2536 call( "perlin",
2537 (options ? options : VImage::option())->
2538 set( "out", &out )->
2539 set( "width", width )->
2540 set( "height", height ) );
2541
2542 return( out );
2543}
2544
2546{
2547 VImage out;
2548
2549 call( "phasecor",
2550 (options ? options : VImage::option())->
2551 set( "in", *this )->
2552 set( "out", &out )->
2553 set( "in2", in2 ) );
2554
2555 return( out );
2556}
2557
2558VImage VImage::pngload( const char *filename, VOption *options )
2559{
2560 VImage out;
2561
2562 call( "pngload",
2563 (options ? options : VImage::option())->
2564 set( "out", &out )->
2565 set( "filename", filename ) );
2566
2567 return( out );
2568}
2569
2570VImage VImage::pngload_buffer( VipsBlob *buffer, VOption *options )
2571{
2572 VImage out;
2573
2574 call( "pngload_buffer",
2575 (options ? options : VImage::option())->
2576 set( "out", &out )->
2577 set( "buffer", buffer ) );
2578
2579 return( out );
2580}
2581
2583{
2584 VImage out;
2585
2586 call( "pngload_source",
2587 (options ? options : VImage::option())->
2588 set( "out", &out )->
2589 set( "source", source ) );
2590
2591 return( out );
2592}
2593
2594void VImage::pngsave( const char *filename, VOption *options ) const
2595{
2596 call( "pngsave",
2597 (options ? options : VImage::option())->
2598 set( "in", *this )->
2599 set( "filename", filename ) );
2600}
2601
2602VipsBlob *VImage::pngsave_buffer( VOption *options ) const
2603{
2605
2606 call( "pngsave_buffer",
2607 (options ? options : VImage::option())->
2608 set( "in", *this )->
2609 set( "buffer", &buffer ) );
2610
2611 return( buffer );
2612}
2613
2614void VImage::pngsave_target( VTarget target, VOption *options ) const
2615{
2616 call( "pngsave_target",
2617 (options ? options : VImage::option())->
2618 set( "in", *this )->
2619 set( "target", target ) );
2620}
2621
2622VImage VImage::ppmload( const char *filename, VOption *options )
2623{
2624 VImage out;
2625
2626 call( "ppmload",
2627 (options ? options : VImage::option())->
2628 set( "out", &out )->
2629 set( "filename", filename ) );
2630
2631 return( out );
2632}
2633
2635{
2636 VImage out;
2637
2638 call( "ppmload_source",
2639 (options ? options : VImage::option())->
2640 set( "out", &out )->
2641 set( "source", source ) );
2642
2643 return( out );
2644}
2645
2646void VImage::ppmsave( const char *filename, VOption *options ) const
2647{
2648 call( "ppmsave",
2649 (options ? options : VImage::option())->
2650 set( "in", *this )->
2651 set( "filename", filename ) );
2652}
2653
2654void VImage::ppmsave_target( VTarget target, VOption *options ) const
2655{
2656 call( "ppmsave_target",
2657 (options ? options : VImage::option())->
2658 set( "in", *this )->
2659 set( "target", target ) );
2660}
2661
2663{
2664 VImage out;
2665
2666 call( "premultiply",
2667 (options ? options : VImage::option())->
2668 set( "in", *this )->
2669 set( "out", &out ) );
2670
2671 return( out );
2672}
2673
2674VImage VImage::profile( VImage *rows, VOption *options ) const
2675{
2677
2678 call( "profile",
2679 (options ? options : VImage::option())->
2680 set( "in", *this )->
2681 set( "columns", &columns )->
2682 set( "rows", rows ) );
2683
2684 return( columns );
2685}
2686
2687VipsBlob *VImage::profile_load( const char *name, VOption *options )
2688{
2690
2691 call( "profile_load",
2692 (options ? options : VImage::option())->
2693 set( "profile", &profile )->
2694 set( "name", name ) );
2695
2696 return( profile );
2697}
2698
2699VImage VImage::project( VImage *rows, VOption *options ) const
2700{
2702
2703 call( "project",
2704 (options ? options : VImage::option())->
2705 set( "in", *this )->
2706 set( "columns", &columns )->
2707 set( "rows", rows ) );
2708
2709 return( columns );
2710}
2711
2712VImage VImage::quadratic( VImage coeff, VOption *options ) const
2713{
2714 VImage out;
2715
2716 call( "quadratic",
2717 (options ? options : VImage::option())->
2718 set( "in", *this )->
2719 set( "out", &out )->
2720 set( "coeff", coeff ) );
2721
2722 return( out );
2723}
2724
2726{
2727 VImage out;
2728
2729 call( "rad2float",
2730 (options ? options : VImage::option())->
2731 set( "in", *this )->
2732 set( "out", &out ) );
2733
2734 return( out );
2735}
2736
2737VImage VImage::radload( const char *filename, VOption *options )
2738{
2739 VImage out;
2740
2741 call( "radload",
2742 (options ? options : VImage::option())->
2743 set( "out", &out )->
2744 set( "filename", filename ) );
2745
2746 return( out );
2747}
2748
2749VImage VImage::radload_buffer( VipsBlob *buffer, VOption *options )
2750{
2751 VImage out;
2752
2753 call( "radload_buffer",
2754 (options ? options : VImage::option())->
2755 set( "out", &out )->
2756 set( "buffer", buffer ) );
2757
2758 return( out );
2759}
2760
2762{
2763 VImage out;
2764
2765 call( "radload_source",
2766 (options ? options : VImage::option())->
2767 set( "out", &out )->
2768 set( "source", source ) );
2769
2770 return( out );
2771}
2772
2773void VImage::radsave( const char *filename, VOption *options ) const
2774{
2775 call( "radsave",
2776 (options ? options : VImage::option())->
2777 set( "in", *this )->
2778 set( "filename", filename ) );
2779}
2780
2781VipsBlob *VImage::radsave_buffer( VOption *options ) const
2782{
2784
2785 call( "radsave_buffer",
2786 (options ? options : VImage::option())->
2787 set( "in", *this )->
2788 set( "buffer", &buffer ) );
2789
2790 return( buffer );
2791}
2792
2793void VImage::radsave_target( VTarget target, VOption *options ) const
2794{
2795 call( "radsave_target",
2796 (options ? options : VImage::option())->
2797 set( "in", *this )->
2798 set( "target", target ) );
2799}
2800
2801VImage VImage::rank( int width, int height, int index, VOption *options ) const
2802{
2803 VImage out;
2804
2805 call( "rank",
2806 (options ? options : VImage::option())->
2807 set( "in", *this )->
2808 set( "out", &out )->
2809 set( "width", width )->
2810 set( "height", height )->
2811 set( "index", index ) );
2812
2813 return( out );
2814}
2815
2816VImage VImage::rawload( const char *filename, int width, int height, int bands, VOption *options )
2817{
2818 VImage out;
2819
2820 call( "rawload",
2821 (options ? options : VImage::option())->
2822 set( "out", &out )->
2823 set( "filename", filename )->
2824 set( "width", width )->
2825 set( "height", height )->
2826 set( "bands", bands ) );
2827
2828 return( out );
2829}
2830
2831void VImage::rawsave( const char *filename, VOption *options ) const
2832{
2833 call( "rawsave",
2834 (options ? options : VImage::option())->
2835 set( "in", *this )->
2836 set( "filename", filename ) );
2837}
2838
2839void VImage::rawsave_fd( int fd, VOption *options ) const
2840{
2841 call( "rawsave_fd",
2842 (options ? options : VImage::option())->
2843 set( "in", *this )->
2844 set( "fd", fd ) );
2845}
2846
2848{
2849 VImage out;
2850
2851 call( "recomb",
2852 (options ? options : VImage::option())->
2853 set( "in", *this )->
2854 set( "out", &out )->
2855 set( "m", m ) );
2856
2857 return( out );
2858}
2859
2860VImage VImage::reduce( double hshrink, double vshrink, VOption *options ) const
2861{
2862 VImage out;
2863
2864 call( "reduce",
2865 (options ? options : VImage::option())->
2866 set( "in", *this )->
2867 set( "out", &out )->
2868 set( "hshrink", hshrink )->
2869 set( "vshrink", vshrink ) );
2870
2871 return( out );
2872}
2873
2874VImage VImage::reduceh( double hshrink, VOption *options ) const
2875{
2876 VImage out;
2877
2878 call( "reduceh",
2879 (options ? options : VImage::option())->
2880 set( "in", *this )->
2881 set( "out", &out )->
2882 set( "hshrink", hshrink ) );
2883
2884 return( out );
2885}
2886
2887VImage VImage::reducev( double vshrink, VOption *options ) const
2888{
2889 VImage out;
2890
2891 call( "reducev",
2892 (options ? options : VImage::option())->
2893 set( "in", *this )->
2894 set( "out", &out )->
2895 set( "vshrink", vshrink ) );
2896
2897 return( out );
2898}
2899
2900VImage VImage::relational( VImage right, VipsOperationRelational relational, VOption *options ) const
2901{
2902 VImage out;
2903
2904 call( "relational",
2905 (options ? options : VImage::option())->
2906 set( "left", *this )->
2907 set( "out", &out )->
2908 set( "right", right )->
2909 set( "relational", relational ) );
2910
2911 return( out );
2912}
2913
2914VImage VImage::relational_const( VipsOperationRelational relational, std::vector<double> c, VOption *options ) const
2915{
2916 VImage out;
2917
2918 call( "relational_const",
2919 (options ? options : VImage::option())->
2920 set( "in", *this )->
2921 set( "out", &out )->
2922 set( "relational", relational )->
2923 set( "c", c ) );
2924
2925 return( out );
2926}
2927
2928VImage VImage::remainder( VImage right, VOption *options ) const
2929{
2930 VImage out;
2931
2932 call( "remainder",
2933 (options ? options : VImage::option())->
2934 set( "left", *this )->
2935 set( "out", &out )->
2936 set( "right", right ) );
2937
2938 return( out );
2939}
2940
2941VImage VImage::remainder_const( std::vector<double> c, VOption *options ) const
2942{
2943 VImage out;
2944
2945 call( "remainder_const",
2946 (options ? options : VImage::option())->
2947 set( "in", *this )->
2948 set( "out", &out )->
2949 set( "c", c ) );
2950
2951 return( out );
2952}
2953
2954VImage VImage::replicate( int across, int down, VOption *options ) const
2955{
2956 VImage out;
2957
2958 call( "replicate",
2959 (options ? options : VImage::option())->
2960 set( "in", *this )->
2961 set( "out", &out )->
2962 set( "across", across )->
2963 set( "down", down ) );
2964
2965 return( out );
2966}
2967
2968VImage VImage::resize( double scale, VOption *options ) const
2969{
2970 VImage out;
2971
2972 call( "resize",
2973 (options ? options : VImage::option())->
2974 set( "in", *this )->
2975 set( "out", &out )->
2976 set( "scale", scale ) );
2977
2978 return( out );
2979}
2980
2981VImage VImage::rot( VipsAngle angle, VOption *options ) const
2982{
2983 VImage out;
2984
2985 call( "rot",
2986 (options ? options : VImage::option())->
2987 set( "in", *this )->
2988 set( "out", &out )->
2989 set( "angle", angle ) );
2990
2991 return( out );
2992}
2993
2995{
2996 VImage out;
2997
2998 call( "rot45",
2999 (options ? options : VImage::option())->
3000 set( "in", *this )->
3001 set( "out", &out ) );
3002
3003 return( out );
3004}
3005
3006VImage VImage::rotate( double angle, VOption *options ) const
3007{
3008 VImage out;
3009
3010 call( "rotate",
3011 (options ? options : VImage::option())->
3012 set( "in", *this )->
3013 set( "out", &out )->
3014 set( "angle", angle ) );
3015
3016 return( out );
3017}
3018
3019VImage VImage::round( VipsOperationRound round, VOption *options ) const
3020{
3021 VImage out;
3022
3023 call( "round",
3024 (options ? options : VImage::option())->
3025 set( "in", *this )->
3026 set( "out", &out )->
3027 set( "round", round ) );
3028
3029 return( out );
3030}
3031
3033{
3034 VImage out;
3035
3036 call( "sRGB2HSV",
3037 (options ? options : VImage::option())->
3038 set( "in", *this )->
3039 set( "out", &out ) );
3040
3041 return( out );
3042}
3043
3045{
3046 VImage out;
3047
3048 call( "sRGB2scRGB",
3049 (options ? options : VImage::option())->
3050 set( "in", *this )->
3051 set( "out", &out ) );
3052
3053 return( out );
3054}
3055
3057{
3058 VImage out;
3059
3060 call( "scRGB2BW",
3061 (options ? options : VImage::option())->
3062 set( "in", *this )->
3063 set( "out", &out ) );
3064
3065 return( out );
3066}
3067
3069{
3070 VImage out;
3071
3072 call( "scRGB2XYZ",
3073 (options ? options : VImage::option())->
3074 set( "in", *this )->
3075 set( "out", &out ) );
3076
3077 return( out );
3078}
3079
3081{
3082 VImage out;
3083
3084 call( "scRGB2sRGB",
3085 (options ? options : VImage::option())->
3086 set( "in", *this )->
3087 set( "out", &out ) );
3088
3089 return( out );
3090}
3091
3093{
3094 VImage out;
3095
3096 call( "scale",
3097 (options ? options : VImage::option())->
3098 set( "in", *this )->
3099 set( "out", &out ) );
3100
3101 return( out );
3102}
3103
3105{
3106 VImage out;
3107
3108 call( "sequential",
3109 (options ? options : VImage::option())->
3110 set( "in", *this )->
3111 set( "out", &out ) );
3112
3113 return( out );
3114}
3115
3117{
3118 VImage out;
3119
3120 call( "sharpen",
3121 (options ? options : VImage::option())->
3122 set( "in", *this )->
3123 set( "out", &out ) );
3124
3125 return( out );
3126}
3127
3128VImage VImage::shrink( double hshrink, double vshrink, VOption *options ) const
3129{
3130 VImage out;
3131
3132 call( "shrink",
3133 (options ? options : VImage::option())->
3134 set( "in", *this )->
3135 set( "out", &out )->
3136 set( "hshrink", hshrink )->
3137 set( "vshrink", vshrink ) );
3138
3139 return( out );
3140}
3141
3142VImage VImage::shrinkh( int hshrink, VOption *options ) const
3143{
3144 VImage out;
3145
3146 call( "shrinkh",
3147 (options ? options : VImage::option())->
3148 set( "in", *this )->
3149 set( "out", &out )->
3150 set( "hshrink", hshrink ) );
3151
3152 return( out );
3153}
3154
3155VImage VImage::shrinkv( int vshrink, VOption *options ) const
3156{
3157 VImage out;
3158
3159 call( "shrinkv",
3160 (options ? options : VImage::option())->
3161 set( "in", *this )->
3162 set( "out", &out )->
3163 set( "vshrink", vshrink ) );
3164
3165 return( out );
3166}
3167
3168VImage VImage::sign( VOption *options ) const
3169{
3170 VImage out;
3171
3172 call( "sign",
3173 (options ? options : VImage::option())->
3174 set( "in", *this )->
3175 set( "out", &out ) );
3176
3177 return( out );
3178}
3179
3181{
3182 VImage out;
3183
3184 call( "similarity",
3185 (options ? options : VImage::option())->
3186 set( "in", *this )->
3187 set( "out", &out ) );
3188
3189 return( out );
3190}
3191
3192VImage VImage::sines( int width, int height, VOption *options )
3193{
3194 VImage out;
3195
3196 call( "sines",
3197 (options ? options : VImage::option())->
3198 set( "out", &out )->
3199 set( "width", width )->
3200 set( "height", height ) );
3201
3202 return( out );
3203}
3204
3205VImage VImage::smartcrop( int width, int height, VOption *options ) const
3206{
3207 VImage out;
3208
3209 call( "smartcrop",
3210 (options ? options : VImage::option())->
3211 set( "input", *this )->
3212 set( "out", &out )->
3213 set( "width", width )->
3214 set( "height", height ) );
3215
3216 return( out );
3217}
3218
3220{
3221 VImage out;
3222
3223 call( "sobel",
3224 (options ? options : VImage::option())->
3225 set( "in", *this )->
3226 set( "out", &out ) );
3227
3228 return( out );
3229}
3230
3231VImage VImage::spcor( VImage ref, VOption *options ) const
3232{
3233 VImage out;
3234
3235 call( "spcor",
3236 (options ? options : VImage::option())->
3237 set( "in", *this )->
3238 set( "out", &out )->
3239 set( "ref", ref ) );
3240
3241 return( out );
3242}
3243
3245{
3246 VImage out;
3247
3248 call( "spectrum",
3249 (options ? options : VImage::option())->
3250 set( "in", *this )->
3251 set( "out", &out ) );
3252
3253 return( out );
3254}
3255
3257{
3258 VImage out;
3259
3260 call( "stats",
3261 (options ? options : VImage::option())->
3262 set( "in", *this )->
3263 set( "out", &out ) );
3264
3265 return( out );
3266}
3267
3268VImage VImage::stdif( int width, int height, VOption *options ) const
3269{
3270 VImage out;
3271
3272 call( "stdif",
3273 (options ? options : VImage::option())->
3274 set( "in", *this )->
3275 set( "out", &out )->
3276 set( "width", width )->
3277 set( "height", height ) );
3278
3279 return( out );
3280}
3281
3282VImage VImage::subsample( int xfac, int yfac, VOption *options ) const
3283{
3284 VImage out;
3285
3286 call( "subsample",
3287 (options ? options : VImage::option())->
3288 set( "input", *this )->
3289 set( "out", &out )->
3290 set( "xfac", xfac )->
3291 set( "yfac", yfac ) );
3292
3293 return( out );
3294}
3295
3296VImage VImage::subtract( VImage right, VOption *options ) const
3297{
3298 VImage out;
3299
3300 call( "subtract",
3301 (options ? options : VImage::option())->
3302 set( "left", *this )->
3303 set( "out", &out )->
3304 set( "right", right ) );
3305
3306 return( out );
3307}
3308
3309VImage VImage::sum( std::vector<VImage> in, VOption *options )
3310{
3311 VImage out;
3312
3313 call( "sum",
3314 (options ? options : VImage::option())->
3315 set( "out", &out )->
3316 set( "in", in ) );
3317
3318 return( out );
3319}
3320
3321VImage VImage::svgload( const char *filename, VOption *options )
3322{
3323 VImage out;
3324
3325 call( "svgload",
3326 (options ? options : VImage::option())->
3327 set( "out", &out )->
3328 set( "filename", filename ) );
3329
3330 return( out );
3331}
3332
3333VImage VImage::svgload_buffer( VipsBlob *buffer, VOption *options )
3334{
3335 VImage out;
3336
3337 call( "svgload_buffer",
3338 (options ? options : VImage::option())->
3339 set( "out", &out )->
3340 set( "buffer", buffer ) );
3341
3342 return( out );
3343}
3344
3346{
3347 VImage out;
3348
3349 call( "svgload_source",
3350 (options ? options : VImage::option())->
3351 set( "out", &out )->
3352 set( "source", source ) );
3353
3354 return( out );
3355}
3356
3357VImage VImage::switch_image( std::vector<VImage> tests, VOption *options )
3358{
3359 VImage out;
3360
3361 call( "switch",
3362 (options ? options : VImage::option())->
3363 set( "out", &out )->
3364 set( "tests", tests ) );
3365
3366 return( out );
3367}
3368
3369void VImage::system( const char *cmd_format, VOption *options )
3370{
3371 call( "system",
3372 (options ? options : VImage::option())->
3373 set( "cmd_format", cmd_format ) );
3374}
3375
3376VImage VImage::text( const char *text, VOption *options )
3377{
3378 VImage out;
3379
3380 call( "text",
3381 (options ? options : VImage::option())->
3382 set( "out", &out )->
3383 set( "text", text ) );
3384
3385 return( out );
3386}
3387
3388VImage VImage::thumbnail( const char *filename, int width, VOption *options )
3389{
3390 VImage out;
3391
3392 call( "thumbnail",
3393 (options ? options : VImage::option())->
3394 set( "out", &out )->
3395 set( "filename", filename )->
3396 set( "width", width ) );
3397
3398 return( out );
3399}
3400
3401VImage VImage::thumbnail_buffer( VipsBlob *buffer, int width, VOption *options )
3402{
3403 VImage out;
3404
3405 call( "thumbnail_buffer",
3406 (options ? options : VImage::option())->
3407 set( "out", &out )->
3408 set( "buffer", buffer )->
3409 set( "width", width ) );
3410
3411 return( out );
3412}
3413
3414VImage VImage::thumbnail_image( int width, VOption *options ) const
3415{
3416 VImage out;
3417
3418 call( "thumbnail_image",
3419 (options ? options : VImage::option())->
3420 set( "in", *this )->
3421 set( "out", &out )->
3422 set( "width", width ) );
3423
3424 return( out );
3425}
3426
3427VImage VImage::thumbnail_source( VSource source, int width, VOption *options )
3428{
3429 VImage out;
3430
3431 call( "thumbnail_source",
3432 (options ? options : VImage::option())->
3433 set( "out", &out )->
3434 set( "source", source )->
3435 set( "width", width ) );
3436
3437 return( out );
3438}
3439
3440VImage VImage::tiffload( const char *filename, VOption *options )
3441{
3442 VImage out;
3443
3444 call( "tiffload",
3445 (options ? options : VImage::option())->
3446 set( "out", &out )->
3447 set( "filename", filename ) );
3448
3449 return( out );
3450}
3451
3452VImage VImage::tiffload_buffer( VipsBlob *buffer, VOption *options )
3453{
3454 VImage out;
3455
3456 call( "tiffload_buffer",
3457 (options ? options : VImage::option())->
3458 set( "out", &out )->
3459 set( "buffer", buffer ) );
3460
3461 return( out );
3462}
3463
3465{
3466 VImage out;
3467
3468 call( "tiffload_source",
3469 (options ? options : VImage::option())->
3470 set( "out", &out )->
3471 set( "source", source ) );
3472
3473 return( out );
3474}
3475
3476void VImage::tiffsave( const char *filename, VOption *options ) const
3477{
3478 call( "tiffsave",
3479 (options ? options : VImage::option())->
3480 set( "in", *this )->
3481 set( "filename", filename ) );
3482}
3483
3484VipsBlob *VImage::tiffsave_buffer( VOption *options ) const
3485{
3487
3488 call( "tiffsave_buffer",
3489 (options ? options : VImage::option())->
3490 set( "in", *this )->
3491 set( "buffer", &buffer ) );
3492
3493 return( buffer );
3494}
3495
3497{
3498 VImage out;
3499
3500 call( "tilecache",
3501 (options ? options : VImage::option())->
3502 set( "in", *this )->
3503 set( "out", &out ) );
3504
3505 return( out );
3506}
3507
3509{
3510 VImage out;
3511
3512 call( "tonelut",
3513 (options ? options : VImage::option())->
3514 set( "out", &out ) );
3515
3516 return( out );
3517}
3518
3520{
3521 VImage out;
3522
3523 call( "transpose3d",
3524 (options ? options : VImage::option())->
3525 set( "in", *this )->
3526 set( "out", &out ) );
3527
3528 return( out );
3529}
3530
3532{
3533 VImage out;
3534
3535 call( "unpremultiply",
3536 (options ? options : VImage::option())->
3537 set( "in", *this )->
3538 set( "out", &out ) );
3539
3540 return( out );
3541}
3542
3543VImage VImage::vipsload( const char *filename, VOption *options )
3544{
3545 VImage out;
3546
3547 call( "vipsload",
3548 (options ? options : VImage::option())->
3549 set( "out", &out )->
3550 set( "filename", filename ) );
3551
3552 return( out );
3553}
3554
3556{
3557 VImage out;
3558
3559 call( "vipsload_source",
3560 (options ? options : VImage::option())->
3561 set( "out", &out )->
3562 set( "source", source ) );
3563
3564 return( out );
3565}
3566
3567void VImage::vipssave( const char *filename, VOption *options ) const
3568{
3569 call( "vipssave",
3570 (options ? options : VImage::option())->
3571 set( "in", *this )->
3572 set( "filename", filename ) );
3573}
3574
3575void VImage::vipssave_target( VTarget target, VOption *options ) const
3576{
3577 call( "vipssave_target",
3578 (options ? options : VImage::option())->
3579 set( "in", *this )->
3580 set( "target", target ) );
3581}
3582
3583VImage VImage::webpload( const char *filename, VOption *options )
3584{
3585 VImage out;
3586
3587 call( "webpload",
3588 (options ? options : VImage::option())->
3589 set( "out", &out )->
3590 set( "filename", filename ) );
3591
3592 return( out );
3593}
3594
3595VImage VImage::webpload_buffer( VipsBlob *buffer, VOption *options )
3596{
3597 VImage out;
3598
3599 call( "webpload_buffer",
3600 (options ? options : VImage::option())->
3601 set( "out", &out )->
3602 set( "buffer", buffer ) );
3603
3604 return( out );
3605}
3606
3608{
3609 VImage out;
3610
3611 call( "webpload_source",
3612 (options ? options : VImage::option())->
3613 set( "out", &out )->
3614 set( "source", source ) );
3615
3616 return( out );
3617}
3618
3619void VImage::webpsave( const char *filename, VOption *options ) const
3620{
3621 call( "webpsave",
3622 (options ? options : VImage::option())->
3623 set( "in", *this )->
3624 set( "filename", filename ) );
3625}
3626
3627VipsBlob *VImage::webpsave_buffer( VOption *options ) const
3628{
3630
3631 call( "webpsave_buffer",
3632 (options ? options : VImage::option())->
3633 set( "in", *this )->
3634 set( "buffer", &buffer ) );
3635
3636 return( buffer );
3637}
3638
3639void VImage::webpsave_target( VTarget target, VOption *options ) const
3640{
3641 call( "webpsave_target",
3642 (options ? options : VImage::option())->
3643 set( "in", *this )->
3644 set( "target", target ) );
3645}
3646
3647VImage VImage::worley( int width, int height, VOption *options )
3648{
3649 VImage out;
3650
3651 call( "worley",
3652 (options ? options : VImage::option())->
3653 set( "out", &out )->
3654 set( "width", width )->
3655 set( "height", height ) );
3656
3657 return( out );
3658}
3659
3660VImage VImage::wrap( VOption *options ) const
3661{
3662 VImage out;
3663
3664 call( "wrap",
3665 (options ? options : VImage::option())->
3666 set( "in", *this )->
3667 set( "out", &out ) );
3668
3669 return( out );
3670}
3671
3672VImage VImage::xyz( int width, int height, VOption *options )
3673{
3674 VImage out;
3675
3676 call( "xyz",
3677 (options ? options : VImage::option())->
3678 set( "out", &out )->
3679 set( "width", width )->
3680 set( "height", height ) );
3681
3682 return( out );
3683}
3684
3685VImage VImage::zone( int width, int height, VOption *options )
3686{
3687 VImage out;
3688
3689 call( "zone",
3690 (options ? options : VImage::option())->
3691 set( "out", &out )->
3692 set( "width", width )->
3693 set( "height", height ) );
3694
3695 return( out );
3696}
3697
3698VImage VImage::zoom( int xfac, int yfac, VOption *options ) const
3699{
3700 VImage out;
3701
3702 call( "zoom",
3703 (options ? options : VImage::option())->
3704 set( "input", *this )->
3705 set( "out", &out )->
3706 set( "xfac", xfac )->
3707 set( "yfac", yfac ) );
3708
3709 return( out );
3710}
Definition VImage8.h:405
VImage HSV2sRGB(VOption *options=0) const
Definition vips-operators.cpp:29
VImage join(VImage in2, VipsDirection direction, VOption *options=0) const
Definition vips-operators.cpp:1657
VImage conva(VImage mask, VOption *options=0) const
Definition vips-operators.cpp:639
VImage rot45(VOption *options=0) const
Definition vips-operators.cpp:2994
static VImage magickload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:1921
VImage canny(VOption *options=0) const
Definition vips-operators.cpp:482
static VImage mask_ideal_ring(int width, int height, double frequency_cutoff, double ringwidth, VOption *options=0)
Definition vips-operators.cpp:2134
VipsBlob * tiffsave_buffer(VOption *options=0) const
Definition vips-operators.cpp:3484
static VImage sines(int width, int height, VOption *options=0)
Definition vips-operators.cpp:3192
VImage XYZ2Lab(VOption *options=0) const
Definition vips-operators.cpp:185
VImage merge(VImage sec, VipsDirection direction, int dx, int dy, VOption *options=0) const
Definition vips-operators.cpp:2308
VImage quadratic(VImage coeff, VOption *options=0) const
Definition vips-operators.cpp:2712
VImage relational_const(VipsOperationRelational relational, std::vector< double > c, VOption *options=0) const
Definition vips-operators.cpp:2914
VImage relational(VImage right, VipsOperationRelational relational, VOption *options=0) const
Definition vips-operators.cpp:2900
VImage math2(VImage right, VipsOperationMath2 math2, VOption *options=0) const
Definition vips-operators.cpp:2183
static VImage pdfload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:2507
VImage shrinkh(int hshrink, VOption *options=0) const
Definition vips-operators.cpp:3142
VImage sequential(VOption *options=0) const
Definition vips-operators.cpp:3104
VImage hist_plot(VOption *options=0) const
Definition vips-operators.cpp:1508
static void call(const char *operation_name, VOption *options=0)
Definition VImage.cpp:560
VImage crop(int left, int top, int width, int height, VOption *options=0) const
Definition vips-operators.cpp:729
VImage bandmean(VOption *options=0) const
Definition vips-operators.cpp:369
VImage Lab2LabQ(VOption *options=0) const
Definition vips-operators.cpp:77
VImage LabQ2sRGB(VOption *options=0) const
Definition vips-operators.cpp:137
const char * filename() const
Definition VImage8.h:554
VImage smartcrop(int width, int height, VOption *options=0) const
Definition vips-operators.cpp:3205
static VImage csvload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:757
VImage LCh2CMC(VOption *options=0) const
Definition vips-operators.cpp:41
static VImage mask_gaussian_band(int width, int height, double frequency_cutoff_x, double frequency_cutoff_y, double radius, double amplitude_cutoff, VOption *options=0)
Definition vips-operators.cpp:2071
VImage CMYK2XYZ(VOption *options=0) const
Definition vips-operators.cpp:17
VImage hist_local(int width, int height, VOption *options=0) const
Definition vips-operators.cpp:1469
VImage autorot(VOption *options=0) const
Definition vips-operators.cpp:295
VImage tilecache(VOption *options=0) const
Definition vips-operators.cpp:3496
VImage thumbnail_image(int width, VOption *options=0) const
Definition vips-operators.cpp:3414
VipsBlob * magicksave_buffer(VOption *options=0) const
Definition vips-operators.cpp:1953
VImage dE76(VImage right, VOption *options=0) const
Definition vips-operators.cpp:798
static VImage jpegload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:1747
VImage fill_nearest(VOption *options=0) const
Definition vips-operators.cpp:1029
int percent(double percent, VOption *options=0) const
Definition vips-operators.cpp:2519
static VImage niftiload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:2415
static VImage webpload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:3607
static VImage black(int width, int height, VOption *options=0)
Definition vips-operators.cpp:405
VImage scRGB2XYZ(VOption *options=0) const
Definition vips-operators.cpp:3068
VImage colourspace(VipsInterpretation space, VOption *options=0) const
Definition vips-operators.cpp:520
static VImage rawload(const char *filename, int width, int height, int bands, VOption *options=0)
Definition vips-operators.cpp:2816
VipsBlob * dzsave_buffer(VOption *options=0) const
Definition vips-operators.cpp:934
static VImage vipsload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:3543
VImage gamma(VOption *options=0) const
Definition vips-operators.cpp:1164
VImage transpose3d(VOption *options=0) const
Definition vips-operators.cpp:3519
VImage scRGB2sRGB(VOption *options=0) const
Definition vips-operators.cpp:3080
VImage conv(VImage mask, VOption *options=0) const
Definition vips-operators.cpp:626
static VImage niftiload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:2427
VImage divide(VImage right, VOption *options=0) const
Definition vips-operators.cpp:836
double hist_entropy(VOption *options=0) const
Definition vips-operators.cpp:1396
void set(const char *field, int value)
Definition VImage8.h:575
VImage similarity(VOption *options=0) const
Definition vips-operators.cpp:3180
static VImage gifload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:1253
VImage grid(int tile_height, int across, int down, VOption *options=0) const
Definition vips-operators.cpp:1305
VImage XYZ2CMYK(VOption *options=0) const
Definition vips-operators.cpp:173
void jxlsave_target(VTarget target, VOption *options=0) const
Definition vips-operators.cpp:1862
VImage scRGB2BW(VOption *options=0) const
Definition vips-operators.cpp:3056
VImage case_image(std::vector< VImage > cases, VOption *options=0) const
Definition vips-operators.cpp:494
void draw_line(std::vector< double > ink, int x1, int y1, int x2, int y2, VOption *options=0) const
Definition vips-operators.cpp:880
void jpegsave_mime(VOption *options=0) const
Definition vips-operators.cpp:1791
VImage Lab2XYZ(VOption *options=0) const
Definition vips-operators.cpp:101
VImage shrink(double hshrink, double vshrink, VOption *options=0) const
Definition vips-operators.cpp:3128
VImage maplut(VImage lut, VOption *options=0) const
Definition vips-operators.cpp:1978
VImage gravity(VipsCompassDirection direction, int width, int height, VOption *options=0) const
Definition vips-operators.cpp:1277
VImage sharpen(VOption *options=0) const
Definition vips-operators.cpp:3116
static VImage heifload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:1344
VImage reduceh(double hshrink, VOption *options=0) const
Definition vips-operators.cpp:2874
VImage freqmult(VImage mask, VOption *options=0) const
Definition vips-operators.cpp:1139
void vipssave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:3567
static VImage radload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:2761
VImage invert(VOption *options=0) const
Definition vips-operators.cpp:1621
VImage Lab2LabS(VOption *options=0) const
Definition vips-operators.cpp:89
VImage stdif(int width, int height, VOption *options=0) const
Definition vips-operators.cpp:3268
static VImage xyz(int width, int height, VOption *options=0)
Definition vips-operators.cpp:3672
static VImage svgload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:3321
VImage math(VipsOperationMath math, VOption *options=0) const
Definition vips-operators.cpp:2170
void radsave_target(VTarget target, VOption *options=0) const
Definition vips-operators.cpp:2793
VImage math2_const(VipsOperationMath2 math2, std::vector< double > c, VOption *options=0) const
Definition vips-operators.cpp:2197
VImage invfft(VOption *options=0) const
Definition vips-operators.cpp:1645
VImage convi(VImage mask, VOption *options=0) const
Definition vips-operators.cpp:678
static VImage matload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:2211
VImage phasecor(VImage in2, VOption *options=0) const
Definition vips-operators.cpp:2545
bool hist_ismonotonic(VOption *options=0) const
Definition vips-operators.cpp:1457
VImage complex(VipsOperationComplex cmplx, VOption *options=0) const
Definition vips-operators.cpp:546
VipsBlob * jpegsave_buffer(VOption *options=0) const
Definition vips-operators.cpp:1779
VImage hist_find_ndim(VOption *options=0) const
Definition vips-operators.cpp:1445
VImage complexget(VipsOperationComplexget get, VOption *options=0) const
Definition vips-operators.cpp:586
VImage XYZ2Yxy(VOption *options=0) const
Definition vips-operators.cpp:197
void heifsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:1356
static VImage vipsload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:3555
static VImage tonelut(VOption *options=0)
Definition vips-operators.cpp:3508
VImage convf(VImage mask, VOption *options=0) const
Definition vips-operators.cpp:665
static VImage pdfload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:2483
VImage dECMC(VImage right, VOption *options=0) const
Definition vips-operators.cpp:811
static VImage tiffload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:3452
static VImage fitsload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:1056
static VImage mask_gaussian_ring(int width, int height, double frequency_cutoff, double amplitude_cutoff, double ringwidth, VOption *options=0)
Definition vips-operators.cpp:2088
static VImage fractsurf(int width, int height, double fractal_dimension, VOption *options=0)
Definition vips-operators.cpp:1125
void rawsave_fd(int fd, VOption *options=0) const
Definition vips-operators.cpp:2839
void jxlsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:1842
VImage sign(VOption *options=0) const
Definition vips-operators.cpp:3168
VImage zoom(int xfac, int yfac, VOption *options=0) const
Definition vips-operators.cpp:3698
void jp2ksave_target(VTarget target, VOption *options=0) const
Definition vips-operators.cpp:1727
static VImage logmat(double sigma, double min_ampl, VOption *options=0)
Definition vips-operators.cpp:1908
void draw_image(VImage sub, int x, int y, VOption *options=0) const
Definition vips-operators.cpp:870
VImage rank(int width, int height, int index, VOption *options=0) const
Definition vips-operators.cpp:2801
static VImage worley(int width, int height, VOption *options=0)
Definition vips-operators.cpp:3647
VImage icc_import(VOption *options=0) const
Definition vips-operators.cpp:1556
void draw_smudge(int left, int top, int width, int height, VOption *options=0) const
Definition vips-operators.cpp:915
static VImage zone(int width, int height, VOption *options=0)
Definition vips-operators.cpp:3685
VImage complexform(VImage right, VOption *options=0) const
Definition vips-operators.cpp:573
VImage fwfft(VOption *options=0) const
Definition vips-operators.cpp:1152
VImage labelregions(VOption *options=0) const
Definition vips-operators.cpp:1870
VImage subtract(VImage right, VOption *options=0) const
Definition vips-operators.cpp:3296
static VImage jpegload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:1735
static VImage jp2kload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:1683
void matrixsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:2266
static VImage svgload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:3333
static VImage webpload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:3595
static void system(const char *cmd_format, VOption *options=0)
Definition vips-operators.cpp:3369
std::vector< double > getpoint(int x, int y, VOption *options=0) const
Definition vips-operators.cpp:1215
VImage LabS2Lab(VOption *options=0) const
Definition vips-operators.cpp:149
VImage hist_find(VOption *options=0) const
Definition vips-operators.cpp:1420
VImage hist_equal(VOption *options=0) const
Definition vips-operators.cpp:1408
static VImage jp2kload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:1671
void webpsave_target(VTarget target, VOption *options=0) const
Definition vips-operators.cpp:3639
VImage hough_line(VOption *options=0) const
Definition vips-operators.cpp:1532
double avg(VOption *options=0) const
Definition vips-operators.cpp:307
static VImage grey(int width, int height, VOption *options=0)
Definition vips-operators.cpp:1292
void niftisave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:2439
VImage rot(VipsAngle angle, VOption *options=0) const
Definition vips-operators.cpp:2981
VImage round(VipsOperationRound round, VOption *options=0) const
Definition vips-operators.cpp:3019
static VImage eye(int width, int height, VOption *options=0)
Definition vips-operators.cpp:991
VipsBlob * heifsave_buffer(VOption *options=0) const
Definition vips-operators.cpp:1364
void fitssave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:1080
VImage sRGB2HSV(VOption *options=0) const
Definition vips-operators.cpp:3032
static VImage ppmload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:2622
void heifsave_target(VTarget target, VOption *options=0) const
Definition vips-operators.cpp:1376
VImage hist_norm(VOption *options=0) const
Definition vips-operators.cpp:1496
VipsBlob * webpsave_buffer(VOption *options=0) const
Definition vips-operators.cpp:3627
VImage buildlut(VOption *options=0) const
Definition vips-operators.cpp:446
VipsBlob * jxlsave_buffer(VOption *options=0) const
Definition vips-operators.cpp:1850
VImage mosaic1(VImage sec, VipsDirection direction, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, VOption *options=0) const
Definition vips-operators.cpp:2368
static VImage heifload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:1320
void pngsave_target(VTarget target, VOption *options=0) const
Definition vips-operators.cpp:2614
void jp2ksave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:1707
VImage hist_match(VImage ref, VOption *options=0) const
Definition vips-operators.cpp:1483
VImage sobel(VOption *options=0) const
Definition vips-operators.cpp:3219
VImage LabQ2Lab(VOption *options=0) const
Definition vips-operators.cpp:113
VImage complex2(VImage right, VipsOperationComplex2 cmplx, VOption *options=0) const
Definition vips-operators.cpp:559
VImage abs(VOption *options=0) const
Definition vips-operators.cpp:233
static VImage heifload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:1332
static VImage pngload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:2582
static VImage jpegload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:1759
void rawsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:2831
VImage remainder_const(std::vector< double > c, VOption *options=0) const
Definition vips-operators.cpp:2941
static VipsBlob * profile_load(const char *name, VOption *options=0)
Definition vips-operators.cpp:2687
VImage falsecolour(VOption *options=0) const
Definition vips-operators.cpp:1004
static VImage mask_ideal_band(int width, int height, double frequency_cutoff_x, double frequency_cutoff_y, double radius, VOption *options=0)
Definition vips-operators.cpp:2118
VImage rotate(double angle, VOption *options=0) const
Definition vips-operators.cpp:3006
VImage scale(VOption *options=0) const
Definition vips-operators.cpp:3092
static VImage arrayjoin(std::vector< VImage > in, VOption *options=0)
Definition vips-operators.cpp:283
void draw_rect(std::vector< double > ink, int left, int top, int width, int height, VOption *options=0) const
Definition vips-operators.cpp:903
VImage hough_circle(VOption *options=0) const
Definition vips-operators.cpp:1520
VImage fastcor(VImage ref, VOption *options=0) const
Definition vips-operators.cpp:1016
static VImage sum(std::vector< VImage > in, VOption *options=0)
Definition vips-operators.cpp:3309
VImage multiply(VImage right, VOption *options=0) const
Definition vips-operators.cpp:2402
static VImage analyzeload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:271
static VImage mask_fractal(int width, int height, double fractal_dimension, VOption *options=0)
Definition vips-operators.cpp:2042
void csvsave_target(VTarget target, VOption *options=0) const
Definition vips-operators.cpp:777
void draw_mask(std::vector< double > ink, VImage mask, int x, int y, VOption *options=0) const
Definition vips-operators.cpp:892
VImage boolean_const(VipsOperationBoolean boolean, std::vector< double > c, VOption *options=0) const
Definition vips-operators.cpp:432
VImage sRGB2scRGB(VOption *options=0) const
Definition vips-operators.cpp:3044
void webpsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:3619
VImage rad2float(VOption *options=0) const
Definition vips-operators.cpp:2725
int find_trim(int *top, int *width, int *height, VOption *options=0) const
Definition vips-operators.cpp:1041
static VImage mask_ideal(int width, int height, double frequency_cutoff, VOption *options=0)
Definition vips-operators.cpp:2104
VImage reduce(double hshrink, double vshrink, VOption *options=0) const
Definition vips-operators.cpp:2860
static VImage pdfload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:2495
VImage boolean(VImage right, VipsOperationBoolean boolean, VOption *options=0) const
Definition vips-operators.cpp:418
static VImage openslideload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:2471
VImage mosaic(VImage sec, VipsDirection direction, int xref, int yref, int xsec, int ysec, VOption *options=0) const
Definition vips-operators.cpp:2350
int height() const
Definition VImage8.h:452
void jpegsave_target(VTarget target, VOption *options=0) const
Definition vips-operators.cpp:1798
VImage stats(VOption *options=0) const
Definition vips-operators.cpp:3256
void ppmsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:2646
double max(VOption *options=0) const
Definition vips-operators.cpp:2282
VImage shrinkv(int vshrink, VOption *options=0) const
Definition vips-operators.cpp:3155
static VImage mask_butterworth_band(int width, int height, double order, double frequency_cutoff_x, double frequency_cutoff_y, double radius, double amplitude_cutoff, VOption *options=0)
Definition vips-operators.cpp:2007
static VImage pngload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:2570
void jpegsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:1771
static VImage tiffload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:3464
void tiffsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:3476
static VImage pngload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:2558
VipsBlob * jp2ksave_buffer(VOption *options=0) const
Definition vips-operators.cpp:1715
VImage linecache(VOption *options=0) const
Definition vips-operators.cpp:1896
VImage premultiply(VOption *options=0) const
Definition vips-operators.cpp:2662
VImage composite(VImage other, VipsBlendMode mode, VOption *options=0) const
Definition VImage.cpp:787
VImage cache(VOption *options=0) const
Definition vips-operators.cpp:470
static VImage jp2kload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:1695
VImage byteswap(VOption *options=0) const
Definition vips-operators.cpp:458
VImage remainder(VImage right, VOption *options=0) const
Definition vips-operators.cpp:2928
int bands() const
Definition VImage8.h:461
static VImage openexrload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:2447
static VImage mask_gaussian(int width, int height, double frequency_cutoff, double amplitude_cutoff, VOption *options=0)
Definition vips-operators.cpp:2056
VImage icc_export(VOption *options=0) const
Definition vips-operators.cpp:1544
VImage extract_band(int band, VOption *options=0) const
Definition vips-operators.cpp:978
VImage unpremultiply(VOption *options=0) const
Definition vips-operators.cpp:3531
VImage globalbalance(VOption *options=0) const
Definition vips-operators.cpp:1265
VImage morph(VImage mask, VipsOperationMorphology morph, VOption *options=0) const
Definition vips-operators.cpp:2336
VImage LabS2LabQ(VOption *options=0) const
Definition vips-operators.cpp:161
static VImage jxlload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:1806
static VImage ppmload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:2634
VImage CMC2LCh(VOption *options=0) const
Definition vips-operators.cpp:5
static VImage webpload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:3583
double deviate(VOption *options=0) const
Definition vips-operators.cpp:824
VImage insert(VImage sub, int x, int y, VOption *options=0) const
Definition vips-operators.cpp:1606
VImage ifthenelse(std::vector< double > th, VImage el, VOption *options=0) const
Definition VImage8.h:1477
VImage bandjoin_const(std::vector< double > c, VOption *options=0) const
Definition vips-operators.cpp:356
VImage spectrum(VOption *options=0) const
Definition vips-operators.cpp:3244
VImage dE00(VImage right, VOption *options=0) const
Definition vips-operators.cpp:785
void matrixprint(VOption *options=0) const
Definition vips-operators.cpp:2259
VImage flip(VipsDirection direction, VOption *options=0) const
Definition vips-operators.cpp:1100
static VImage gaussnoise(int width, int height, VOption *options=0)
Definition vips-operators.cpp:1202
double countlines(VipsDirection direction, VOption *options=0) const
Definition vips-operators.cpp:716
VImage linear(double a, double b, VOption *options=0) const
Definition VImage8.h:1064
void ppmsave_target(VTarget target, VOption *options=0) const
Definition vips-operators.cpp:2654
VImage Yxy2XYZ(VOption *options=0) const
Definition vips-operators.cpp:221
void magicksave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:1945
static VImage perlin(int width, int height, VOption *options=0)
Definition vips-operators.cpp:2532
VImage bandfold(VOption *options=0) const
Definition vips-operators.cpp:332
VImage match(VImage sec, int xr1, int yr1, int xs1, int ys1, int xr2, int yr2, int xs2, int ys2, VOption *options=0) const
Definition vips-operators.cpp:2149
void draw_flood(std::vector< double > ink, int x, int y, VOption *options=0) const
Definition vips-operators.cpp:860
static VImage radload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:2737
VImage copy(VOption *options=0) const
Definition vips-operators.cpp:704
static VImage jxlload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:1818
static VImage matrixload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:2247
VImage spcor(VImage ref, VOption *options=0) const
Definition vips-operators.cpp:3231
static VImage svgload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:3345
VImage Lab2LCh(VOption *options=0) const
Definition vips-operators.cpp:65
void draw_circle(std::vector< double > ink, int cx, int cy, int radius, VOption *options=0) const
Definition vips-operators.cpp:849
VImage extract_area(int left, int top, int width, int height, VOption *options=0) const
Definition vips-operators.cpp:962
VImage profile(VImage *rows, VOption *options=0) const
Definition vips-operators.cpp:2674
void vipssave_target(VTarget target, VOption *options=0) const
Definition vips-operators.cpp:3575
VImage hist_find_indexed(VImage index, VOption *options=0) const
Definition vips-operators.cpp:1432
VipsBandFormat format() const
Definition VImage8.h:470
static VImage thumbnail_source(VSource source, int width, VOption *options=0)
Definition vips-operators.cpp:3427
VImage mapim(VImage index, VOption *options=0) const
Definition vips-operators.cpp:1965
VImage recomb(VImage m, VOption *options=0) const
Definition vips-operators.cpp:2847
VImage icc_transform(const char *output_profile, VOption *options=0) const
Definition vips-operators.cpp:1568
static VImage thumbnail(const char *filename, int width, VOption *options=0)
Definition vips-operators.cpp:3388
void pngsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:2594
static VImage gifload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:1229
static VImage radload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:2749
static VImage gifload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:1241
VImage embed(int x, int y, int width, int height, VOption *options=0) const
Definition vips-operators.cpp:946
static VImage openslideload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:2459
void matrixsave_target(VTarget target, VOption *options=0) const
Definition vips-operators.cpp:2274
int width() const
Definition VImage8.h:443
VImage bandbool(VipsOperationBoolean boolean, VOption *options=0) const
Definition vips-operators.cpp:319
VImage convasep(VImage mask, VOption *options=0) const
Definition vips-operators.cpp:652
VImage float2rad(VOption *options=0) const
Definition vips-operators.cpp:1113
double min(VOption *options=0) const
Definition vips-operators.cpp:2324
VImage composite2(VImage overlay, VipsBlendMode mode, VOption *options=0) const
Definition vips-operators.cpp:612
static VImage switch_image(std::vector< VImage > tests, VOption *options=0)
Definition vips-operators.cpp:3357
static VImage bandrank(std::vector< VImage > in, VOption *options=0)
Definition vips-operators.cpp:381
VImage replicate(int across, int down, VOption *options=0) const
Definition vips-operators.cpp:2954
VipsBlob * radsave_buffer(VOption *options=0) const
Definition vips-operators.cpp:2781
VImage bandunfold(VOption *options=0) const
Definition vips-operators.cpp:393
static VImage gaussmat(double sigma, double min_ampl, VOption *options=0)
Definition vips-operators.cpp:1189
static VImage matrixload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:2235
VipsBlob * pngsave_buffer(VOption *options=0) const
Definition vips-operators.cpp:2602
static VImage tiffload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:3440
VImage affine(std::vector< double > matrix, VOption *options=0) const
Definition vips-operators.cpp:258
VImage matrixinvert(VOption *options=0) const
Definition vips-operators.cpp:2223
static VImage magickload_buffer(VipsBlob *buffer, VOption *options=0)
Definition vips-operators.cpp:1933
VImage add(VImage right, VOption *options=0) const
Definition vips-operators.cpp:245
VImage LabQ2LabS(VOption *options=0) const
Definition vips-operators.cpp:125
static VImage csvload(const char *filename, VOption *options=0)
Definition vips-operators.cpp:745
VImage LCh2Lab(VOption *options=0) const
Definition vips-operators.cpp:53
VImage hist_cum(VOption *options=0) const
Definition vips-operators.cpp:1384
void csvsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:769
VImage cast(VipsBandFormat format, VOption *options=0) const
Definition vips-operators.cpp:507
static VImage mask_butterworth(int width, int height, double order, double frequency_cutoff, double amplitude_cutoff, VOption *options=0)
Definition vips-operators.cpp:1991
static VImage text(const char *text, VOption *options=0)
Definition vips-operators.cpp:3376
static VImage fitsload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:1068
VImage msb(VOption *options=0) const
Definition vips-operators.cpp:2390
static VOption * option()
Definition VImage8.h:820
static VImage identity(VOption *options=0)
Definition vips-operators.cpp:1581
VImage flatten(VOption *options=0) const
Definition vips-operators.cpp:1088
VImage project(VImage *rows, VOption *options=0) const
Definition vips-operators.cpp:2699
VImage wrap(VOption *options=0) const
Definition vips-operators.cpp:3660
VImage convsep(VImage mask, VOption *options=0) const
Definition vips-operators.cpp:691
VImage reducev(double vshrink, VOption *options=0) const
Definition vips-operators.cpp:2887
static VImage jxlload_source(VSource source, VOption *options=0)
Definition vips-operators.cpp:1830
void radsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:2773
VImage XYZ2scRGB(VOption *options=0) const
Definition vips-operators.cpp:209
VImage gaussblur(double sigma, VOption *options=0) const
Definition vips-operators.cpp:1176
VImage invertlut(VOption *options=0) const
Definition vips-operators.cpp:1633
static VImage thumbnail_buffer(VipsBlob *buffer, int width, VOption *options=0)
Definition vips-operators.cpp:3401
VImage bandjoin(VImage other, VOption *options=0) const
Definition VImage.cpp:778
VImage resize(double scale, VOption *options=0) const
Definition vips-operators.cpp:2968
void dzsave(const char *filename, VOption *options=0) const
Definition vips-operators.cpp:926
VImage compass(VImage mask, VOption *options=0) const
Definition vips-operators.cpp:533
VImage measure(int h, int v, VOption *options=0) const
Definition vips-operators.cpp:2294
static VImage mask_butterworth_ring(int width, int height, double order, double frequency_cutoff, double amplitude_cutoff, double ringwidth, VOption *options=0)
Definition vips-operators.cpp:2025
VImage subsample(int xfac, int yfac, VOption *options=0) const
Definition vips-operators.cpp:3282
Definition VImage8.h:217
Definition VConnection8.h:46
Definition VConnection8.h:107