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