test_mrumtl_wlens.c (9992B)
1 /* Copyright (C) 2020-2023 |Méso|Star> (contact@meso-star.com) 2 * 3 * This program is free software: you can redistribute it and/or modify 4 * it under the terms of the GNU General Public License as published by 5 * the Free Software Foundation, either version 3 of the License, or 6 * (at your option) any later version. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program. If not, see <http://www.gnu.org/licenses/>. */ 15 16 #include "mrumtl.h" 17 #include <rsys/mem_allocator.h> 18 19 #include <stdio.h> 20 21 static void 22 test_load(struct mrumtl* mrumtl) 23 { 24 struct mrumtl_brdf_specular specular = MRUMTL_BRDF_SPECULAR_NULL; 25 struct mrumtl_brdf_lambertian lambertian = MRUMTL_BRDF_LAMBERTIAN_NULL; 26 const struct mrumtl_brdf* brdf = NULL; 27 FILE* fp = NULL; 28 29 CHK(fp = tmpfile()); 30 fprintf(fp, "wavelengths 0\n"); 31 rewind(fp); 32 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_OK); 33 CHK(mrumtl_get_brdfs_count(mrumtl) == 0); 34 CHK(fclose(fp) == 0); 35 36 CHK(fp = tmpfile()); 37 fprintf(fp, "# Comment\n"); 38 fprintf(fp, "wavelengths 1\n"); 39 fprintf(fp, "\n"); 40 fprintf(fp, "200.1 lambertian 0\n"); 41 rewind(fp); 42 43 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_OK); 44 45 CHK(mrumtl_get_brdfs_count(mrumtl) == 1); 46 CHK(brdf = mrumtl_get_brdf(mrumtl, 0)); 47 CHK(mrumtl_brdf_get_type(brdf) == MRUMTL_BRDF_LAMBERTIAN); 48 49 CHK(mrumtl_brdf_get_lambertian(brdf, &lambertian) == RES_OK); 50 CHK(lambertian.wavelengths[0] == 200.1); 51 CHK(lambertian.wavelengths[1] == 200.1); 52 CHK(lambertian.reflectivity == 0); 53 CHK(fclose(fp) == 0); 54 55 CHK(fp = tmpfile()); 56 fprintf(fp, "wavelengths 10\n"); 57 fprintf(fp, "\n"); 58 fprintf(fp, "# Short waves\n"); 59 fprintf(fp, "430 specular 0.02\n"); 60 fprintf(fp, "450 specular 0.05\n"); 61 fprintf(fp, "750\t specular 0.9\n"); 62 fprintf(fp, "# Long waves\n"); 63 fprintf(fp, "1100 lambertian 0.1\n"); 64 fprintf(fp, "1300 lambertian 0.57\n"); 65 fprintf(fp, "1400 lambertian 0.4\n"); 66 fprintf(fp, "2100 lambertian 0.3\n"); 67 fprintf(fp, "2500 lambertian\t0.9\n"); 68 fprintf(fp, "2900 lambertian 0.4\n"); 69 fprintf(fp, "100000 lambertian 0.0\n"); 70 rewind(fp); 71 72 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_OK); 73 CHK(mrumtl_get_brdfs_count(mrumtl) == 10); 74 75 CHK(brdf = mrumtl_get_brdf(mrumtl, 0)); 76 CHK(mrumtl_brdf_get_type(brdf) == MRUMTL_BRDF_SPECULAR); 77 CHK(mrumtl_brdf_get_specular(brdf, &specular) == RES_OK); 78 CHK(specular.wavelengths[0] == 430); 79 CHK(specular.wavelengths[1] == 430); 80 CHK(specular.reflectivity == 0.02); 81 82 CHK(brdf = mrumtl_get_brdf(mrumtl, 1)); 83 CHK(mrumtl_brdf_get_type(brdf) == MRUMTL_BRDF_SPECULAR); 84 CHK(mrumtl_brdf_get_specular(brdf, &specular) == RES_OK); 85 CHK(specular.wavelengths[0] == 450); 86 CHK(specular.wavelengths[1] == 450); 87 CHK(specular.reflectivity == 0.05); 88 89 CHK(brdf = mrumtl_get_brdf(mrumtl, 2)); 90 CHK(mrumtl_brdf_get_type(brdf) == MRUMTL_BRDF_SPECULAR); 91 CHK(mrumtl_brdf_get_specular(brdf, &specular) == RES_OK); 92 CHK(specular.wavelengths[0] == 750); 93 CHK(specular.wavelengths[1] == 750); 94 CHK(specular.reflectivity == 0.9); 95 96 CHK(brdf = mrumtl_get_brdf(mrumtl, 3)); 97 CHK(mrumtl_brdf_get_type(brdf) == MRUMTL_BRDF_LAMBERTIAN); 98 CHK(mrumtl_brdf_get_lambertian(brdf, &lambertian) == RES_OK); 99 CHK(lambertian.wavelengths[0] == 1100); 100 CHK(lambertian.wavelengths[1] == 1100); 101 CHK(lambertian.reflectivity == 0.1); 102 103 CHK(brdf = mrumtl_get_brdf(mrumtl, 4)); 104 CHK(mrumtl_brdf_get_type(brdf) == MRUMTL_BRDF_LAMBERTIAN); 105 CHK(mrumtl_brdf_get_lambertian(brdf, &lambertian) == RES_OK); 106 CHK(lambertian.wavelengths[0] == 1300); 107 CHK(lambertian.wavelengths[1] == 1300); 108 CHK(lambertian.reflectivity == 0.57); 109 110 CHK(brdf = mrumtl_get_brdf(mrumtl, 5)); 111 CHK(mrumtl_brdf_get_type(brdf) == MRUMTL_BRDF_LAMBERTIAN); 112 CHK(mrumtl_brdf_get_lambertian(brdf, &lambertian) == RES_OK); 113 CHK(lambertian.wavelengths[0] == 1400); 114 CHK(lambertian.wavelengths[1] == 1400); 115 CHK(lambertian.reflectivity == 0.4); 116 117 CHK(brdf = mrumtl_get_brdf(mrumtl, 6)); 118 CHK(mrumtl_brdf_get_type(brdf) == MRUMTL_BRDF_LAMBERTIAN); 119 CHK(mrumtl_brdf_get_lambertian(brdf, &lambertian) == RES_OK); 120 CHK(lambertian.wavelengths[0] == 2100); 121 CHK(lambertian.wavelengths[1] == 2100); 122 CHK(lambertian.reflectivity == 0.3); 123 124 CHK(brdf = mrumtl_get_brdf(mrumtl, 7)); 125 CHK(mrumtl_brdf_get_type(brdf) == MRUMTL_BRDF_LAMBERTIAN); 126 CHK(mrumtl_brdf_get_lambertian(brdf, &lambertian) == RES_OK); 127 CHK(lambertian.wavelengths[0] == 2500); 128 CHK(lambertian.wavelengths[1] == 2500); 129 CHK(lambertian.reflectivity == 0.9); 130 131 CHK(brdf = mrumtl_get_brdf(mrumtl, 8)); 132 CHK(mrumtl_brdf_get_type(brdf) == MRUMTL_BRDF_LAMBERTIAN); 133 CHK(mrumtl_brdf_get_lambertian(brdf, &lambertian) == RES_OK); 134 CHK(lambertian.wavelengths[0] == 2900); 135 CHK(lambertian.wavelengths[1] == 2900); 136 CHK(lambertian.reflectivity == 0.4); 137 138 CHK(brdf = mrumtl_get_brdf(mrumtl, 9)); 139 CHK(mrumtl_brdf_get_type(brdf) == MRUMTL_BRDF_LAMBERTIAN); 140 CHK(mrumtl_brdf_get_lambertian(brdf, &lambertian) == RES_OK); 141 CHK(lambertian.wavelengths[0] == 100000); 142 CHK(lambertian.wavelengths[1] == 100000); 143 CHK(lambertian.reflectivity == 0); 144 145 CHK(fclose(fp) == 0); 146 } 147 148 static void 149 test_fetch(struct mrumtl* mrumtl) 150 { 151 FILE* fp = NULL; 152 size_t ibrdf = 0; 153 154 CHK(fp = tmpfile()); 155 fprintf(fp, "wavelengths 0\n"); 156 rewind(fp); 157 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_OK); 158 CHK(fclose(fp) == 0); 159 CHK(mrumtl_fetch_brdf(mrumtl, 400, 0.5, &ibrdf) == RES_OK); 160 CHK(ibrdf >= mrumtl_get_brdfs_count(mrumtl)); 161 162 CHK(fp = tmpfile()); 163 fprintf(fp, "wavelengths 2\n"); 164 fprintf(fp, "200 lambertian 0\n"); 165 fprintf(fp, "300 lambertian 0\n"); 166 rewind(fp); 167 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_OK); 168 CHK(fclose(fp) == 0); 169 170 CHK(mrumtl_fetch_brdf(mrumtl, 299, 0, &ibrdf) == RES_OK); 171 CHK(ibrdf == 0); 172 CHK(mrumtl_fetch_brdf(mrumtl, 301, 0, &ibrdf) == RES_OK); 173 CHK(ibrdf == 1); 174 CHK(mrumtl_fetch_brdf(mrumtl, 200, 0, &ibrdf) == RES_OK); 175 CHK(ibrdf == 0); 176 CHK(mrumtl_fetch_brdf(mrumtl, 300, 0, &ibrdf) == RES_OK); 177 CHK(ibrdf == 1); 178 CHK(mrumtl_fetch_brdf(mrumtl, 280, 0, &ibrdf) == RES_OK); 179 CHK(ibrdf == 0); 180 CHK(mrumtl_fetch_brdf(mrumtl, 280, 0.19, &ibrdf) == RES_OK); 181 CHK(ibrdf == 0); 182 CHK(mrumtl_fetch_brdf(mrumtl, 280, 0.20, &ibrdf) == RES_OK); 183 CHK(ibrdf == 1); 184 185 CHK(fp = tmpfile()); 186 fprintf(fp, "wavelengths 4\n"); 187 fprintf(fp, "100 lambertian 0\n"); 188 fprintf(fp, "200 lambertian 1\n"); 189 fprintf(fp, "300 lambertian 0.5\n"); 190 fprintf(fp, "400 specular 0.4\n"); 191 rewind(fp); 192 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_OK); 193 CHK(fclose(fp) == 0); 194 195 CHK(mrumtl_fetch_brdf(mrumtl, 50, 0, &ibrdf) == RES_OK); 196 CHK(ibrdf == 0); 197 CHK(mrumtl_fetch_brdf(mrumtl, 120, 0.8, &ibrdf) == RES_OK); 198 CHK(ibrdf == 1); 199 CHK(mrumtl_fetch_brdf(mrumtl, 270, 0.29, &ibrdf) == RES_OK); 200 CHK(ibrdf == 1); 201 CHK(mrumtl_fetch_brdf(mrumtl, 270, 0.3, &ibrdf) == RES_OK); 202 CHK(ibrdf == 2); 203 CHK(mrumtl_fetch_brdf(mrumtl, 350, 0.5, &ibrdf) == RES_OK); 204 CHK(ibrdf == 3); 205 CHK(mrumtl_fetch_brdf(mrumtl, 450, 0, &ibrdf) == RES_OK); 206 CHK(ibrdf == 3); 207 } 208 209 static void 210 test_load_fail(struct mrumtl* mrumtl) 211 { 212 FILE* fp = NULL; 213 214 /* No wavelength count */ 215 CHK(fp = tmpfile()); 216 fprintf(fp, "wavelengths\n"); 217 fprintf(fp, "380 lambertian 0.5\n"); 218 rewind(fp); 219 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_BAD_ARG); 220 CHK(fclose(fp) == 0); 221 222 /* Missing a phase function */ 223 CHK(fp = tmpfile()); 224 fprintf(fp, "wavelengths 2\n"); 225 fprintf(fp, "380 lambertian 0.5\n"); 226 rewind(fp); 227 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_BAD_ARG); 228 CHK(fclose(fp) == 0); 229 230 /* Invalid wavelength */ 231 CHK(fp = tmpfile()); 232 fprintf(fp, "wavelengths 1\n"); 233 fprintf(fp, "-380 lambertian 0.5\n"); 234 rewind(fp); 235 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_BAD_ARG); 236 CHK(fclose(fp) == 0); 237 238 /* Unsorted phase functions */ 239 CHK(fp = tmpfile()); 240 fprintf(fp, "wavelengths 2\n"); 241 fprintf(fp, "380 lambertian 0.5\n"); 242 fprintf(fp, "280 lambertian 0.0\n"); 243 rewind(fp); 244 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_BAD_ARG); 245 CHK(fclose(fp) == 0); 246 247 /* Phase functions overlap */ 248 CHK(fp = tmpfile()); 249 fprintf(fp, "wavelengths 2\n"); 250 fprintf(fp, "280 lambertian 0.5\n"); 251 fprintf(fp, "280 lambertian 0.0\n"); 252 rewind(fp); 253 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_BAD_ARG); 254 CHK(fclose(fp) == 0); 255 256 /* Additional text. Print a warning */ 257 CHK(fp = tmpfile()); 258 fprintf(fp, "wavelengths 2 additional_text\n"); 259 fprintf(fp, "280 lambertian 0.5\n"); 260 fprintf(fp, "380 lambertian 0.0\n"); 261 rewind(fp); 262 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_OK); 263 CHK(fclose(fp) == 0); 264 265 /* Missing data */ 266 CHK(fp = tmpfile()); 267 fprintf(fp, "wavelengths 1\n"); 268 fprintf(fp, "280\n"); 269 rewind(fp); 270 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_BAD_ARG); 271 CHK(fclose(fp) == 0); 272 273 /* Missing data */ 274 CHK(fp = tmpfile()); 275 fprintf(fp, "wavelengths 1\n"); 276 fprintf(fp, "280 lambertian\n"); 277 rewind(fp); 278 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_BAD_ARG); 279 CHK(fclose(fp) == 0); 280 281 /* Additional text. Print a warning */ 282 CHK(fp = tmpfile()); 283 fprintf(fp, "wavelengths 1\n"); 284 fprintf(fp, "280 lambertian 1 additional_text\n"); 285 rewind(fp); 286 CHK(mrumtl_load_stream(mrumtl, fp, NULL) == RES_OK); 287 CHK(fclose(fp) == 0); 288 } 289 290 int 291 main(int argc, char** argv) 292 { 293 struct mrumtl_create_args args = MRUMTL_CREATE_ARGS_DEFAULT; 294 struct mrumtl* mrumtl = NULL; 295 (void)argc, (void)argv; 296 297 args.verbose = 1; 298 CHK(mrumtl_create(&args, &mrumtl) == RES_OK); 299 CHK(mrumtl_get_brdfs_count(mrumtl) == RES_OK); 300 301 test_load(mrumtl); 302 test_fetch(mrumtl); 303 test_load_fail(mrumtl); 304 305 CHK(mrumtl_ref_put(mrumtl) == RES_OK); 306 CHK(mem_allocated_size() == 0); 307 return 0; 308 }