sharp 0.17.2 → 0.18.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (36) hide show
  1. package/CONTRIBUTING.md +1 -7
  2. package/binding.gyp +1 -1
  3. package/binding.js +14 -14
  4. package/docs/api-colour.md +2 -2
  5. package/docs/api-composite.md +11 -3
  6. package/docs/api-constructor.md +25 -5
  7. package/docs/api-input.md +4 -3
  8. package/docs/api-operation.md +20 -17
  9. package/docs/api-output.md +39 -30
  10. package/docs/api-resize.md +9 -8
  11. package/docs/api-utility.md +4 -4
  12. package/docs/changelog.md +103 -0
  13. package/docs/index.md +4 -1
  14. package/docs/install.md +44 -14
  15. package/lib/channel.js +6 -6
  16. package/lib/colour.js +10 -10
  17. package/lib/composite.js +11 -6
  18. package/lib/constructor.js +41 -18
  19. package/lib/input.js +52 -24
  20. package/lib/is.js +9 -0
  21. package/lib/operation.js +41 -38
  22. package/lib/output.js +103 -112
  23. package/lib/resize.js +25 -20
  24. package/lib/utility.js +8 -8
  25. package/package.json +22 -18
  26. package/src/common.cc +94 -20
  27. package/src/common.h +30 -3
  28. package/src/libvips/cplusplus/VImage.cpp +110 -104
  29. package/src/libvips/cplusplus/vips-operators.cpp +108 -44
  30. package/src/metadata.cc +19 -4
  31. package/src/metadata.h +1 -0
  32. package/src/operations.cc +18 -165
  33. package/src/operations.h +4 -26
  34. package/src/pipeline.cc +201 -97
  35. package/src/pipeline.h +14 -0
  36. package/src/sharp.cc +3 -0
package/src/libvips/cplusplus/VImage.cpp CHANGED
@@ -350,7 +350,7 @@ set_property( VipsObject *object, const char *name, const GValue *value )
350
350
 
351
351
  if( vips_object_get_argument( object, name,
352
352
  &pspec, &argument_class, &argument_instance ) ) {
353
- vips_warn( NULL, "%s", vips_error_buffer() );
353
+ g_warning( "%s", vips_error_buffer() );
354
354
  vips_error_clear();
355
355
  return;
356
356
  }
@@ -364,7 +364,7 @@ set_property( VipsObject *object, const char *name, const GValue *value )
364
364
 
365
365
  if( (enum_value = vips_enum_from_nick( object_class->nickname,
366
366
  pspec_type, g_value_get_string( value ) )) < 0 ) {
367
- vips_warn( NULL, "%s", vips_error_buffer() );
367
+ g_warning( "%s", vips_error_buffer() );
368
368
  vips_error_clear();
369
369
  return;
370
370
  }
@@ -770,19 +770,19 @@ operator+( VImage a, std::vector<double> b )
770
770
  }
771
771
 
772
772
  VImage &
773
- operator+=( VImage a, const VImage b )
773
+ operator+=( VImage &a, const VImage b )
774
774
  {
775
775
  return( a = a + b );
776
776
  }
777
777
 
778
778
  VImage &
779
- operator+=( VImage a, const double b )
779
+ operator+=( VImage &a, const double b )
780
780
  {
781
781
  return( a = a + b );
782
782
  }
783
783
 
784
784
  VImage &
785
- operator+=( VImage a, std::vector<double> b )
785
+ operator+=( VImage &a, std::vector<double> b )
786
786
  {
787
787
  return( a = a + b );
788
788
  }
@@ -818,19 +818,19 @@ operator-( VImage a, std::vector<double> b )
818
818
  }
819
819
 
820
820
  VImage &
821
- operator-=( VImage a, const VImage b )
821
+ operator-=( VImage &a, const VImage b )
822
822
  {
823
823
  return( a = a - b );
824
824
  }
825
825
 
826
826
  VImage &
827
- operator-=( VImage a, const double b )
827
+ operator-=( VImage &a, const double b )
828
828
  {
829
829
  return( a = a - b );
830
830
  }
831
831
 
832
832
  VImage &
