static void compute_viewport(window_state_t *state, viewport_t *v) {
    stream_t *stream = state->stream;
    double min;
    double max;
    double unit;

    compute_scale_factor(state, &v->sx, &v->sy);

    v->w = gtk_widget_get_allocated_width(state->drawing_area);
    v->h = gtk_widget_get_allocated_height(state->drawing_area);

    v->uox = 0.0f;
    v->uoy = 0.0f;
    v->udx = v->w;
    v->udy = v->h;
    v->uw = v->w;
    v->uh = v->h;
    v->updx = 1.0f;
    v->updy = 1.0f;

    // Find equivalent for the origin and window size in user coordinates
    cairo_matrix_transform_point(&state->window_to_user_inv, &v->uox, &v->uoy);
    cairo_matrix_transform_point(&state->window_to_user_inv, &v->udx, &v->udy);
    cairo_matrix_transform_distance(&state->window_to_user_inv, &v->uw, &v->uh);
    cairo_matrix_transform_distance(&state->window_to_user_inv, &v->updx, &v->updy);

    v->sox = v->uox;
    v->soy = v->uoy;
    v->sdx = v->udx;
    v->sdy = v->udy;
    v->sw = v->uw;
    v->sh = v->uh;
    v->spdx = v->updx;
    v->spdy = v->updy;

    // Find equivalent for the origin and window size in scaled coordinates
    cairo_matrix_transform_point(&state->user_to_scaled_inv, &v->sox, &v->soy);
    cairo_matrix_transform_point(&state->user_to_scaled_inv, &v->sdx, &v->sdy);
    cairo_matrix_transform_distance(&state->user_to_scaled_inv, &v->sw, &v->sh);
    cairo_matrix_transform_distance(&state->user_to_scaled_inv, &v->spdx, &v->spdy);

    if (v->soy < v->sdy) {
        min = v->soy;
        max = v->sdy;
    } else {
        min = v->sdy;
        max = v->soy;
    }

    // Determine offsets of first wedge in view and first wedge out of view
    unit = state->wedge_height * stream->sample_rate / powf(2.0f, v->sy);
    v->start = floor((min * stream->sample_rate) / unit) * unit;
    v->end = (floor((max * stream->sample_rate) / unit) + 1.0f) * unit;
    v->skip = unit;

    // Offsets of stream
    v->stream_start = 0;
    v->stream_end = stream->n_samples;
}

void
_cairo_matrix_transform_bounding_box (const cairo_matrix_t *matrix,
                                      double *x, double *y,
                                      double *width, double *height)
{
    int i;
    double quad_x[4], quad_y[4];
    double dx1, dy1;
    double dx2, dy2;
    double min_x, max_x;
    double min_y, max_y;

    quad_x[0] = *x;
    quad_y[0] = *y;
    cairo_matrix_transform_point (matrix, &quad_x[0], &quad_y[0]);

    dx1 = *width;
    dy1 = 0;
    cairo_matrix_transform_distance (matrix, &dx1, &dy1);
    quad_x[1] = quad_x[0] + dx1;
    quad_y[1] = quad_y[0] + dy1;

    dx2 = 0;
    dy2 = *height;
    cairo_matrix_transform_distance (matrix, &dx2, &dy2);
    quad_x[2] = quad_x[0] + dx2;
    quad_y[2] = quad_y[0] + dy2;

    quad_x[3] = quad_x[0] + dx1 + dx2;
    quad_y[3] = quad_y[0] + dy1 + dy2;

    min_x = max_x = quad_x[0];
    min_y = max_y = quad_y[0];

    for (i=1; i < 4; i++) {
        if (quad_x[i] < min_x)
            min_x = quad_x[i];
        if (quad_x[i] > max_x)
            max_x = quad_x[i];

        if (quad_y[i] < min_y)
            min_y = quad_y[i];
        if (quad_y[i] > max_y)
            max_y = quad_y[i];
    }

    *x = min_x;
    *y = min_y;
    *width = max_x - min_x;
    *height = max_y - min_y;
}

gfxSize
gfxMatrix::Transform(const gfxSize& size) const
{
    gfxSize ret = size;
    cairo_matrix_transform_distance(CONST_CAIRO_MATRIX(this), &ret.width, &ret.height);
    return ret;
}

/**
 * cpml_vector_transform:
 * @vector:               the destination #CpmlPair struct
 * @matrix: (allow-none): the transformation matrix
 *
 * Shortcut to apply a specific transformation matrix to @vector.
 * It works in a similar way of cpml_pair_transform() but uses
 * cairo_matrix_transform_distance() instead of
 * cairo_matrix_transform_point().
 *
 * Since: 1.0
 **/
