Line data    Source code

       1              : // 
       2              : // Initialize a field using a PNG image. (2D only)
       3              : //
       4              : 
       5              : #ifndef IC_PNG_H
       6              : #define IC_PNG_H
       7              : #include <cmath>
       8              : 
       9              : #ifndef ALAMO_NOPNG
      10              : #include <stdarg.h>
      11              : #include <stddef.h>
      12              : #include <setjmp.h>
      13              : #include <png.h>
      14              : #endif
      15              : 
      16              : #include "IC/IC.H"
      17              : #include "Util/Util.H"
      18              : #include "Util/BMP.H"
      19              : #include "Set/Set.H"
      20              : #include "IO/ParmParse.H"
      21              : #include "Util/PNG.H"
      22              : 
      23              : namespace IC
      24              : {
      25              : class PNG : public IC<Set::Scalar>
      26              : {
      27              : public:
      28              :     static constexpr const char* name = "png";
      29              : 
      30              :     //enum Type {XYZ, XY, YZ, XZ};
      31              :     enum Fit { Stretch, FitWidth, FitHeight, Coord };
      32              :     enum Channel { R = 0, G = 1, B = 2, A = 3 };
      33              : 
      34            0 :     virtual ~PNG() {}
      35              : 
      36            0 :     PNG(amrex::Vector<amrex::Geometry>& _geom) : IC(_geom) {}
      37              : 
      38            0 :     PNG(amrex::Vector<amrex::Geometry>& _geom, IO::ParmParse& pp, std::string name) : PNG(_geom)
      39              :     {
      40            0 :         pp_queryclass(name, *this);
      41            0 :     }
      42              : 
      43            0 :     void Add(const int& lev, Set::Field<Set::Scalar>& a_field, Set::Scalar)
      44              :     {
      45              : 
      46              : #ifndef ALAMO_NOPNG
      47            0 :         Set::Vector DX(geom[lev].CellSize());
      48            0 :         amrex::Box domain = geom[lev].Domain();
      49              : 
      50            0 :         amrex::IndexType type = a_field[lev]->ixType();
      51            0 :         domain.convert(type);
      52              : 
      53            0 :         Set::Vector domlo(AMREX_D_DECL(geom[lev].ProbLo()[0], geom[lev].ProbLo()[1], 0.0));
      54            0 :         Set::Vector domhi(AMREX_D_DECL(geom[lev].ProbHi()[0], geom[lev].ProbHi()[1], 0.0));
      55              : 
      56            0 :         png.setDomain(domlo, domhi);
      57              : 
      58            0 :         for (amrex::MFIter mfi(*a_field[lev], amrex::TilingIfNotGPU()); mfi.isValid(); ++mfi)
      59              :         {
      60            0 :             amrex::Box bx;
      61            0 :             if (type == amrex::IndexType::TheNodeType()) bx = mfi.grownnodaltilebox();
      62            0 :             if (type == amrex::IndexType::TheCellType()) bx = mfi.growntilebox();
      63            0 :             bx = bx & domain;
      64              : 
      65            0 :             amrex::Array4<Set::Scalar> const& field = a_field[lev]->array(mfi);
      66            0 :             amrex::ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k)
      67              :             {
      68            0 :                 Set::Vector x = Set::Vector::Zero();
      69              :                 // NODE
      70            0 :                 if (type == amrex::IndexType::TheNodeType())
      71              :                 {
      72            0 :                     x(0) = domlo(0) + ((amrex::Real)(i)) * geom[lev].CellSize()[0];
      73            0 :                     x(1) = domlo(1) + ((amrex::Real)(j)) * geom[lev].CellSize()[1];
      74              :                 }
      75            0 :                 else if (type == amrex::IndexType::TheCellType())
      76              :                 {
      77            0 :                     x(0) = domlo(0) + ((amrex::Real)(i)+0.5) * geom[lev].CellSize()[0];
      78            0 :                     x(1) = domlo(1) + ((amrex::Real)(j)+0.5) * geom[lev].CellSize()[1];
      79              :                 }
      80              : 
      81              : 
      82            0 :                 std::array<Set::Scalar, 4> val = png(x);
      83              : 
      84            0 :                 field(i,j,k,0) = val[channel];
      85              : 
      86              : 
      87            0 :                 if (field.nComp() > 1) field(i, j, k, 1) = 1.0 - field(i, j, k, 0);
      88              : 
      89            0 :             });
      90            0 :         }
      91            0 :         a_field[lev]->FillBoundary();
      92              : #else
      93              :         Util::Abort(INFO,"PNG is disabled");
      94              : #endif
      95              :         
      96            0 :     };
      97              : 
      98              : private:
      99              : #ifndef ALAMO_NOPNG
     100              :     Util::PNG png;
     101              :     Channel channel = Channel::G;
     102              : #endif
     103              : 
     104              : public:
     105            0 :     static void Parse(PNG& value, IO::ParmParse& pp)
     106              :     {
     107              : #ifndef ALAMO_NOPNG
     108              : 
     109            0 :         std::string channel = "g";
     110              :         // Color channel to use (options: r, R, g, G, b, B, a, A)        
     111            0 :         pp_query_validate("channel", channel, {"r","g","b","a","R","G","B","A"}); 
     112            0 :         if (channel == "r" || channel == "R") value.channel = Channel::R;
     113            0 :         else if (channel == "g" || channel == "G") value.channel = Channel::G;
     114            0 :         else if (channel == "b" || channel == "B") value.channel = Channel::B;
     115            0 :         else if (channel == "a" || channel == "A") value.channel = Channel::A;
     116            0 :         else Util::Abort(INFO, "Invalid value for bmp channel - should be r/g/b/a but received '", channel, "'");
     117              : 
     118              :         
     119            0 :         pp.queryclass<Util::PNG>(value.png);
     120              : 
     121              : #else
     122              :         Util::Abort(INFO,"PNG is disabled");
     123              : #endif
     124            0 :     }
     125              : };
     126              : }
     127              : #endif