833
- operator-=( VImage a, std::vector<double> b )
833
+ operator-=( VImage &a, std::vector<double> b )
834
834
  {
835
835
  return( a = a - b );
836
836
  }
@@ -872,19 +872,19 @@ operator*( VImage a, std::vector<double> b )
872
872
  }
873
873
 
874
874
  VImage &
875
- operator*=( VImage a, const VImage b )
875
+ operator*=( VImage &a, const VImage b )
876
876
  {
877
877
  return( a = a * b );
878
878
  }
879
879
 
880
880
  VImage &
881
- operator*=( VImage a, const double b )
881
+ operator*=( VImage &a, const double b )
882
882
  {
883
883
  return( a = a * b );
884
884
  }
885
885
 
886
886
  VImage &
887
- operator*=( VImage a, std::vector<double> b )
887
+ operator*=( VImage &a, std::vector<double> b )
888
888
  {
889
889
  return( a = a * b );
890
890
  }
@@ -920,19 +920,19 @@ operator/( VImage a, std::vector<double> b )
920
920
  }
921
921
 
922
922
  VImage &
923
- operator/=( VImage a, const VImage b )
923
+ operator/=( VImage &a, const VImage b )
924
924
  {
925
925
  return( a = a / b );
926
926
  }
927
927
 
928
928
  VImage &
929
- operator/=( VImage a, const double b )
929
+ operator/=( VImage &a, const double b )
930
930
  {
931
931
  return( a = a / b );
932
932
  }
933
933
 
934
934
  VImage &
935
- operator/=( VImage a, std::vector<double> b )
935
+ operator/=( VImage &a, std::vector<double> b )
936
936
  {
937
937
  return( a = a / b );
938
938
  }
@@ -956,19 +956,19 @@ operator%( VImage a, std::vector<double> b )
956
956
  }
957
957
 
958
958
  VImage &
959
- operator%=( VImage a, const VImage b )
959
+ operator%=( VImage &a, const VImage b )
960
960
  {
961
961
  return( a = a % b );
962
962
  }
963
963
 
964
964
  VImage &
965
- operator%=( VImage a, const double b )
965
+ operator%=( VImage &a, const double b )
966
966
  {
967
967
  return( a = a % b );
968
968
  }
969
969
 
970
970
  VImage &
971
- operator%=( VImage a, std::vector<double> b )
971
+ operator%=( VImage &a, std::vector<double> b )
972
972
  {
973
973
  return( a = a % b );
974
974
  }
@@ -982,29 +982,29 @@ operator<( VImage a, VImage b )
982
982
  VImage
983
983
  operator<( double a, VImage b )
984
984
  {
985
- return( b.relational_const( to_vector( a ),
986
- VIPS_OPERATION_RELATIONAL_MORE ) );
985
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
986
+ to_vector( a ) ) );
987
987
  }
988
988
 
989
989
  VImage
990
990
  operator<( VImage a, double b )
991
991
  {
992
- return( a.relational_const( to_vector( b ),
993
- VIPS_OPERATION_RELATIONAL_LESS ) );
992
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
993
+ to_vector( b ) ) );
994
994
  }
995
995
 
996
996
  VImage
997
997
  operator<( std::vector<double> a, VImage b )
998
998
  {
999
- return( b.relational_const( a,
1000
- VIPS_OPERATION_RELATIONAL_MORE ) );
999
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
1000
+ a ) );
1001
1001
  }
1002
1002
 
1003
1003
  VImage
1004
1004
  operator<( VImage a, std::vector<double> b )
1005
1005
  {
1006
- return( a.relational_const( b,
1007
- VIPS_OPERATION_RELATIONAL_LESS ) );
1006
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
1007
+ b ) );
1008
1008
  }
1009
1009
 
1010
1010
  VImage
@@ -1016,29 +1016,29 @@ operator<=( VImage a, VImage b )
1016
1016
  VImage
1017
1017
  operator<=( double a, VImage b )
1018
1018
  {
1019
- return( b.relational_const( to_vector( a ),
1020
- VIPS_OPERATION_RELATIONAL_MOREEQ ) );
1019
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
1020
+ to_vector( a ) ) );
1021
1021
  }
