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