Gecko [ nrupathungauniversityblr.ac.in ]

Name	Size	Permission
msinttypes	[ DIR ]	drwxr-xr-x
CMakeLists.txt	3.23 KB	-rwxr-xr-x
COPYING	2.25 KB	-rwxr-xr-x
Makefile.am	1.96 KB	-rwxr-xr-x
annotate.c	4.38 KB	-rwxr-xr-x
bdftogd	3.91 KB	-rwxr-xr-x
bmp.h	2.39 KB	-rwxr-xr-x
circletexttest.c	1.49 KB	-rwxr-xr-x
config.h.cmake	3.58 KB	-rwxr-xr-x
demoin.png	9.79 KB	-rwxr-xr-x
depcomp	11.84 KB	-rwxr-xr-x
entities.h	4.81 KB	-rwxr-xr-x
entities.html	41.11 KB	-rwxr-xr-x
entities.tcl	1.35 KB	-rwxr-xr-x
fontconfigtest.c	1.34 KB	-rwxr-xr-x
fontsizetest.c	2.3 KB	-rwxr-xr-x
fontwheeltest.c	3.23 KB	-rwxr-xr-x
gd.c	89.58 KB	-rwxr-xr-x
gd.h	50.14 KB	-rwxr-xr-x
gd2copypal.c	1.25 KB	-rwxr-xr-x
gd2time.c	1.19 KB	-rwxr-xr-x
gd2togif.c	939 B	-rwxr-xr-x
gd2topng.c	1.38 KB	-rwxr-xr-x
gd_bmp.c	25.78 KB	-rwxr-xr-x
gd_color.c	798 B	-rwxr-xr-x
gd_color.h	189 B	-rwxr-xr-x
gd_color_map.c	22.71 KB	-rwxr-xr-x
gd_color_map.h	478 B	-rwxr-xr-x
gd_color_map_test.c	570 B	-rwxr-xr-x
gd_color_match.c	1.49 KB	-rwxr-xr-x
gd_crop.c	5.75 KB	-rwxr-xr-x
gd_errors.h	1.47 KB	-rwxr-xr-x
gd_filename.c	6.41 KB	-rwxr-xr-x
gd_filter.c	21 KB	-rwxr-xr-x
gd_gd.c	7.1 KB	-rwxr-xr-x
gd_gd2.c	25.85 KB	-rwxr-xr-x
gd_gif_in.c	14.79 KB	-rwxr-xr-x
gd_gif_out.c	41 KB	-rwxr-xr-x
gd_intern.h	1.95 KB	-rwxr-xr-x
gd_interpolation.c	59.19 KB	-rwxr-xr-x
gd_io.c	3.42 KB	-rwxr-xr-x
gd_io.h	3.05 KB	-rwxr-xr-x
gd_io_dp.c	7.95 KB	-rwxr-xr-x
gd_io_file.c	2.41 KB	-rwxr-xr-x
gd_io_ss.c	2.66 KB	-rwxr-xr-x
gd_io_stream.cxx	4.11 KB	-rwxr-xr-x
gd_io_stream.h	3.63 KB	-rwxr-xr-x
gd_jpeg.c	34.5 KB	-rwxr-xr-x
gd_matrix.c	7.93 KB	-rwxr-xr-x
gd_nnquant.c	15 KB	-rwxr-xr-x
gd_nnquant.h	527 B	-rwxr-xr-x
gd_png.c	30.58 KB	-rwxr-xr-x
gd_rotate.c	12.25 KB	-rwxr-xr-x
gd_security.c	692 B	-rwxr-xr-x
gd_ss.c	1.27 KB	-rwxr-xr-x
gd_tga.c	8.61 KB	-rwxr-xr-x
gd_tga.h	1.66 KB	-rwxr-xr-x
gd_tiff.c	25.85 KB	-rwxr-xr-x
gd_topal.c	55.18 KB	-rwxr-xr-x
gd_transform.c	1.48 KB	-rwxr-xr-x
gd_version.c	827 B	-rwxr-xr-x
gd_wbmp.c	6.54 KB	-rwxr-xr-x
gd_webp.c	4.25 KB	-rwxr-xr-x
gd_xbm.c	5.68 KB	-rwxr-xr-x
gdcache.c	5.14 KB	-rwxr-xr-x
gdcache.h	2.83 KB	-rwxr-xr-x
gdcmpgif.c	1.86 KB	-rwxr-xr-x
gddemo.c	5.42 KB	-rwxr-xr-x
gdfontg.c	109.84 KB	-rwxr-xr-x
gdfontg.h	553 B	-rwxr-xr-x
gdfontl.c	104.83 KB	-rwxr-xr-x
gdfontl.h	551 B	-rwxr-xr-x
gdfontmb.c	76.33 KB	-rwxr-xr-x
gdfontmb.h	519 B	-rwxr-xr-x
gdfonts.c	66.55 KB	-rwxr-xr-x
gdfonts.h	515 B	-rwxr-xr-x
gdfontt.c	36.82 KB	-rwxr-xr-x
gdfontt.h	546 B	-rwxr-xr-x
gdft.c	49.23 KB	-rwxr-xr-x
gdfx.c	13.52 KB	-rwxr-xr-x
gdfx.h	2.34 KB	-rwxr-xr-x
gdhelpers.c	1.51 KB	-rwxr-xr-x
gdhelpers.h	2.31 KB	-rwxr-xr-x
gdkanji.c	11.97 KB	-rwxr-xr-x
gdparttopng.c	1.23 KB	-rwxr-xr-x
gdpp.cxx	6.43 KB	-rwxr-xr-x
gdpp.h	50.94 KB	-rwxr-xr-x
gdtables.c	4.67 KB	-rwxr-xr-x
gdtest.c	10.27 KB	-rwxr-xr-x
gdtestft.c	5.54 KB	-rwxr-xr-x
gdtopng.c	1.01 KB	-rwxr-xr-x
gdxpm.c	4.64 KB	-rwxr-xr-x
gifanimtest.c	682 B	-rwxr-xr-x
giftogd2.c	1.12 KB	-rwxr-xr-x
jisx0208.h	73.71 KB	-rwxr-xr-x
pngtogd.c	1.03 KB	-rwxr-xr-x
pngtogd2.c	1.23 KB	-rwxr-xr-x
snprintf.c	585 B	-rwxr-xr-x
testac.c	4.14 KB	-rwxr-xr-x
testtr.c	1.33 KB	-rwxr-xr-x
wbmp.c	6.18 KB	-rwxr-xr-x
wbmp.h	1.2 KB	-rwxr-xr-x
webpng.c	6.44 KB	-rwxr-xr-x