1022
1022
 
1023
1023
  VImage
1024
1024
  operator<=( VImage a, double b )
1025
1025
  {
1026
- return( a.relational_const( to_vector( b ),
1027
- VIPS_OPERATION_RELATIONAL_LESSEQ ) );
1026
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
1027
+ to_vector( b ) ) );
1028
1028
  }
1029
1029
 
1030
1030
  VImage
1031
1031
  operator<=( std::vector<double> a, VImage b )
1032
1032
  {
1033
- return( b.relational_const( a,
1034
- VIPS_OPERATION_RELATIONAL_MOREEQ ) );
1033
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
1034
+ a ) );
1035
1035
  }
1036
1036
 
1037
1037
  VImage
1038
1038
  operator<=( VImage a, std::vector<double> b )
1039
1039
  {
1040
- return( a.relational_const( b,
1041
- VIPS_OPERATION_RELATIONAL_LESSEQ ) );
1040
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
1041
+ b ) );
1042
1042
  }
1043
1043
 
1044
1044
  VImage
@@ -1050,29 +1050,29 @@ operator>( VImage a, VImage b )
1050
1050
  VImage
1051
1051
  operator>( double a, VImage b )
1052
1052
  {
1053
- return( b.relational_const( to_vector( a ),
1054
- VIPS_OPERATION_RELATIONAL_LESS ) );
1053
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
1054
+ to_vector( a ) ) );
1055
1055
  }
1056
1056
 
1057
1057
  VImage
1058
1058
  operator>( VImage a, double b )
1059
1059
  {
1060
- return( a.relational_const( to_vector( b ),
1061
- VIPS_OPERATION_RELATIONAL_MORE ) );
1060
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
1061
+ to_vector( b ) ) );
1062
1062
  }
1063
1063
 
1064
1064
  VImage
1065
1065
  operator>( std::vector<double> a, VImage b )
1066
1066
  {
1067
- return( b.relational_const( a,
1068
- VIPS_OPERATION_RELATIONAL_LESS ) );
1067
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESS,
1068
+ a ) );
1069
1069
  }
1070
1070
 
1071
1071
  VImage
1072
1072
  operator>( VImage a, std::vector<double> b )
1073
1073
  {
1074
- return( a.relational_const( b,
1075
- VIPS_OPERATION_RELATIONAL_MORE ) );
1074
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_MORE,
1075
+ b ) );
1076
1076
  }
1077
1077
 
1078
1078
  VImage
@@ -1084,29 +1084,29 @@ operator>=( VImage a, VImage b )
1084
1084
  VImage
1085
1085
  operator>=( double a, VImage b )
1086
1086
  {
1087
- return( b.relational_const( to_vector( a ),
1088
- VIPS_OPERATION_RELATIONAL_LESSEQ ) );
1087
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
1088
+ to_vector( a ) ) );
1089
1089
  }
1090
1090
 
1091
1091
  VImage
1092
1092
  operator>=( VImage a, double b )
1093
1093
  {
1094
- return( a.relational_const( to_vector( b ),
1095
- VIPS_OPERATION_RELATIONAL_MOREEQ ) );
1094
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
1095
+ to_vector( b ) ) );
1096
1096
  }
1097
1097
 
1098
1098
  VImage
1099
1099
  operator>=( std::vector<double> a, VImage b )
1100
1100
  {
1101
- return( b.relational_const( a,
1102
- VIPS_OPERATION_RELATIONAL_LESSEQ ) );
1101
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_LESSEQ,
1102
+ a ) );
1103
1103
  }
1104
1104
 
1105
1105
  VImage
1106
1106
  operator>=( VImage a, std::vector<double> b )
1107
1107
  {
1108
- return( a.relational_const( b,
1109
- VIPS_OPERATION_RELATIONAL_MOREEQ ) );
1108
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_MOREEQ,
1109
+ b ) );
1110
1110
  }
1111
1111
 
1112
1112
  VImage
@@ -1118,29 +1118,29 @@ operator==( VImage a, VImage b )
1118
1118
  VImage
1119
1119
  operator==( double a, VImage b )