void
cpml_vector_transform(CpmlPair *vector, const cairo_matrix_t *matrix)
{
    if (matrix != NULL) {
        cairo_matrix_transform_distance(matrix, &vector->x, &vector->y);
    }
}

OGREnvelope wxGISDisplay::TransformRect(wxRect &rect)
{
	OGREnvelope out;
	double dX1, dX2, dY2, dY1;
	double dWHalf = double(rect.width) / 2;
	double dHHalf = double(rect.height) / 2;
	double dXCenter = rect.x + dWHalf, dYCenter = rect.y + dHHalf;
	DC2World(&dXCenter, &dYCenter);

	cairo_matrix_t InvertMatrix = {m_pDisplayMatrixNoRotate->xx, m_pDisplayMatrixNoRotate->yx, m_pDisplayMatrixNoRotate->xy, m_pDisplayMatrixNoRotate->yy, m_pDisplayMatrixNoRotate->x0, m_pDisplayMatrixNoRotate->y0};
	cairo_matrix_invert(&InvertMatrix);

	cairo_matrix_transform_distance(&InvertMatrix, &dWHalf, &dHHalf);

	dX1 = dXCenter - dWHalf;
	dX2 = dXCenter + dWHalf;
	dY1 = dYCenter - dHHalf;
	dY2 = dYCenter + dHHalf;

    out.MinX = wxMin(dX1, dX2);
    out.MinY = wxMin(dY1, dY2);
    out.MaxX = wxMax(dX1, dX2);
    out.MaxY = wxMax(dY1, dY2);
	return out;
}

static SeedValue
seed_cairo_matrix_transform_distance (SeedContext ctx,
				      SeedObject function,
				      SeedObject this_object,
				      gsize argument_count,
				      const SeedValue arguments[],
				      SeedException *exception)
{
  SeedValue ret[2];
  gdouble x, y;
  cairo_matrix_t m;

  if (argument_count != 3)
    {
      EXPECTED_EXCEPTION("transform_distance", "3 arguments");
    }

  if (!seed_value_to_cairo_matrix (ctx, arguments[0], &m, exception))
    {
      seed_make_exception (ctx, exception, "ArgumentError", "transform_distance needs an array [xx, yx, xy, yy, x0, y0]");
    }
  x = seed_value_to_double (ctx, arguments[1], exception);
  y = seed_value_to_double (ctx, arguments[2], exception);

  cairo_matrix_transform_distance (&m, &x, &y);

  ret[0] = seed_value_from_double (ctx, x, exception);
  ret[1] = seed_value_from_double (ctx, y, exception);

  return seed_make_array (ctx, ret, 2, exception);
}

void uiDrawMatrixTransformSize(uiDrawMatrix *m, double *x, double *y)
{
	cairo_matrix_t c;

	m2c(m, &c);
	cairo_matrix_transform_distance(&c, x, y);
}

static gboolean
_adg_motion_notify_event(GtkWidget *widget, GdkEventMotion *event)
{
    gboolean translating, local_space, global_space;
    cairo_matrix_t map, inverted;

    translating = (event->state & GDK_BUTTON2_MASK) == GDK_BUTTON2_MASK;
    local_space = (event->state & ADG_GTK_MODIFIERS) == 0;
    global_space = (event->state & ADG_GTK_MODIFIERS) == GDK_SHIFT_MASK;

    if (translating && (local_space || global_space) &&
        _adg_get_map(widget, local_space, &map, &inverted)) {
        AdgGtkAreaPrivate *data = adg_gtk_area_get_instance_private((AdgGtkArea *) widget);
        gdouble x = event->x - data->x_event;
        gdouble y = event->y - data->y_event;

        cairo_matrix_transform_distance(&inverted, &x, &y);
        cairo_matrix_translate(&map, x, y);
        data->x_event = event->x;
        data->y_event = event->y;

        _adg_set_map(widget, local_space, &map);

        gtk_widget_queue_draw(widget);

        /* Avoid to chain up the default handler:
         * this event has been grabbed by this function */
        return TRUE;
    }

    if (_ADG_OLD_WIDGET_CLASS->motion_notify_event == NULL)
        return FALSE;

    return _ADG_OLD_WIDGET_CLASS->motion_notify_event(widget, event);
}

void wxGISDisplay::World2DCDist(double* pdX, double* pdY, bool bRotated)
{
	cairo_matrix_t Matrix;
	if(bRotated)
		Matrix = *m_pDisplayMatrix;
	else
		Matrix = *m_pDisplayMatrixNoRotate;
	cairo_matrix_transform_distance(&Matrix, pdX, pdY);
}

static void
_cairo_skia_context_user_to_device_distance (void *abstract_cr,
					     double *dx,
					     double *dy)
{
    cairo_skia_context_t *cr = (cairo_skia_context_t *) abstract_cr;

    cairo_matrix_transform_distance (&cr->matrix, dx, dy);
}

