image.cpp

Go to the documentation of this file.

#include <qpainter.h>
#include <qfiledialog.h>
#include "runtime.h"
#include "text.h"
#include "image.h"

Data ImageValue::getSaveDescription(QString prefix)
{
  QString fn = prefix+"."+QString::number((ulong)(void*)this)+".dat";
  DataBinner::write(data,fn);
  Token T;
  T["type"]= Symbol("image");
  T["filename"]=String(fn);
  T["center"]=center.getSaveDescription();
  T["scale"]=scale.getSaveDescription(prefix);
  return T;
};

ImageValue::ImageValue(Token desc) : Value()
{
  String filename = desc["filename"];
  QString fn = filename;
  data = DataBinner::read_file(fn);
  center = DirectPoint(desc["center"]);
  scale  = PointValue(desc["scale"]);
}

ImageValue::ImageValue(int xs, int ys, int c) : data(c,xs,ys)
{
  center.x = xs / 2;
  center.y = ys / 2;
  scale.y = scale.x = max(xs,ys)/2.0;
}

ImageValue * ImageValue::deepCopy()
{
  int xs = width_direct();
  int ys = height_direct();
  int cs = channelcount();
  ImageValue * result= new ImageValue(width_direct(),height_direct(),channelcount());
  for(int c = 0 ; c < cs ; c ++)
    for(int x = 0 ; x < xs ; x++)
      for(int y = 0 ; y < ys ; y++)
        result->set_direct(x,y,c,
                           get_direct(x,y,c));
  result->center = center;
  result->scale = scale;
  return result;
}

ImageValue::ImageValue(PointValue tl, PointValue br, PointValue res, int c) 
  : data(c,(int)((br.x-tl.x)*res.x),(int)((br.y-tl.y)*res.y)),
    scale(res)
{
  center.x = (-tl.x)*scale.x;
  center.y = (-tl.y)*scale.y;
}

ImageValue::ImageValue(QImage &i) : Value()
{
  loadImage(i);
};

ImageValue::ImageValue(QString str) : Value()
{                      
  loadImage(str);
};

void ImageValue::loadImage(QString str)
{
  QImage i(str);
  loadImage(i);
}

bool ImageValue::equals_same_type(Value * other)
{
  ImageValue * o = (ImageValue*)other;
  return (data == o->data)
    && (center == o->center)
    && (scale.equals(o->scale));
};

void ImageValue::loadImage(QImage&I1)
{
  QImage I=I1.convertDepth(32);
  bool gray = I.isGrayscale();
  int w = I.width();
  int h = I.height();
  center.x = w / 2;
  center.y = h / 2;
  scale.y = scale.x = max(w,h)/2.0;
  data = Image(gray ? 1 : 3,I.width(),I.height());
  if (gray)
    for(Image::positions pos(data); pos.more() ; ++pos)
      {
        QRgb G = I.pixel(pos[imagex],pos[imagey]);
        pos=qGray(G);
      }
  else
    for(Image::vector_positions pos(data,imagex,imagey); pos.more() ; ++pos)
      {
        QRgb G = I.pixel(pos[imagex],pos[imagey]);
        Image::vector & v=pos;
        v[0]=qRed(G);
        v[1]=qGreen(G);
        v[2]=qBlue(G);
      }
}

int axe_fatiness(double x)
{
  if (x<1.01 && x>0.99) return 3;
  if (x>-1.01 && x<-0.99) return 3;
  if (x>-0.01 && x<0.01) return 1;
  return 2;
}