1120
1120
  {
1121
- return( b.relational_const( to_vector( a ),
1122
- VIPS_OPERATION_RELATIONAL_EQUAL ) );
1121
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
1122
+ to_vector( a ) ) );
1123
1123
  }
1124
1124
 
1125
1125
  VImage
1126
1126
  operator==( VImage a, double b )
1127
1127
  {
1128
- return( a.relational_const( to_vector( b ),
1129
- VIPS_OPERATION_RELATIONAL_EQUAL ) );
1128
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
1129
+ to_vector( b ) ) );
1130
1130
  }
1131
1131
 
1132
1132
  VImage
1133
1133
  operator==( std::vector<double> a, VImage b )
1134
1134
  {
1135
- return( b.relational_const( a,
1136
- VIPS_OPERATION_RELATIONAL_EQUAL ) );
1135
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
1136
+ a ) );
1137
1137
  }
1138
1138
 
1139
1139
  VImage
1140
1140
  operator==( VImage a, std::vector<double> b )
1141
1141
  {
1142
- return( a.relational_const( b,
1143
- VIPS_OPERATION_RELATIONAL_EQUAL ) );
1142
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_EQUAL,
1143
+ b ) );
1144
1144
  }
1145
1145
 
1146
1146
  VImage
@@ -1152,29 +1152,29 @@ operator!=( VImage a, VImage b )
1152
1152
  VImage
1153
1153
  operator!=( double a, VImage b )
1154
1154
  {
1155
- return( b.relational_const( to_vector( a ),
1156
- VIPS_OPERATION_RELATIONAL_NOTEQ ) );
1155
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
1156
+ to_vector( a ) ) );
1157
1157
  }
1158
1158
 
1159
1159
  VImage
1160
1160
  operator!=( VImage a, double b )
1161
1161
  {
1162
- return( a.relational_const( to_vector( b ),
1163
- VIPS_OPERATION_RELATIONAL_NOTEQ ) );
1162
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
1163
+ to_vector( b ) ) );
1164
1164
  }
1165
1165
 
1166
1166
  VImage
1167
1167
  operator!=( std::vector<double> a, VImage b )
1168
1168
  {
1169
- return( b.relational_const( a,
1170
- VIPS_OPERATION_RELATIONAL_NOTEQ ) );
1169
+ return( b.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
1170
+ a ) );
1171
1171
  }
1172
1172
 
1173
1173
  VImage
1174
1174
  operator!=( VImage a, std::vector<double> b )
1175
1175
  {
1176
- return( a.relational_const( b,
1177
- VIPS_OPERATION_RELATIONAL_NOTEQ ) );
1176
+ return( a.relational_const( VIPS_OPERATION_RELATIONAL_NOTEQ,
1177
+ b ) );
1178
1178
  }
1179
1179
 
1180
1180
  VImage
@@ -1186,43 +1186,43 @@ operator&( VImage a, VImage b )
1186
1186
  VImage
1187
1187
  operator&( double a, VImage b )
1188
1188
  {
1189
- return( b.boolean_const( to_vector( a ),
1190
- VIPS_OPERATION_BOOLEAN_AND ) );
1189
+ return( b.boolean_const( VIPS_OPERATION_BOOLEAN_AND,
1190
+ to_vector( a ) ) );
1191
1191
  }
1192
1192
 
1193
1193
  VImage
1194
1194
  operator&( VImage a, double b )
1195
1195
  {
1196
- return( a.boolean_const( to_vector( b ),
1197
- VIPS_OPERATION_BOOLEAN_AND ) );
1196
+ return( a.boolean_const( VIPS_OPERATION_BOOLEAN_AND,
1197
+ to_vector( b ) ) );
1198
1198
  }
1199
1199
 
1200
1200
  VImage
1201
1201
  operator&( std::vector<double> a, VImage b )
1202
1202
  {
1203
- return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_AND ) );
1203
+ return( b.boolean_const( VIPS_OPERATION_BOOLEAN_AND, a ) );
1204
1204
  }
1205
1205
 
1206
1206
  VImage
1207
1207
  operator&( VImage a, std::vector<double> b )
1208
1208
  {
1209
- return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_AND ) );
1209
+ return( a.boolean_const( VIPS_OPERATION_BOOLEAN_AND, b ) );
1210
1210
  }
