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