QImage ImageValue::getQImage(bool draw_axes)
{
  double loz = minz();
  double hiz = maxz();
  double diz = hiz-loz;
  if (diz==0) diz=1;
  QImage result(data.size(imagex),data.size(imagey),32);
  if (data.size(channels)==1)
    for(Image::matrix_positions pos(data,imagey); pos.more() ; ++pos)
      {
        QRgb * scanline = (QRgb*)result.scanLine(pos[imagey]);
        for(ColorLine::ordered_vectors xy(pos,colorlinex); xy.more() ; ++xy, ++scanline)
          {
            Image::value g = xy;
            g-=loz;
            g/=diz;
            g*=255.0;
            *scanline=qRgb((int)g,(int)g,(int)g);
          }
      }
  else
    for(Image::matrix_positions y(data,imagey); y.more() ; ++y)
      {
        QRgb * scanline = (QRgb*)result.scanLine(y[imagey]);
        for(ColorLine::ordered_vectors xy(y,colorlinex); xy.more() ; ++xy, ++scanline)
          {
            Image::vector &c = xy;
            float r = c[0];
            float g = c[1];
            float b = c[2];
            
            r-=loz;
            r/=diz;
            r*=255.0;

            g-=loz;
            g/=diz;
            g*=255.0;
            
            b-=loz;
            b/=diz;
            b*=255.0;
            
            int R = (int)r, G = (int)g, B = (int)b;
            *scanline=qRgb(R,G,B);
          }
      }

  // draw the axes
  /*  if (draw_axes)
    {
      int xs = width_direct();
      int ys = height_direct();
      for(double x = -1.0 ; x <= 1.0 ; x+=0.1)
        for(double y = -1.0 ; y <= 1.0 ; y+=0.1)
          {
            DirectPoint dp=ocsToDcs(PointValue(x,y));
            if (dp.y>=0 && dp.y<ys)
              {
                QRgb * scanline = (QRgb*)result.scanLine(dp.y);
                int delta = axe_fatiness(y);
                for(int x = 0 ; x < xs ; x+=delta) scanline[x]=qRgb(0,0,0);
              }
            if (dp.x>=0 && dp.x<xs)
              {
                int delta = axe_fatiness(x);
                for(int y = 0 ; y < ys ; y+=delta) 
                  {
                    QRgb * scanline = (QRgb*)result.scanLine(y);
                    scanline[dp.x]=qRgb(0,0,0);
                  }
              }
          }
    }
  */

  return result;
}

void ImageValue::drawAxes(QImage *onto)
{
  int as = onto->width();
  int bs = onto->height();
  int xs = width_direct();
  int ys = height_direct();

  QPen central(Qt::red);
  central.setStyle(Qt::SolidLine);

  QPen sides(Qt::blue);
  sides.setStyle(Qt::SolidLine);

  QPen units(Qt::red);
  units.setStyle(Qt::DashLine);
  
  double dx,dy;
  if (as<100 || bs<100)
    {
      dx = 1.0;
      dy = 1.0;
    }
  else
    {
      dx = 0.1;
      dy = 0.1;
    }
  
  // calculate the size of a pixel in the paintdevice
  double pixel_width =  (double)as/(double)xs;
  double pixel_height = (double)bs/(double)ys;
  pixel_width/=2;
  pixel_height/=2;
  pixel_width+=0.5;
  pixel_height+=0.5;
  QRgb c;
  for(double x = -10.0 ; x <= 10.0 ; x+=dx)
    for(double y = -10.0 ; y <= 10.0 ; y+=dy)
      {
        DirectPoint dp=ocsToDcs(PointValue(x,y));
        // dp refers to the position in the image
        int a = pixel_width  + dp.x*as/xs;
        int b = pixel_height + dp.y*bs/ys;
        // a and b now refers to the coordinate in the paintdevice
        if (a>=0 && a<as)
          {
            int s = axe_fatiness(x);
            if (s==1) c = qRgb(255,0,0);
            else if (s==2) c = qRgb(0,0,255);
            else c = qRgb(255,128,128);
            
            for(int y = 0 ; y < bs ; y++)
              {
                QRgb * scanline = (QRgb*)onto->scanLine(y);
                scanline[a]=c;
              }
          }
        
        if (b>=0 && b<bs)
          {
            int s = axe_fatiness(y);
            if (s==1) c = qRgb(255,0,0);
            else if (s==2) c = qRgb(0,0,255);
            else c = qRgb(255,128,128);
            
            QRgb * scanline = (QRgb*)onto->scanLine(b);
            for(int x = 0 ; x < as ; x++)
              scanline[x]=c;
          }
      }
}

