rotate.cpp

Go to the documentation of this file.

#include <math.h>
#include "image.h"
#include "aux.h"
#include "line.h"
#include "runtime.h"

Value * Runtime::straighten(Value * image, Value * line)
{
  // input checks
  if (image==NULL)  return NULL;
  if (line==NULL) return NULL;
  if (typeid(*image)!=typeid(ImageValue)) return NULL;
  if (typeid(*line)!=typeid(LineValue)) return NULL;
  ImageValue * I = (ImageValue*)image;
  LineValue * l = (LineValue*)line;

  // we rotate the image data, afterwards we reestablish the
  // center and scaling factors
  
  // determine angle of line & normalize
  DirectPoint A = I->ocsToDcs(l->a);
  DirectPoint B = I->ocsToDcs(l->b);
  double da = B.x - A.x;
  double db = B.y - A.y;
  double angle = atan2(db,da);
  while(angle<0) angle+=2*M_PI;
  while(angle>=M_PI/4) angle-=M_PI/2;

  // rotate the corners
  int as = I->width_direct();
  int bs = I->height_direct();
  double cas = (double)as/2.0;
  double cbs = (double)bs/2.0;
  
  int tl_x, tl_y;
  int tr_x, tr_y;
  int bl_x, bl_y;
  int br_x, br_y;
  rotate(0, 0, cas,cbs,tl_x,tl_y,-angle);
  rotate(as,0, cas,cbs,tr_x,tr_y,-angle);
  rotate(0, bs,cas,cbs,bl_x,bl_y,-angle);
  rotate(as,bs,cas,cbs,br_x,br_y,-angle);
  int xs = max(tr_x,br_x)-min(tl_x,bl_x);
  int ys = max(br_y,bl_y)-min(tl_y,tr_y);
  // create output image
  ImageValue *O=new ImageValue(xs,ys,I->channelcount());
  O->clear(I->maxz());
  //scan through output area
  double cxs = (double)xs/2.0;
  double cys = (double)ys/2.0;
  for(int x = 0 ; x < xs ; x++)
    for(int y = 0 ; y < ys ; y++)
      {
        int a,b;
        rotate(x-cxs,y-cys,0,0,a,b,angle);
        a+=cas;
        b+=cbs;
        if (a<0) continue;
        if (a>=as) continue;
        if (b<0) continue;
        if (b>=bs) continue;
        for(int c = 0 ; c < I->channelcount();c++)
          O->set_direct(x,y,c,I->get_direct(a,b,c));
      }
  // calculate the new center;
  // first determine the position of the old center
  PointValue new_center;
  rotate(I->center.x-cas,I->center.y-cbs,0,0,
         new_center.x,new_center.y,-angle);
  // this is the rotation of the direct points
  O->center.x = new_center.x + cxs;
  O->center.y = new_center.y + cys;
  // calculate the new zoom factors
  // the scaling factor means: how many pixels per unit. 
  return O;
}

Value * Runtime::straighten(vector<Value*> v)
{
  if (v.size()!=2) return NULL;
  return straighten(v[0],v[1]);
}

---