vips-cpp: /build/libvips/src/vips-8.18.6/cplusplus/vips-operators.cpp Source File

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