Code Editor : gd_matrix.c

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */

#include "gd.h"
#include <math.h>

#ifndef M_PI
# define M_PI 3.14159265358979323846
#endif

/**
 * Title: Matrix
 * Group: Affine Matrix
 */

/**
 * Function: gdAffineApplyToPointF
 *  Applies an affine transformation to a point (floating point
 *  gdPointF)
 *
 *
 * Parameters:
 * 	dst - Where to store the resulting point
 *  affine - Source Point
 *  flip_horz - affine matrix
 *
 * Returns:
 *  GD_TRUE if the affine is rectilinear or GD_FALSE
 */
BGD_DECLARE(int) gdAffineApplyToPointF (gdPointFPtr dst, const gdPointFPtr src,
		  const double affine[6])
{
	double x = src->x;
	double y = src->y;
	dst->x = x * affine[0] + y * affine[2] + affine[4];
	dst->y = x * affine[1] + y * affine[3] + affine[5];
	return GD_TRUE;
}

/**
 * Function: gdAffineInvert
 *  Find the inverse of an affine transformation.
 *
 * All non-degenerate affine transforms are invertible. Applying the
 * inverted matrix will restore the original values. Multiplying <src>
 * by <dst> (commutative) will return the identity affine (rounding
 * error possible).
 *
 * Parameters:
 * 	dst - Where to store the resulting affine transform
 *  src_affine - Original affine matrix
 *  flip_horz - Whether or not to flip horizontally
 *  flip_vert - Whether or not to flip vertically
 *
 * See also:
 *  <gdAffineIdentity>
 *
 * Returns:
 *  GD_TRUE if the affine is rectilinear or GD_FALSE
 */
BGD_DECLARE(int) gdAffineInvert (double dst[6], const double src[6])
{
	double r_det = (src[0] * src[3] - src[1] * src[2]);

if (r_det <= 0.0) {
		return GD_FALSE;
	}

r_det = 1.0 / r_det;
	dst[0] = src[3] * r_det;
	dst[1] = -src[1] * r_det;
	dst[2] = -src[2] * r_det;
	dst[3] = src[0] * r_det;
	dst[4] = -src[4] * dst[0] - src[5] * dst[2];
	dst[5] = -src[4] * dst[1] - src[5] * dst[3];
	return GD_TRUE;
}

