write_jpg.hpp

#ifndef INCLUDE_WRITE_JPG
#define INCLUDE_WRITE_JPG

#include "image_parser.hpp"
#include <vector>

#include "my_mkl.hpp"
#include "input_file.hpp"

#include <memory>

class Bild;

class jpg_image_processor: public abstract_image_parser
{
public:
    ~jpg_image_processor() throw() {};
private:

    STD_TR1::shared_ptr<palette> my_palette;

    bool do_jpg;
    std::string filename_extension;

    const char* name() const { return "jpg_image";};
    void init();

    void process_image_( MPI_Comm comm,
             const Bild& b, 
             const std::string& filen );    
};

//for efficiency reasons, use template instead of function pointer calls

class palette: public loadable_Object{
public:
    typedef STD_TR1::shared_ptr<palette> ref;

    void write_ppm_info(const Bild& bild, 
            FILE* file)
    { use_palette_( bild, file);};

protected:
    template <class effective_palette>
    void write_ppm(const Bild& bild, 
           FILE* file,
           const effective_palette& t) const;

private:
    virtual void use_palette_(const Bild&, 
                  FILE* file) = 0;
};

class default_palette: public palette{
public:
    void precalc(const complex& c) const {
        tmp = abs(c)*abs(c);    
    white = (tmp <= white_thrshld);

    if (tmp > 10000){
        if (c.real() < 0) 
        {
        tmp=0;
        }else{
        white = true;
        }
    }else{
        tmp -= delta_eff;
    }

    if (tmp < 0.) tmp = 0.;

    tmp = atan(tmp * scale) * M_2_PI;
    };

    char red(const complex& c) const { if (white) return 255; return tmp * 255.;};
    char green(const complex& c) const { if (white) return 255; return tmp*tmp*(1.-tmp)*27./4.*255.;}; 
    char blue(const complex& c) const { if (white) return 255; return tmp * (1. - tmp) * (1. - tmp) * 27./4. * 255.;};

private:

    void use_palette_(const Bild&, FILE*);

    virtual const char* name() const { return "default_palette";};    
    double white_thrshld;

    void init();

    double scale;
    double delta;
    double delta_eff;
    mutable double tmp;    
    mutable bool white;
};

class log_palette: public palette{
public:
    void precalc(const complex& c) const {
    tmp = abs(c)*abs(c);
    white = (tmp == 0.);
    if (!white){
         tmp = (log(tmp) + y0) * scale;
         if (tmp < 0) tmp = 0;
         if (tmp > 1) tmp = 1;
    }
    };

    char red(const complex& c) const { if (white) return 255; return tmp * 255.;};
    char green(const complex& c) const { if (white) return 255; return tmp*tmp*(1.-tmp)*27./4.*255.;}; 
    char blue(const complex& c) const { if (white) return 255; return tmp * (1. - tmp) * (1. - tmp) * 27./4. * 255.;};

private:

    void use_palette_(const Bild&, FILE*);

    virtual const char* name() const { return "log_palette";};    

    void init();

    double scale;
    double y0;
    mutable double tmp;
    mutable bool white;
};

class height_palette: public palette{
private:
    bool arctanscale;
public:
    void precalc(const complex& c) const {
    
    double f(max*(std::max(abs(c)*abs(c) - min,0.)));
    if (arctanscale){
        f = atan(f / 6553) * M_2_PI * 65535;    
    }
    tmp = (f > 65535) ? 65530 : static_cast<int>(f);};

    char red(const complex& c) const { return tmp / 256.;};
    char green(const complex& c) const { return tmp % 256;}; 
    char blue(const complex& c) const { return 0;};

private:

    void use_palette_(const Bild&, FILE*);

    virtual const char* name() const { return "height_palette";};    

    void init();

    double max;
    double min;

    mutable int tmp;    
};


class multilayer_default_palette: public palette{
public:
    void precalc(const complex& c) const {
        tmp = abs(c);   
    white = (tmp == 0.);
    tmp -= delta_eff;
    if (tmp < 0.) tmp = 0.;
    tmp = atan(tmp * scale) * M_2_PI;};

    char red(const complex& c) const { if (white) return 255; return tmp * 255.;};
    char green(const complex& c) const { if (white) return 255; return tmp*tmp*(1.-tmp)*27./4.*255.;}; 
    char blue(const complex& c) const { if (white) return 255; return tmp * (1. - tmp) * (1. - tmp) * 27./4. * 255.;};

private:

    void use_palette_(const Bild&, FILE*);

    virtual const char* name() const { return "multilayer_default_palette";};    

    void init();

    double scale;
    double delta;
    double delta_eff;
    mutable double tmp;    
    mutable bool white;
};


