# Fractals/Computer graphic techniques/2D/transformation

Plane transformations

# Names

• transformations
• projections
• Cartographic Map projection ( in case of 3D to 2D graphic)
• mappings

# Theory

Mapping in 2D raster graphic is a complex function $f$  that maps from complex plane to complex plane:

$f:\mathbb {C} \to \mathbb {C}$ It is implemented as point transformations.

It is usually denoted as

$w=f(z)$ where

• $z=x+yi$  is a point of complex plane ( input)
• $w=u+vi$  is a point of image complex plane ( output = result)

For instance, Mercator:

function Spherical_mercator(x, y) {
return [x, Math.log(Math.tan(Math.PI / 4 + y / 2))];
}

function transverseMercatorRaw(lambda, phi) {
return [log(tan((halfPi + phi) / 2)), -lambda];
}

transverseMercatorRaw.invert = function(x, y) {
return [-y, 2 * atan(exp(x)) - halfPi];
};


If one work with discrete geometry ( polygons and polylines) then the projecting is much harder to imlement. One have to balance accuracy and performance.

# classifications

Maps clasifications

• object-based mappings ( Image objects are sets of connected pixels having the same integer value )
• pixel based mappings

Transformations ( maps) in 2-D graphics

• basic types
• Composite Transformation 

# types

## rotation


/*

C program to rotate an object by a given angle about a given point
gcc r.c -Wall -Wextra -lm
./a.out
*/

#include <stdio.h>
#include <math.h>
#include <complex.h> 		// complex numbers : https://stackoverflow.com/questions/6418807/how-to-work-with-complex-numbers-in-c

//The sin() function returns the value in the range of [-1, 1]

/*
First subtract the pivot point (cx,cy), then rotate it (counter clock-wise), then add the point again.
*/

complex double rotate_point(const complex double center, const double angle_in_radians, const complex double point )
{
// translate point to center
complex double translated_point = creal(point) - creal(center)  + (cimag(point) - cimag(center))*I;

// rotate point counter clock-wise by a given angle about a given pivot point ( center)
complex double new_point = creal(translated_point) * c - cimag(translated_point) * s + (creal(translated_point) * s + cimag(translated_point) * c)*I;

// translate point back
new_point = creal(new_point) + creal(center) +(cimag(new_point) + cimag(center))*I;

return new_point;
}

#define kMax 6

double examples[kMax] = {
{50,-50, -0.7853982, 100,100 },
{50,-50, -0.7853982, 100,200 },
{50,-50, -0.7853982, 200,200 },
{0,0, 1.570796, 100,100},
{0,0, 1.570796, 150,200},
{0,0, 1.570796, 200,200}

};

int main(void){

int k;

complex double center ;
double angle_r ;
complex double point ;
complex double rotated_point;

for (k=0; k<kMax; ++k){
center = examples[k] + examples[k] * I ;
angle_r = examples[k];
point = examples[k] + examples[k] * I ;
rotated_point = rotate_point(center, angle_r, point );
fprintf(stdout, "point %f%+f*I rotated about %f%+f*I  by %f radians is %f%+f*I \n", creal(point), cimag(point), creal(center), cimag(center), angle_r, creal(rotated_point), cimag(rotated_point));
}

return 0;
}


Output:

point 100.000000+100.000000*I rotated about 50.000000-50.000000*I  by -0.785398 radians is 191.421359+20.710673*I


Examples:

## Conformal map

• "Conformal maps preserve angles and take infinitesimal circles to infinitesimal circles. Non-conformal maps take infinitesimal circles to infinitesimal ellipses (or worse)." Claude Heiland-Allen
• "A complex function $f(z)$  is conformal at infinity if the function $f(1/z)$  is conformal at 0. This equivalent to the usual definition of conformal in terms of leaving angles unchanged in size and sense (clockwise/anticlockwise) if you think of $f$  as being conformal at infinity if it leaves angles unchanged at the "North Pole" of the Riemann sphere."

Conformal maps

Dictionary of Conformal Mapping by John H. Mathews, Russell W. Howell ( 2008)

## Cartographic Map projection

### cylindrical projection

Cylindrical projection ( or cylindric p. ) maps from sphere ( without poles) to cylinder 

Description :

## domain coloring or complex phase plots

Visualisation of complex functions