1211
1211
 
1212
1212
  VImage &
1213
- operator&=( VImage a, const VImage b )
1213
+ operator&=( VImage &a, const VImage b )
1214
1214
  {
1215
1215
  return( a = a & b );
1216
1216
  }
1217
1217
 
1218
1218
  VImage &
1219
- operator&=( VImage a, const double b )
1219
+ operator&=( VImage &a, const double b )
1220
1220
  {
1221
1221
  return( a = a & b );
1222
1222
  }
1223
1223
 
1224
1224
  VImage &
1225
- operator&=( VImage a, std::vector<double> b )
1225
+ operator&=( VImage &a, std::vector<double> b )
1226
1226
  {
1227
1227
  return( a = a & b );
1228
1228
  }
@@ -1236,43 +1236,45 @@ operator|( VImage a, VImage b )
1236
1236
  VImage
1237
1237
  operator|( double a, VImage b )
1238
1238
  {
1239
- return( b.boolean_const( to_vector( a ),
1240
- VIPS_OPERATION_BOOLEAN_OR ) );
1239
+ return( b.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
1240
+ to_vector( a ) ) );
1241
1241
  }
1242
1242
 
1243
1243
  VImage
1244
1244
  operator|( VImage a, double b )
1245
1245
  {
1246
- return( a.boolean_const( to_vector( b ),
1247
- VIPS_OPERATION_BOOLEAN_OR ) );
1246
+ return( a.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
1247
+ to_vector( b ) ) );
1248
1248
  }
1249
1249
 
1250
1250
  VImage
1251
1251
  operator|( std::vector<double> a, VImage b )
1252
1252
  {
1253
- return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_OR ) );
1253
+ return( b.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
1254
+ a ) );
1254
1255
  }
1255
1256
 
1256
1257
  VImage
1257
1258
  operator|( VImage a, std::vector<double> b )
1258
1259
  {
1259
- return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_OR ) );
1260
+ return( a.boolean_const( VIPS_OPERATION_BOOLEAN_OR,
1261
+ b ) );
1260
1262
  }
1261
1263
 
1262
1264
  VImage &
1263
- operator|=( VImage a, const VImage b )
1265
+ operator|=( VImage &a, const VImage b )
1264
1266
  {
1265
1267
  return( a = a | b );
1266
1268
  }
1267
1269
 
1268
1270
  VImage &
1269
- operator|=( VImage a, const double b )
1271
+ operator|=( VImage &a, const double b )
1270
1272
  {
1271
1273
  return( a = a | b );
1272
1274
  }
1273
1275
 
1274
1276
  VImage &
1275
- operator|=( VImage a, std::vector<double> b )
1277
+ operator|=( VImage &a, std::vector<double> b )
1276
1278
  {
1277
1279
  return( a = a | b );
1278
1280
  }
@@ -1286,43 +1288,45 @@ operator^( VImage a, VImage b )
1286
1288
  VImage
1287
1289
  operator^( double a, VImage b )
1288
1290
  {
1289
- return( b.boolean_const( to_vector( a ),
1290
- VIPS_OPERATION_BOOLEAN_EOR ) );
1291
+ return( b.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
1292
+ to_vector( a ) ) );
1291
1293
  }
1292
1294
 
1293
1295
  VImage
1294
1296
  operator^( VImage a, double b )
1295
1297
  {
1296
- return( a.boolean_const( to_vector( b ),
1297
- VIPS_OPERATION_BOOLEAN_EOR ) );
1298
+ return( a.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
1299
+ to_vector( b ) ) );
1298
1300
  }
1299
1301
 
1300
1302
  VImage
1301
1303
  operator^( std::vector<double> a, VImage b )
1302
1304
  {
1303
- return( b.boolean_const( a, VIPS_OPERATION_BOOLEAN_EOR ) );
1305
+ return( b.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
1306
+ a ) );
1304
1307
  }
1305
1308
 
1306
1309
  VImage
1307
1310
  operator^( VImage a, std::vector<double> b )