class complex_palette: public palette{
public:
    void precalc(const complex& c) const {
        if (part == 0) {
            tmp = c.real();
        } else if (part == 1) {
            tmp = c.imag();
        } else if (part == 2) {
            tmp = abs(c);
        } else if (part == 3) {
            tmp = atan2(c.imag(),c.real());
        }
        tmp = atan(tmp * scale) * M_1_PI + 0.5;
    };

    // modelled after the 9-class RdBu colormap (see http://colorbrewer2.org/)
    // to reverse the map, simply replace (1.-tmp) with tmp
    char red(const complex& c) const { 
        return (0.70448+1.52424*(1.-tmp)-2.18358*(1.-tmp)*(1.-tmp)) * 255.;
    };
    char green(const complex& c) const { 
        return (0.0754843+3.05864*(1.-tmp)-2.77681*(1.-tmp)*(1.-tmp)) * 255;
    }; 
    char blue(const complex& c) const { 
        return (0.0892454+2.55404*(1.-tmp)-1.9815*(1.-tmp)*(1.-tmp))* 255.;
    };

private:

    void use_palette_(const Bild&, FILE*);

    virtual const char* name() const { return "complex_palette";};

    void init();

    double scale;
    double delta;

    int part;

    mutable double tmp;
};

class parula_palette: public palette{
public:
    void precalc(const complex& c) const {
        tmp = abs(c)*abs(c);

        white = (tmp <= white_thrshld);

        if (tmp > 10000){
            if (c.real() < 0)
            {
            tmp=0;
            }else{
            white = true;
            }
        }else{
            tmp -= delta_eff;
        }

        if (tmp < 0.) tmp = 0.;

        tmp = atan(tmp * scale) * M_2_PI;
    };

    char red(const complex& c) const {
        if (white) return 255;
        return (0.205465 -4.48508 *tmp+40.8598 *tmp*tmp-169.805 *tmp*tmp*tmp+343.401 *tmp*tmp*tmp*tmp-315.711 *tmp*tmp*tmp*tmp*tmp+106.514 *tmp*tmp*tmp*tmp*tmp*tmp) * 255.;
    };
    char green(const complex& c) const {
        if (white) return 255;
        return (0.164678 +2.97057 *tmp-15.2531 *tmp*tmp+59.0754 *tmp*tmp*tmp-113.712 *tmp*tmp*tmp*tmp+99.8169 *tmp*tmp*tmp*tmp*tmp-32.0779 *tmp*tmp*tmp*tmp*tmp*tmp) * 255.;
    };
    char blue(const complex& c) const {
        if (white) return 255;
        return (0.53106 +5.66654 *tmp-32.4304 *tmp*tmp+85.9473 *tmp*tmp*tmp-126.792 *tmp*tmp*tmp*tmp+95.8767 *tmp*tmp*tmp*tmp*tmp-28.7464 *tmp*tmp*tmp*tmp*tmp*tmp) * 255.;
    };

private:

    void use_palette_(const Bild&, FILE*);

    virtual const char* name() const { return "parula_palette";};
    double white_thrshld;

    void init();

    double scale;
    double delta;
    double delta_eff;
    mutable double tmp;
    mutable bool white;
};


class parula_log_palette: public palette{
public:
    void precalc(const complex& c) const {
    tmp = abs(c)*abs(c);
    white = (tmp == 0.);
    if (!white){
         tmp = (log(tmp) + y0) * scale;
         if (tmp < 0) tmp = 0;
         // if (tmp > 1) tmp = 1;
         if (tmp > 0.89) tmp = 0.89;
    }
    };

    char red(const complex& c) const {
        if (white) return 255;
        return (0.205465 -4.48508 *tmp+40.8598 *tmp*tmp-169.805 *tmp*tmp*tmp+343.401 *tmp*tmp*tmp*tmp-315.711 *tmp*tmp*tmp*tmp*tmp+106.514 *tmp*tmp*tmp*tmp*tmp*tmp) * 255.;
    };
    char green(const complex& c) const {
        if (white) return 255;
        return (0.164678 +2.97057 *tmp-15.2531 *tmp*tmp+59.0754 *tmp*tmp*tmp-113.712 *tmp*tmp*tmp*tmp+99.8169 *tmp*tmp*tmp*tmp*tmp-32.0779 *tmp*tmp*tmp*tmp*tmp*tmp) * 255.;
    };
    char blue(const complex& c) const {
        if (white) return 255;
        return (0.53106 +5.66654 *tmp-32.4304 *tmp*tmp+85.9473 *tmp*tmp*tmp-126.792 *tmp*tmp*tmp*tmp+95.8767 *tmp*tmp*tmp*tmp*tmp-28.7464 *tmp*tmp*tmp*tmp*tmp*tmp) * 255.;
    };

private:

    void use_palette_(const Bild&, FILE*);

    virtual const char* name() const { return "parula_log_palette";};

    void init();

    double scale;
    double y0;
    mutable double tmp;
    mutable bool white;
};


#endif