cairo_status_t
_cairo_pen_init (cairo_pen_t *pen, double radius, cairo_gstate_t *gstate)
{
    int i;
    int reflect;
    double  det;

    if (pen->num_vertices) {
	/* XXX: It would be nice to notice that the pen is already properly constructed.
	   However, this test would also have to account for possible changes in the transformation
	   matrix.
	   if (pen->radius == radius && pen->tolerance == tolerance)
	   return CAIRO_STATUS_SUCCESS;
	*/
	_cairo_pen_fini (pen);
    }

    pen->radius = radius;
    pen->tolerance = gstate->tolerance;

    _cairo_matrix_compute_determinant (&gstate->ctm, &det);
    if (det >= 0) {
	reflect = 0;
    } else {
	reflect = 1;
    }

    pen->num_vertices = _cairo_pen_vertices_needed (gstate->tolerance,
						    radius,
						    &gstate->ctm);
    
    pen->vertices = malloc (pen->num_vertices * sizeof (cairo_pen_vertex_t));
    if (pen->vertices == NULL) {
	return CAIRO_STATUS_NO_MEMORY;
    }

    /*
     * Compute pen coordinates.  To generate the right ellipse, compute points around
     * a circle in user space and transform them to device space.  To get a consistent
     * orientation in device space, flip the pen if the transformation matrix
     * is reflecting
     */
    for (i=0; i < pen->num_vertices; i++) {
	double theta = 2 * M_PI * i / (double) pen->num_vertices;
	double dx = radius * cos (reflect ? -theta : theta);
	double dy = radius * sin (reflect ? -theta : theta);
	cairo_pen_vertex_t *v = &pen->vertices[i];
	cairo_matrix_transform_distance (&gstate->ctm, &dx, &dy);
	v->point.x = _cairo_fixed_from_double (dx);
	v->point.y = _cairo_fixed_from_double (dy);
    }

    _cairo_pen_compute_slopes (pen);

    return CAIRO_STATUS_SUCCESS;
}

static int m_cairo_matrix_transform_distance(lua_State * L)
{
	const cairo_matrix_t * matrix = luaL_checkudata(L, 1, MT_NAME_CAIRO_MATRIX);
	double dx = luaL_checknumber(L, 2);
	double dy = luaL_checknumber(L, 3);
	cairo_matrix_transform_distance(matrix, &dx, &dy);
	lua_pushnumber(L, dx);
	lua_pushnumber(L, dy);
	return 2;
}

void wxGISDisplay::DC2WorldDist(double* pdX, double* pdY, bool bRotated)
{
	cairo_matrix_t InvertMatrix;
	if(bRotated)//set center of real window not cache
		InvertMatrix = *m_pDisplayMatrix;
	else
		InvertMatrix = *m_pDisplayMatrixNoRotate;
	cairo_matrix_invert(&InvertMatrix);
	cairo_matrix_transform_distance(&InvertMatrix, pdX, pdY);
}

static int
cairmat_transform_distance (lua_State *L) {
    cairo_matrix_t mat;
    double x = luaL_checknumber(L, 2), y = luaL_checknumber(L, 3);
    from_lua_matrix(L, &mat, 1);
    cairo_matrix_transform_distance(&mat, &x, &y);
    lua_pushnumber(L, x);
    lua_pushnumber(L, y);
    return 2;
}

static PyObject *
matrix_transform_distance (PycairoMatrix *o, PyObject *args) {
  double dx, dy;

  if (!PyArg_ParseTuple(args, "dd:Matrix.transform_distance", &dx, &dy))
    return NULL;

  cairo_matrix_transform_distance (&o->matrix, &dx, &dy);
  return Py_BuildValue("(dd)", dx, dy);
}

static void compute_scale_factor(window_state_t *state, int8_t *sx, int8_t *sy) {
    double ddx = 1.0f;
    double ddy = 1.0f;
    double dfx;
    double dfy;

    // Find equivalent for 1x1 pixel block in user coordinates
    cairo_matrix_transform_distance(&state->window_to_user_inv, &ddx, &ddy);
    cairo_matrix_transform_distance(&state->user_to_scaled_inv, &ddx, &ddy);

    ddx = log2f(fabs(ddx));
    dfx = -floor(ddx);
    if (dfx < 0) {
        *sx = 0;
    } else {
        *sx = dfx;
    }

    ddy = log2f(fabs(ddy));
    dfy = -floor(ddy);
    if (dfy < 0) {
        *sy = 0;
    } else {
        *sy = dfy;
    }

    // At scale 14 the wedge width is 16384, which is the maximum cairo surface width.
    // (the cairo status flips to invalid value after using one of higher width)
    if (*sx > 14) {
        *sx = 14;
    }

    if (*sy > 14) {
        *sy = 14;
    }

    if (DEBUG) {
        fprintf(stderr, "sx: %d (ddx: %.3f), sy: %d (ddy: %.3f)\n", *sx, ddx, *sy, ddy);
    }

    return;
}