1308
1311
  {
1309
- return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_EOR ) );
1312
+ return( a.boolean_const( VIPS_OPERATION_BOOLEAN_EOR,
1313
+ b ) );
1310
1314
  }
1311
1315
 
1312
1316
  VImage &
1313
- operator^=( VImage a, const VImage b )
1317
+ operator^=( VImage &a, const VImage b )
1314
1318
  {
1315
1319
  return( a = a ^ b );
1316
1320
  }
1317
1321
 
1318
1322
  VImage &
1319
- operator^=( VImage a, const double b )
1323
+ operator^=( VImage &a, const double b )
1320
1324
  {
1321
1325
  return( a = a ^ b );
1322
1326
  }
1323
1327
 
1324
1328
  VImage &
1325
- operator^=( VImage a, std::vector<double> b )
1329
+ operator^=( VImage &a, std::vector<double> b )
1326
1330
  {
1327
1331
  return( a = a ^ b );
1328
1332
  }
@@ -1336,30 +1340,31 @@ operator<<( VImage a, VImage b )
1336
1340
  VImage
1337
1341
  operator<<( VImage a, double b )
1338
1342
  {
1339
- return( a.boolean_const( to_vector( b ),
1340
- VIPS_OPERATION_BOOLEAN_LSHIFT ) );
1343
+ return( a.boolean_const( VIPS_OPERATION_BOOLEAN_LSHIFT,
1344
+ to_vector( b ) ) );
1341
1345
  }
1342
1346
 
1343
1347
  VImage
1344
1348
  operator<<( VImage a, std::vector<double> b )
1345
1349
  {
1346
- return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_LSHIFT ) );
1350
+ return( a.boolean_const( VIPS_OPERATION_BOOLEAN_LSHIFT,
1351
+ b ) );
1347
1352
  }
1348
1353
 
1349
1354
  VImage &
1350
- operator<<=( VImage a, const VImage b )
1355
+ operator<<=( VImage &a, const VImage b )
1351
1356
  {
1352
1357
  return( a = a << b );
1353
1358
  }
1354
1359
 
1355
1360
  VImage &
1356
- operator<<=( VImage a, const double b )
1361
+ operator<<=( VImage &a, const double b )
1357
1362
  {
1358
1363
  return( a = a << b );
1359
1364
  }
1360
1365
 
1361
1366
  VImage &
1362
- operator<<=( VImage a, std::vector<double> b )
1367
+ operator<<=( VImage &a, std::vector<double> b )
1363
1368
  {
1364
1369
  return( a = a << b );
1365
1370
  }
@@ -1373,30 +1378,31 @@ operator>>( VImage a, VImage b )
1373
1378
  VImage
1374
1379
  operator>>( VImage a, double b )
1375
1380
  {
1376
- return( a.boolean_const( to_vector( b ),
1377
- VIPS_OPERATION_BOOLEAN_RSHIFT ) );
1381
+ return( a.boolean_const( VIPS_OPERATION_BOOLEAN_RSHIFT,
1382
+ to_vector( b ) ) );
1378
1383
  }
1379
1384
 
1380
1385
  VImage
1381
1386
  operator>>( VImage a, std::vector<double> b )
1382
1387
  {
1383
- return( a.boolean_const( b, VIPS_OPERATION_BOOLEAN_RSHIFT ) );
1388
+ return( a.boolean_const( VIPS_OPERATION_BOOLEAN_RSHIFT,
1389
+ b ) );
1384
1390
  }
1385
1391
 
1386
1392
  VImage &
1387
- operator>>=( VImage a, const VImage b )
1393
+ operator>>=( VImage &a, const VImage b )
1388
1394
  {
1389
1395
  return( a = a << b );
1390
1396
  }
1391
1397
 
1392
1398
  VImage &
1393
- operator>>=( VImage a, const double b )
1399
+ operator>>=( VImage &a, const double b )
1394
1400
  {
1395
1401
  return( a = a << b );
1396
1402
  }
1397
1403
 
1398
1404
  VImage &
1399
- operator>>=( VImage a, std::vector<double> b )
1405
+ operator>>=( VImage &a, std::vector<double> b )
1400
1406
  {
1401
1407
  return( a = a << b );
1402
1408
  }