void ImageValue::drawLegend(QPainter * painter, int as, int bs)
{
  // now we need to print the extrema
  QString hi = QString("max: ")+QString::number(maxz());
  QString lo = QString("min: ")+QString::number(minz());
  QString me = QString("median: ")+QString::number(medianz());
  QString t = hi+"\n"+me+"\n"+lo;
  QRect bounds = 
    painter->boundingRect(0,0,640,480,Qt::AlignBottom|Qt::AlignLeft,t);
  if (bounds.width()>as ||
      bounds.height()>bs/4) return;
  painter->setPen(Qt::white);
  painter->drawText(2,-2,as,bs,Qt::AlignBottom|Qt::AlignLeft,t);
  painter->setPen(Qt::black);
  painter->drawText(0,0,as,bs,Qt::AlignBottom|Qt::AlignLeft,t);
}

double ImageValue::maxz()
{
  if (data.empty()) return 0;
  double mz = get_direct(0,0,0);
  for(Image::values v(data); v.more(); ++v)
    if (v>mz) mz=v;
  return mz;
}

double ImageValue::minz()
{
  if (data.empty()) return 0;
  double mz = get_direct(0,0,0);
  for(Image::values v(data); v.more(); ++v)
    if (v<mz) mz=v;
  return mz;
}

int float_cmp(const void * a , const void * b)
{
  float * A = (float*)a;
  float * B = (float*)b;
  float c = *A;
  float d = *B;
  if (c<d) return -1;
  if (c>d) return 1;
  return 0;
}

double ImageValue::medianz()
{
  if (data.empty()) return 0;
  int size = width_direct()*height_direct()*channelcount();
  float * sort = (float*)malloc(sizeof(float)*size);
  assert(sort);
  int p = 0;
  for(Image::values it(data) ; it.more(); it++)
    sort[p++]=*it;
  qsort(sort,size,sizeof(float),float_cmp);
  float result = sort[size/2];
  free(sort);
  return result;
}

Value * Runtime::image(QString filename)
{
  return new ImageValue(filename);
}

Value * Runtime::image(Value * what)
{
  if (what==NULL) return NULL;
  if (typeid(*what)!=typeid(TextValue)) return NULL;
  TextValue * t = (TextValue*)what;
  return image(t->getText());
}

Value * Runtime::image()
{
  QString s = QFileDialog::getOpenFileName(".",
                                           "Images (*.png *.xpm *.jpg)",
                                           NULL,
                                           "Select file to open",
                                           "Choose a file");
  if(s.isEmpty()) return NULL;
  return image(s);
}

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

DirectPoint ImageValue::ocsToDcs(const PointValue& in)
{
  DirectPoint out;
  out.copyFrom(in * scale);
  out+=center;
  return out;
}

PointValue ImageValue::dcsToOcs(const DirectPoint& in)
{
  PointValue out=(PointValue)(in-center);
  out/=scale;
  return out;
}

void ImageValue::negate()
{
  for(Image::values it(data); it.more() ; it++)
    *it = -it;
}

void ImageValue::addFrom(ImageValue * i)
{
  int c1 = channelcount();
  int c2 = i->channelcount();
  if (c1==c2)
    {
      //      printf("Ranging from %g to %g step %g\n",i->left(),i->right(),horiz());
      // we calculate the top left direct coordinate and bottom right direct coordinate
      DirectPoint tl = ocsToDcs(i->topleft());
      DirectPoint br = ocsToDcs(i->bottomright());
      DirectPoint cr = tl;
      for(cr.x=tl.x; cr.x <= br.x ; cr.x++)
        for(cr.y=tl.y ; cr.y <= br.y ; cr.y++)
          {
            DirectPoint from = i->ocsToDcs(dcsToOcs(cr));
            if (!outside(cr) && !i->outside(from))
              for(int c = 0 ; c < c1 ; c++)
                {
                  double v1 = get_direct(cr.x,cr.y,c);
                  double v2 = i->get_direct(from.x,from.y,c);
                  set_direct(cr.x,cr.y,c,v1+v2);
                }
          }
    }
  else 
    assert(0);
}

---