Funny Fractal Encryption c++11 testing 123...

/*
Funny Fractal Encryption (in progress)...
by: Chris M. Thomasson
__________________________________________________________________*/



#include <cstdlib>
#include <climits>
#include <cstdio>
#include <cmath>
#include <string>
#include <complex>
#include <iostream>
#include <algorithm>






namespace fractal
{

#define FRACTAL_PREC ".17"

typedef std::complex<double> complex_t;


static double round(double n)
{
    if (n > 0.0)
    {
        n = n + 0.5;
    }

    else
    {
        n = n - 0.5;
    }

    return n;
}

struct grid
{
    std::size_t m_width;
    std::size_t m_height;
};


struct axes
{
    double m_xmin;
    double m_xmax;
    double m_ymin;
    double m_ymax;

    double width() const
    {
        return m_xmax - m_xmin;
    }

    double height() const
    {
        return m_ymax - m_ymin;
    }
};


struct iter_result
{
    std::size_t m_iters;
    double m_orbit_trap;
    complex_t m_z;
};

struct iter_settings
{
    grid m_grid;
    axes m_axes;
    std::size_t m_iters;
    complex_t m_jp[3];
};

struct iter_callback_base
{
    virtual bool callback(std::size_t x, std::size_t y, complex_t const c, iter_settings const& isets, iter_result& ires) = 0;
};


// Iterate 3 points in triple mixed Julia mode...
static bool iterate_point(complex_t const c, iter_settings const& isets, iter_result& ires)
{
    complex_t z = c;

    complex_t scale(1.0, 0.0);

    double orbit_trap = 99999999999999999.0;

    std::size_t jstep = 0;

    double escape =
        std::abs(2.0 +
            isets.m_jp[0].real() + isets.m_jp[0].imag() +
            isets.m_jp[1].real() + isets.m_jp[1].imag() +
            isets.m_jp[2].real() + isets.m_jp[2].imag()
        );

    for (std::size_t i = 1; i < isets.m_iters + 1; ++i)
    {
        z = z * z;

        if (jstep == 0)
        {
            z = z + isets.m_jp[0];
        }


        else if (jstep == 1)
        {
            z = z + isets.m_jp[1];
        }

        else
        {
            z = z + isets.m_jp[2];
        }

        z = z * scale;

        jstep = (jstep + 1) % 3;

        double d = std::sqrt(z.real() * z.real() + z.imag() * z.imag());

        if (d != 0)
        {
            orbit_trap = std::min(orbit_trap, d);
        }

        else
        {
            orbit_trap = std::min(orbit_trap, 0.1);
        }

        if (d > escape)
        {
            ires.m_iters = i;
            ires.m_orbit_trap = orbit_trap;
            ires.m_z = z;

            return false;
        }
    }

    ires.m_iters = isets.m_iters;
    ires.m_orbit_trap = orbit_trap;
    ires.m_z = z;

    return true;
}

// Iterare the whole axes in `isets' using a callback for each mapped complex number
static void iterate_plane(iter_callback_base& callback, iter_settings const& isets, iter_result& ires)
{
    complex_t c(0.0, 0.0);
    double xstep = isets.m_axes.width() / (isets.m_grid.m_width - 1);
    double ystep = isets.m_axes.height() / (isets.m_grid.m_height - 1);

    for (std::size_t y = 0; y < isets.m_grid.m_height; ++y)
    {
        c.imag(isets.m_axes.m_ymax - ystep * y);

        for (std::size_t x = 0; x < isets.m_grid.m_width; ++x)
        {
            c.real(isets.m_axes.m_xmin + xstep * x);

            if (! callback.callback(x, y, c, isets, ires))
            {
                return;
            }
        }
    }
}


}


namespace ffe
{

#define FFE_LB "\r\n"
#define FFE_BYTE_SZ (UCHAR_MAX + 1)


struct private_fractal : public fractal::iter_callback_base
{
    bool callback(std::size_t x, std::size_t y, fractal::complex_t const c, fractal::iter_settings const& isets, fractal::iter_result& ires)
    {
        double cipher_mutator_real = 0.0;
        fractal::iterate_point(c, isets, ires);

        if (isets.m_iters != ires.m_iters)
        {
            cipher_mutator_real = ires.m_iters * ires.m_orbit_trap * (ires.m_z.real() + ires.m_z.imag());
            cipher_mutator_real *= 5134.0413;
        }

        else
        {
            cipher_mutator_real = ires.m_iters * ires.m_orbit_trap * (ires.m_z.real() + ires.m_z.imag());
            cipher_mutator_real *= 178654.681;
        }

        std::size_t cipher_mutator = ((std::size_t)std::abs(fractal::round(cipher_mutator_real))) % FFE_BYTE_SZ;

        // Encrypt the 9 A's in the plaintext. 65 = A in decimal wrt ASCII
        std::size_t cipher_mutation = (65 + cipher_mutator) % FFE_BYTE_SZ;

        std::cout << cipher_mutation << " ";

        return true;
    }
};



}







namespace app
{

struct ascii_fractal : public fractal::iter_callback_base
{
    bool callback(
        std::size_t x, std::size_t y,
        fractal::complex_t const c,
        fractal::iter_settings const& isets,
        fractal::iter_result& ires
    ){
        if (! fractal::iterate_point(c, isets, ires))
        {
            std::cout << "-";
        }

        else
        {
            std::cout << "*";
        }

        return true;
    }
};


}




int main()
{
    {
        std::string plaintext = "AAAAAAAAA";

        std::size_t D = ((std::size_t)(std::ceil(std::sqrt(plaintext.length())) + 1));

        std::cout << "D = " << D << FFE_LB;

        fractal::iter_settings isets = {
            { D, D },
            { -1.5, 1.5, -1.5, 1.5 },
            314,
            { { 0.36, 0.1 }, { -0.75, 0.2 }, { 0.35, 0.1 } }
        };

        fractal::iter_result ires = {
            0,
            0.0,
            { 0.0, 0.0 }
        };

        ffe::private_fractal ffe_frac;
        app::ascii_fractal txt_frac;

        fractal::complex_t c(0.0, 0.5);

        std::cout << c << FFE_LB FFE_LB;


        fractal::iterate_plane(txt_frac, isets, ires);

        std::cout << FFE_LB FFE_LB;

        fractal::iterate_plane(ffe_frac, isets, ires);
    }

    std::cout << FFE_LB FFE_LB "Hit <ENTER> to exit..." << FFE_LB;
    std::cin.get();

    return 0;
}