/**
 * Function: gdAffineFlip
 *  Flip an affine transformation horizontally or vertically.
 *
 * Flips the affine transform, giving GD_FALSE for <flip_horz> and
 * <flip_vert> will clone the affine matrix. GD_TRUE for both will
 * copy a 180° rotation.
 *
 * Parameters:
 * 	dst - Where to store the resulting affine transform
 *  src_affine - Original affine matrix
 *  flip_h - Whether or not to flip horizontally
 *  flip_v - Whether or not to flip vertically
 *
 * Returns:
 *  GD_TRUE on success or GD_FALSE
 */
BGD_DECLARE(int) gdAffineFlip (double dst[6], const double src[6], const int flip_h, const int flip_v)
{
	dst[0] = flip_h ? - src[0] : src[0];
	dst[1] = flip_h ? - src[1] : src[1];
	dst[2] = flip_v ? - src[2] : src[2];
	dst[3] = flip_v ? - src[3] : src[3];
	dst[4] = flip_h ? - src[4] : src[4];
	dst[5] = flip_v ? - src[5] : src[5];
	return GD_TRUE;
}

/**
 * Function: gdAffineConcat
 * Concat (Multiply) two affine transformation matrices.
 *
 * Concats two affine transforms together, i.e. the result
 * will be the equivalent of doing first the transformation m1 and then
 * m2. All parameters can be the same matrix (safe to call using
 * the same array for all three arguments).
 *
 * Parameters:
 * 	dst - Where to store the resulting affine transform
 *  m1 - First affine matrix
 *  m2 - Second affine matrix
 *
 * Returns:
 *  GD_TRUE on success or GD_FALSE
 */
BGD_DECLARE(int) gdAffineConcat (double dst[6], const double m1[6], const double m2[6])
{
	double dst0, dst1, dst2, dst3, dst4, dst5;

dst0 = m1[0] * m2[0] + m1[1] * m2[2];
	dst1 = m1[0] * m2[1] + m1[1] * m2[3];
	dst2 = m1[2] * m2[0] + m1[3] * m2[2];
	dst3 = m1[2] * m2[1] + m1[3] * m2[3];
	dst4 = m1[4] * m2[0] + m1[5] * m2[2] + m2[4];
	dst5 = m1[4] * m2[1] + m1[5] * m2[3] + m2[5];
	dst[0] = dst0;
	dst[1] = dst1;
	dst[2] = dst2;
	dst[3] = dst3;
	dst[4] = dst4;
	dst[5] = dst5;
	return GD_TRUE;
}

/**
 * Function: gdAffineIdentity
 * Set up the identity matrix.
 *
 * Parameters:
 * 	dst - Where to store the resulting affine transform
 *
 * Returns:
 *  GD_TRUE on success or GD_FALSE
 */
BGD_DECLARE(int) gdAffineIdentity (double dst[6])
{
	dst[0] = 1;
	dst[1] = 0;
	dst[2] = 0;
	dst[3] = 1;
	dst[4] = 0;
	dst[5] = 0;
	return GD_TRUE;
}

/**
 * Function: gdAffineScale
 * Set up a scaling matrix.
 *
 * Parameters:
 * 	scale_x - X scale factor
 * 	scale_y - Y scale factor
 *
 * Returns:
 *  GD_TRUE on success or GD_FALSE
 */
BGD_DECLARE(int) gdAffineScale (double dst[6], const double scale_x, const double scale_y)
{
	dst[0] = scale_x;
	dst[1] = 0;
	dst[2] = 0;
	dst[3] = scale_y;
	dst[4] = 0;
	dst[5] = 0;
	return GD_TRUE;
}

/**
 * Function: gdAffineRotate
 * Set up a rotation affine transform.
 *
 * Like the other angle in libGD, in which increasing y moves
 * downward, this is a counterclockwise rotation.
 *
 * Parameters:
 * 	dst - Where to store the resulting affine transform
 * 	angle - Rotation angle in degrees
 *
 * Returns:
 *  GD_TRUE on success or GD_FALSE
 */
