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