m_transform.c

Go to the documentation of this file.

/* gEDA - GPL Electronic Design Automation
 * libgeda - gEDA's library
 * Copyright (C) 1998-2010 Ales Hvezda
 * Copyright (C) 1998-2010 gEDA Contributors (see ChangeLog for details)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <config.h>
#include <math.h>
#include <libgeda_priv.h>

void m_transform_combine(TRANSFORM *result, TRANSFORM *a, TRANSFORM *b )
{
  g_return_if_fail(result!=NULL);
  g_return_if_fail(a!=NULL);
  g_return_if_fail(b!=NULL);

  result->m[0][0] = a->m[0][0] * b->m[0][0] + a->m[0][1] * b->m[1][0];
  result->m[0][1] = a->m[0][0] * b->m[0][1] + a->m[0][1] * b->m[1][1];
  result->m[0][2] = a->m[0][0] * b->m[0][2] + a->m[0][1] * b->m[1][2] + a->m[0][2];
  result->m[1][0] = a->m[1][0] * b->m[0][0] + a->m[1][1] * b->m[1][0];
  result->m[1][1] = a->m[1][0] * b->m[0][1] + a->m[1][1] * b->m[1][1];
  result->m[1][2] = a->m[1][0] * b->m[0][2] + a->m[1][1] * b->m[1][2] + a->m[1][2];
}

void m_transform_init(TRANSFORM *transform)
{
  g_return_if_fail(transform!=NULL);

  transform->m[0][0] = 1;
  transform->m[0][1] = 0;
  transform->m[0][2] = 0;
  transform->m[1][0] = 0;
  transform->m[1][1] = 1;
  transform->m[1][2] = 0;
}

void m_transform_invert(TRANSFORM *transform, TRANSFORM *inverse)
{
  gdouble d;

  g_return_if_fail(transform!=NULL);
  g_return_if_fail(inverse!=NULL);

  d = transform->m[0][0]*transform->m[1][1] - transform->m[1][0]*transform->m[0][1];

  inverse->m[0][0] =  transform->m[1][1] / d;
  inverse->m[0][1] = -transform->m[0][1] / d;
  inverse->m[0][2] =  ( transform->m[0][1]*transform->m[1][2] - transform->m[1][1]*transform->m[0][2] ) / d;
  inverse->m[1][0] = -transform->m[1][0] / d;
  inverse->m[1][1] =  transform->m[0][0] / d;
  inverse->m[1][2] = -( transform->m[0][0]*transform->m[1][2] - transform->m[1][0]*transform->m[0][2] ) / d;
}

void m_transform_line(TRANSFORM *transform, LINE *line)
{
  g_return_if_fail(transform!=NULL);
  g_return_if_fail(line!=NULL);

  m_transform_point(transform, &(line->x[0]), &(line->y[0]));
  m_transform_point(transform, &(line->x[1]), &(line->y[1]));
}

void m_transform_lines(TRANSFORM *transform, GArray *lines)
{
  gint index;

  g_return_if_fail(transform!=NULL);
  g_return_if_fail(lines!=NULL);

  for (index=0; index<lines->len; index++) {
    LINE *line = &g_array_index(lines, LINE, index);
    m_transform_line(transform, line);
  }
}

void m_transform_point(TRANSFORM *transform, gint *x, gint *y)
{
  gdouble tx;
  gdouble ty;

  g_return_if_fail(transform!=NULL);
  g_return_if_fail(x!=NULL);
  g_return_if_fail(y!=NULL);

  tx = *x;
  ty = *y;

  *x = round(transform->m[0][0] * tx + transform->m[0][1] * ty + transform->m[0][2]);
  *y = round(transform->m[1][0] * tx + transform->m[1][1] * ty + transform->m[1][2]);
}

void m_transform_points(TRANSFORM *transform, GArray *points)
{
  gint index;

  g_return_if_fail(transform!=NULL);
  g_return_if_fail(points!=NULL);

  for (index=0; index<points->len; index++) {
    sPOINT *point = &g_array_index(points, sPOINT, index);
    m_transform_point(transform, &(point->x), &(point->y));
  }
}

void m_transform_rotate(TRANSFORM *transform, gdouble angle)
{
  gdouble r = G_PI*angle/180.0;
  gdouble c = cos(r);
  gdouble s = sin(r);
  TRANSFORM temp;

  g_return_if_fail(transform!=NULL);

  temp = *transform;

  transform->m[0][0] = temp.m[0][0] *  c + temp.m[0][1] * s;
  transform->m[0][1] = temp.m[0][0] * -s + temp.m[0][1] * c;
  transform->m[1][0] = temp.m[1][0] *  c + temp.m[1][1] * s;
  transform->m[1][1] = temp.m[1][0] * -s + temp.m[1][1] * c;
}

void m_transform_scale(TRANSFORM *transform, gdouble factor)
{
  g_return_if_fail(transform!=NULL);
  g_return_if_fail(factor!=0);

  transform->m[0][0] *= factor;
  transform->m[0][1] *= factor;
  transform->m[1][0] *= factor;
  transform->m[1][1] *= factor;
}

void m_transform_translate(TRANSFORM *transform, gdouble dx, gdouble dy)
{
  g_return_if_fail(transform!=NULL);

  transform->m[0][2] += dx;
  transform->m[1][2] += dy;
}