BGD_DECLARE(int) gdAffineRotate (double dst[6], const double angle)
{
	const double sin_t = sin (angle * M_PI / 180.0);
	const double cos_t = cos (angle * M_PI / 180.0);

dst[0] = cos_t;
	dst[1] = sin_t;
	dst[2] = -sin_t;
	dst[3] = cos_t;
	dst[4] = 0;
	dst[5] = 0;
	return GD_TRUE;
}

/**
 * Function: gdAffineShearHorizontal
 * Set up a horizontal shearing matrix || becomes \\.
 *
 * Parameters:
 * 	dst - Where to store the resulting affine transform
 * 	angle - Shear angle in degrees
 *
 * Returns:
 *  GD_TRUE on success or GD_FALSE
 */
BGD_DECLARE(int) gdAffineShearHorizontal(double dst[6], const double angle)
{
	dst[0] = 1;
	dst[1] = 0;
	dst[2] = tan(angle * M_PI / 180.0);
	dst[3] = 1;
	dst[4] = 0;
	dst[5] = 0;
  	return GD_TRUE;
}

/**
 * Function: gdAffineShearVertical
 * Set up a vertical shearing matrix, columns are untouched.
 *
 * Parameters:
 * 	dst - Where to store the resulting affine transform
 * 	angle - Shear angle in degrees
 *
 * Returns:
 *  GD_TRUE on success or GD_FALSE
 */
BGD_DECLARE(int) gdAffineShearVertical(double dst[6], const double angle)
{
	dst[0] = 1;
	dst[1] = tan(angle * M_PI / 180.0);
	dst[2] = 0;
	dst[3] = 1;
	dst[4] = 0;
	dst[5] = 0;
  	return GD_TRUE;
}

/**
 * Function: gdAffineTranslate
 * Set up a translation matrix.
 *
 * Parameters:
 * 	dst - Where to store the resulting affine transform
 * 	offset_x - Horizontal translation amount
 * 	offset_y - Vertical translation amount
 *
 * Returns:
 *  GD_TRUE on success or GD_FALSE
 */
BGD_DECLARE(int) gdAffineTranslate (double dst[6], const double offset_x, const double offset_y)
{
	dst[0] = 1;
	dst[1] = 0;
	dst[2] = 0;
	dst[3] = 1;
	dst[4] = offset_x;
	dst[5] = offset_y;
    return GD_TRUE;
}

/**
 * gdAffineexpansion: Find the affine's expansion factor.
 * @src: The affine transformation.
 *
 * Finds the expansion factor, i.e. the square root of the factor
 * by which the affine transform affects area. In an affine transform
 * composed of scaling, rotation, shearing, and translation, returns
 * the amount of scaling.
 *
 *  GD_TRUE on success or GD_FALSE
 **/
BGD_DECLARE(double) gdAffineExpansion (const double src[6])
{
  return sqrt (fabs (src[0] * src[3] - src[1] * src[2]));
}

/**
 * Function: gdAffineRectilinear
 * Determines whether the affine transformation is axis aligned. A
 * tolerance has been implemented using GD_EPSILON.
 *
 * Parameters:
 * 	m - The affine transformation
 *
 * Returns:
 *  GD_TRUE if the affine is rectilinear or GD_FALSE
 */
BGD_DECLARE(int) gdAffineRectilinear (const double m[6])
{
  return ((fabs (m[1]) < GD_EPSILON && fabs (m[2]) < GD_EPSILON) ||
	  (fabs (m[0]) < GD_EPSILON && fabs (m[3]) < GD_EPSILON));
}

/**
 * Function: gdAffineEqual
 * Determines whether two affine transformations are equal. A tolerance
 * has been implemented using GD_EPSILON.
 *
 * Parameters:
 * 	m1 - The first affine transformation
 * 	m2 - The first affine transformation
 *
 * Returns:
 * 	GD_TRUE on success or GD_FALSE
 */
BGD_DECLARE(int) gdAffineEqual (const double m1[6], const double m2[6])
{
  return (fabs (m1[0] - m2[0]) < GD_EPSILON &&
	  fabs (m1[1] - m2[1]) < GD_EPSILON &&
	  fabs (m1[2] - m2[2]) < GD_EPSILON &&
	  fabs (m1[3] - m2[3]) < GD_EPSILON &&
	  fabs (m1[4] - m2[4]) < GD_EPSILON &&
	  fabs (m1[5] - m2[5]) < GD_EPSILON);
}

${this.title}

Code Editor : gd_matrix.c