LCOV - code coverage report
Current view: top level - src/Util - PNG.H (source / functions) Coverage Total Hit
Test: coverage_merged.info Lines: 0.0 % 134 0
Test Date: 2025-04-03 04:02:21 Functions: 0.0 % 7 0

            Line data    Source code
       1              : 
       2              : #include <string.h>
       3              : 
       4              : #include "Set/Set.H"
       5              : #include "IO/ParmParse.H"
       6              : 
       7              : #ifndef ALAMO_NOPNG
       8              : #include <png.h>
       9              : #endif
      10              : 
      11              : namespace Util
      12              : {
      13              : class PNG
      14              : {
      15              : public:
      16            0 :     PNG() {} 
      17              :     PNG(IO::ParmParse &pp,std::string name) 
      18              :     {pp.queryclass(name, *this);}
      19            0 :     ~PNG()
      20              :     {
      21            0 :         for (int y = 0; y < png_height; y++) {
      22            0 :             free(row_pointers[y]);
      23              :         }
      24            0 :         free(row_pointers);
      25            0 :     } 
      26              : 
      27              :     //enum Type {XYZ, XY, YZ, XZ};
      28              :     enum Fit { Stretch, FitWidth, FitHeight, Coord };
      29              :     enum Channel { R = 0, G = 1, B = 2, A = 3 };
      30              : 
      31            0 :     static void Parse(PNG &value, IO::ParmParse &pp)
      32              :     {
      33              : #ifndef ALAMO_NOPNG
      34              : 
      35            0 :         std::string filename;
      36            0 :         pp_query_file("filename", filename); // BMP filename.
      37              : 
      38            0 :         std::string fit = "stretch";
      39              :         // how to position the image
      40            0 :         pp_query_validate("fit", fit, {"stretch","fitheight","fitwidth","coord"}); 
      41            0 :         if (fit == "stretch")        value.fit = Fit::Stretch;
      42            0 :         else if (fit == "fitheight") value.fit = Fit::FitHeight;
      43            0 :         else if (fit == "fitwidth")  value.fit = Fit::FitWidth;
      44            0 :         else if (fit == "coord")
      45              :         {
      46            0 :             value.fit = Fit::Coord;
      47            0 :             pp_queryarr("coord.lo", value.coord_lo); // Lower-left coordinates of image in domain
      48            0 :             pp_queryarr("coord.hi", value.coord_hi); // Upper-right coordinates of image in domain
      49              :         }
      50            0 :         else Util::Abort(INFO);
      51              : 
      52              :         // Desired minimum value to scale pixels by
      53            0 :         pp_query_default("min", value.min, 0.0  );
      54              :         // Desired maximum value to scale pixels by
      55            0 :         pp_query_default("max", value.max, 255.0);
      56              : 
      57              :         //
      58              :         //
      59              :         // Now, read in the PNG
      60              :         //
      61              :         //
      62              : 
      63              : 
      64            0 :         FILE* fp = std::fopen(filename.c_str(), "rb");
      65              : 
      66            0 :         if (fp == NULL) Util::Abort(INFO, "Cannot find file", filename);
      67              : 
      68            0 :         png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
      69            0 :         if (!png) Util::Abort(INFO);
      70              : 
      71            0 :         png_infop info = png_create_info_struct(png);
      72            0 :         if (!info) Util::Abort(INFO);
      73              : 
      74            0 :         if (setjmp(png_jmpbuf(png))) Util::Abort(INFO);
      75              : 
      76              : 
      77            0 :         png_init_io(png, fp);
      78              : 
      79            0 :         png_read_info(png, info);
      80              : 
      81            0 :         value.png_width = png_get_image_width(png, info);
      82            0 :         value.png_height = png_get_image_height(png, info);
      83            0 :         value.color_type = png_get_color_type(png, info);
      84            0 :         value.bit_depth = png_get_bit_depth(png, info);
      85              : 
      86            0 :         if (value.bit_depth == 16)
      87            0 :             png_set_strip_16(png);
      88              : 
      89            0 :         if (value.color_type == PNG_COLOR_TYPE_PALETTE)
      90            0 :             png_set_palette_to_rgb(png);
      91              : 
      92            0 :         if (value.color_type == PNG_COLOR_TYPE_GRAY && value.bit_depth < 8)
      93            0 :             png_set_expand_gray_1_2_4_to_8(png);
      94              : 
      95            0 :         if (png_get_valid(png, info, PNG_INFO_tRNS))
      96            0 :             png_set_tRNS_to_alpha(png);
      97              : 
      98            0 :         if (value.color_type == PNG_COLOR_TYPE_RGB ||
      99            0 :             value.color_type == PNG_COLOR_TYPE_GRAY ||
     100            0 :             value.color_type == PNG_COLOR_TYPE_PALETTE)
     101            0 :             png_set_filler(png, 0xFF, PNG_FILLER_AFTER);
     102              : 
     103            0 :         if (value.color_type == PNG_COLOR_TYPE_GRAY ||
     104            0 :             value.color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
     105            0 :             png_set_gray_to_rgb(png);
     106              : 
     107            0 :         png_read_update_info(png, info);
     108              : 
     109            0 :         if (value.row_pointers) Util::Abort(INFO);
     110              : 
     111            0 :         value.row_pointers = (png_bytep*)malloc(sizeof(png_bytep) * value.png_height);
     112            0 :         for (int y = 0; y < value.png_height; y++) {
     113            0 :             value.row_pointers[y] = (png_byte*)malloc(png_get_rowbytes(png, info));
     114              :         }
     115              : 
     116            0 :         png_read_image(png, value.row_pointers);
     117              : 
     118            0 :         fclose(fp);
     119              : 
     120            0 :         png_destroy_read_struct(&png, &info, NULL);
     121              : #else
     122              :         Util::Abort(INFO,"PNG is disabled");
     123              : #endif
     124              : 
     125            0 :     }
     126            0 :     void setDomain(Set::Vector &_lo, Set::Vector &_hi)
     127              :     {
     128              : #ifndef ALAMO_NOPNG
     129            0 :         domain_lo = _lo;
     130            0 :         domain_hi = _hi;
     131            0 :         domain_defined = false;
     132              : #endif
     133            0 :     }
     134              : 
     135              :     [[nodiscard]]
     136              :     std::array<int, 4> operator() (int I, int J)
     137              :     {
     138              : #ifndef ALAMO_NOPNG
     139              :         std::array<int, 4> ret;
     140              :         png_bytep px = &row_pointers[J][I * 4];
     141              :         ret = { px[0], px[1], px[2], px[3] };
     142              :         return ret;
     143              : #endif
     144              :     }
     145              : 
     146              :     [[nodiscard]]
     147            0 :     std::array<Set::Scalar, 4> operator()(Set::Vector &x)
     148              :     {
     149              : #ifndef ALAMO_NOPNG
     150            0 :         Util::Assert(INFO, TEST(row_pointers), "Running IC without initialization...");
     151              : 
     152              :         std::array<Set::Scalar, 4> ret;
     153              : 
     154            0 :         Set::Scalar img_width = (Set::Scalar)(png_width - 1);
     155            0 :         Set::Scalar img_height = (Set::Scalar)(png_height - 1);
     156            0 :         Set::Scalar img_dx = 1.0;
     157            0 :         Set::Scalar img_dy = 1.0;
     158              :         
     159              :         //Set::Scalar x, y;
     160            0 :         Set::Vector ximg;
     161              : 
     162            0 :         if (fit == Fit::Stretch)
     163              :         {
     164            0 :             ximg(0) = (x(0) - domain_lo(0)) / (domain_hi(0) - domain_lo(0));
     165            0 :             ximg(1) = (x(1) - domain_lo(1)) / (domain_hi(1) - domain_lo(1));
     166              :         }
     167            0 :         else if (fit == Fit::FitWidth)
     168              :         {
     169            0 :             Set::Scalar aspect_ratio = img_width / img_height;
     170            0 :             ximg(0) = (x(0) - domain_lo(0)) / (domain_hi(0) - domain_lo(0));
     171            0 :             ximg(1) = (x(1) - domain_lo(1)) / (domain_hi(1) - domain_lo(1));
     172            0 :             ximg(1) -= 0.5 - 0.5 / aspect_ratio;
     173            0 :             ximg(1) *= aspect_ratio;
     174              :         }
     175            0 :         else if (fit == Fit::FitHeight)
     176              :         {
     177            0 :             Set::Scalar aspect_ratio = img_height / img_width;
     178            0 :             ximg(0) = (x(0) - domain_lo(0)) / (domain_hi(0) - domain_lo(0));
     179            0 :             ximg(1) = (x(1) - domain_lo(1)) / (domain_hi(1) - domain_lo(1));
     180            0 :             ximg(0) -= 0.5 - 0.5 / aspect_ratio;
     181            0 :             ximg(0) *= aspect_ratio;
     182              :         }
     183            0 :         else if (fit == Fit::Coord)
     184              :         {
     185            0 :             ximg(0) = (x(0) - coord_lo(0)) / (coord_hi(0) - coord_lo(0));
     186            0 :             ximg(1) = (x(1) - coord_lo(1)) / (coord_hi(1) - coord_lo(1));
     187              :         }
     188              : 
     189              : 
     190              : 
     191            0 :         ximg(0) = std::min(ximg(0), 1.0); ximg(1) = std::min(ximg(1), 1.0);
     192            0 :         ximg(0) = std::max(ximg(0), 0.0); ximg(1) = std::max(ximg(1), 0.0);
     193              : 
     194            0 :         ximg(0) *= img_width;
     195            0 :         ximg(1) *= img_height;
     196              : 
     197            0 :         int I = (int)(ximg(0));
     198            0 :         int J = (int)(ximg(1));
     199              : 
     200            0 :         Set::Scalar x1 = I * img_dx, x2 = (I + 1) * img_dx;
     201            0 :         Set::Scalar y1 = J * img_dy, y2 = (J + 1) * img_dy;
     202              : 
     203              : 
     204            0 :         for (int channel = 0; channel < 4; channel++)
     205              :         {
     206              : 
     207            0 :             if (I > 0 && I < png_width - 1 &&
     208            0 :                 J>0 && J < png_height - 1)
     209              :             {
     210            0 :                 png_bytep px_sw = &(row_pointers[J][I * 4]);
     211            0 :                 png_bytep px_se = &(row_pointers[J][(I + 1) * 4]);
     212            0 :                 png_bytep px_nw = &(row_pointers[J + 1][I * 4]);
     213            0 :                 png_bytep px_ne = &(row_pointers[J + 1][(I + 1) * 4]);
     214              : 
     215              : 
     216            0 :                 Set::Scalar fQ11 = ((Set::Scalar)(px_sw[channel]) - min) / (max - min);
     217            0 :                 Set::Scalar fQ12 = ((Set::Scalar)(px_nw[channel]) - min) / (max - min);
     218            0 :                 Set::Scalar fQ21 = ((Set::Scalar)(px_se[channel]) - min) / (max - min);
     219            0 :                 Set::Scalar fQ22 = ((Set::Scalar)(px_ne[channel]) - min) / (max - min);
     220              : 
     221            0 :                 ret[channel] = (
     222            0 :                     fQ11 * (x2 - ximg(0)) * (y2 - ximg(1)) +
     223            0 :                     fQ21 * (ximg(0) - x1) * (y2 - ximg(1)) +
     224            0 :                     fQ12 * (x2 - ximg(0)) * (ximg(1) - y1) +
     225            0 :                     fQ22 * (ximg(0) - x1) * (ximg(1) - y1)) / (img_dx * img_dy);
     226              : 
     227            0 :             }
     228            0 :             else if ((I == 0 || I == png_width - 1) && J < png_height - 1)
     229              :             {
     230            0 :                 png_bytep px_sw = &(row_pointers[J][I * 4]);
     231            0 :                 png_bytep px_nw = &(row_pointers[J + 1][I * 4]);
     232              : 
     233            0 :                 Set::Scalar fQ11 = ((Set::Scalar)(px_sw[channel]) - min) / (max - min);
     234            0 :                 Set::Scalar fQ12 = ((Set::Scalar)(px_nw[channel]) - min) / (max - min);
     235            0 :                 ret[channel] = fQ11 + (fQ12 - fQ11) * (ximg(1) - y1);
     236            0 :             }
     237            0 :             else if (I < png_width - 1 && (J == 0 || J == png_height - 1))
     238              :             {
     239            0 :                 png_bytep px_sw = &(row_pointers[J][I * 4]);
     240            0 :                 png_bytep px_se = &(row_pointers[J][(I + 1) * 4]);
     241              : 
     242            0 :                 Set::Scalar fQ11 = ((Set::Scalar)(px_sw[channel]) - min) / (max - min);
     243            0 :                 Set::Scalar fQ21 = ((Set::Scalar)(px_se[channel]) - min) / (max - min);
     244            0 :                 ret[channel] = fQ11 + (fQ21 - fQ11) * (ximg(0) - x1);
     245            0 :             }
     246            0 :             else if (I == png_width - 1 && J == png_height - 1)
     247              :             {
     248            0 :                 png_bytep px_sw = &(row_pointers[J][I * 4]);
     249              : 
     250            0 :                 Set::Scalar fQ11 = ((Set::Scalar)(px_sw[channel]) - min) / (max - min);
     251            0 :                 ret[channel] = fQ11;
     252            0 :             }
     253              :             else
     254              :             {
     255            0 :                 ret[channel] = 0.0;
     256              :             }
     257              :         }
     258            0 :         return ret;
     259              : #endif
     260              :     }
     261              : 
     262              : private:
     263              : 
     264              : #ifndef ALAMO_NOPNG
     265              :     int png_width, png_height;
     266              :     png_byte color_type;
     267              :     png_byte bit_depth;
     268              :     png_bytep* row_pointers = NULL;
     269              :     Set::Vector coord_lo = Set::Vector::Zero();
     270              :     Set::Vector coord_hi = Set::Vector::Zero();
     271              : 
     272              :     //Util::BMP bmp;
     273              :     Fit fit = Fit::Stretch;
     274              :     Set::Scalar min = NAN, max = NAN;
     275              : 
     276              :     bool domain_defined = false;
     277              :     Set::Vector domain_lo = Set::Vector::Zero();
     278              :     Set::Vector domain_hi = Set::Vector::Zero();
     279              : #endif
     280              : 
     281              : };
     282              : 
     283              : }
        

Generated by: LCOV version 2.0-1