cairo_status_t
_cairo_pen_init (cairo_pen_t	*pen,
		 double		 radius,
		 double		 tolerance,
		 const cairo_matrix_t	*ctm)
{
    int i;
    int reflect;

    if (CAIRO_INJECT_FAULT ())
	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

    VG (VALGRIND_MAKE_MEM_UNDEFINED (pen, sizeof (cairo_pen_t)));

    pen->radius = radius;
    pen->tolerance = tolerance;

    reflect = _cairo_matrix_compute_determinant (ctm) < 0.;

    pen->num_vertices = _cairo_pen_vertices_needed (tolerance,
						    radius,
						    ctm);

    if (pen->num_vertices > ARRAY_LENGTH (pen->vertices_embedded)) {
	pen->vertices = _cairo_malloc_ab (pen->num_vertices,
					  sizeof (cairo_pen_vertex_t));
	if (unlikely (pen->vertices == NULL))
	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);
    } else {
	pen->vertices = pen->vertices_embedded;
    }

    /*
     * Compute pen coordinates.  To generate the right ellipse, compute points around
     * a circle in user space and transform them to device space.  To get a consistent
     * orientation in device space, flip the pen if the transformation matrix
     * is reflecting
     */
    for (i=0; i < pen->num_vertices; i++) {
	cairo_pen_vertex_t *v = &pen->vertices[i];
	double theta = 2 * M_PI * i / (double) pen->num_vertices, dx, dy;
	if (reflect)
	    theta = -theta;
	dx = radius * cos (theta);
	dy = radius * sin (theta);
	cairo_matrix_transform_distance (ctm, &dx, &dy);
	v->point.x = _cairo_fixed_from_double (dx);
	v->point.y = _cairo_fixed_from_double (dy);
    }

    _cairo_pen_compute_slopes (pen);

    return CAIRO_STATUS_SUCCESS;
}

/**
 * Convert a unit array to a C array of doubles representing NPC values.
 */
static void
unit_array_to_npc(double *result, grid_context_t *gr, char dim, 
                  const unit_array_t *u) 
{
    grid_viewport_node_t *node = gr->current_node;
    double dev_x_per_npc, dev_y_per_npc;
    dev_x_per_npc = dev_y_per_npc = 1.0;
    cairo_matrix_transform_distance(node->npc_to_dev, &dev_x_per_npc, 
                                                      &dev_y_per_npc);

    double x_ntv, y_ntv, w_ntv, h_ntv;
    x_ntv = y_ntv = 0.0;
    w_ntv = h_ntv = 1.0;
    cairo_matrix_transform_point(node->npc_to_ntv, &x_ntv, &y_ntv);
    cairo_matrix_transform_distance(node->npc_to_ntv, &w_ntv, &h_ntv);

    cairo_font_extents_t font_extents;
    cairo_font_extents(gr->cr, &font_extents);

    cairo_text_extents_t em_extents;
    cairo_text_extents(gr->cr, "m", &em_extents);

    double dev_per_npc, o_ntv, size_ntv;
    dev_per_npc = o_ntv = size_ntv = 0.0;

    if (dim == 'x') {
        dev_per_npc = dev_x_per_npc;
        o_ntv = x_ntv;
        size_ntv = w_ntv;
    } else if (dim == 'y') {
        dev_per_npc = dev_y_per_npc;
        o_ntv = y_ntv;
        size_ntv = h_ntv;
    } else {
        fprintf(stderr, "Warning: unknown dimension '%c'\n", dim);
    }

    unit_array_to_npc_helper(result, dev_per_npc, font_extents.height,
                             em_extents.width, o_ntv, size_ntv, 
                             unit_array_size(u), u);
}

static gboolean
context_is_unscaled (cairo_t *cr)
{
  cairo_matrix_t matrix;
  gdouble x, y;

  x = y = 1;
  cairo_get_matrix (cr, &matrix);
  cairo_matrix_transform_distance (&matrix, &x, &y);

  return x == 1 && y == 1;
}

static gdouble
_mech_surface_get_axis_scale (cairo_matrix_t *matrix,
                              MechAxis        axis)
{
  gdouble distance_x, distance_y;

  distance_x = (axis == MECH_AXIS_X) ? 1 : 0;
  distance_y = (axis == MECH_AXIS_Y) ? 1 : 0;
  cairo_matrix_transform_distance (matrix, &distance_x, &distance_y);

  return sqrt ((distance_x * distance_x) + (distance_y * distance_y));
}