narray 0.5.9.4

data/src/narray.def

@@ -0,0 +1,29 @@
+EXPORTS
+Init_narray
+na_sizeof
+na_make_object
+na_make_scalar
+na_make_empty
+na_get_typecode
+na_clear_data
+na_clone
+na_fill
+na_copy_nary
+na_to_array
+na_ary_to_nary
+na_object_type
+na_cast_object
+na_cast_unless_narray
+na_cast_unless_array
+na_upcast_object
+na_dup_w_type
+na_change_type
+na_upcast_type
+na_to_narray
+na_aset
+na_aref
+na_slice
+na_count_true
+na_count_false
+na_aref_mask
+na_aset_mask

data/src/narray.h

@@ -0,0 +1,170 @@
+/*
+  narray.h
+  Numerical Array Extention for Ruby
+    (C) Copyright 1999-2003 by Masahiro TANAKA
+
+  This program is free software.
+  You can distribute/modify this program
+  under the same terms as Ruby itself.
+  NO WARRANTY.
+*/
+#ifndef NARRAY_H
+#define NARRAY_H
+
+#include <math.h>
+
+#include "narray_config.h"
+
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#define NARRAY_VERSION "0.5.9p4"
+#define NARRAY_VERSION_CODE 594
+
+/*
+  Data types used in NArray :
+  Please modify these types if your system has any different type.
+*/
+#ifndef HAVE_U_INT8_T
+typedef unsigned char          u_int8_t; /* NA_BYTE */
+#endif
+
+#ifndef HAVE_INT16_T
+# if SIZEOF_SHORT == 2
+typedef short                  int16_t;  /* NA_SINT */
+# else
+---->> Please define int16_t manually because sizeof(short) != 2. <<----
+# endif
+#endif /* HAVE_INT16_T */
+
+#ifndef HAVE_INT32_T
+# if SIZEOF_LONG == 4
+typedef long                   int32_t;  /* NA_LINT */
+# else
+#  if SIZEOF_INT == 4
+typedef int                    int32_t;  /* NA_LINT */
+#  else
+---->> Please define int32_t manually because sizeof(long) != 4. <<----
+#  endif
+# endif
+#endif /* HAVE_INT32_T */
+
+#ifndef HAVE_U_INT32_T
+# if SIZEOF_LONG == 4
+typedef unsigned long                   u_int32_t;  /* NA_LINT */
+# else
+#  if SIZEOF_INT == 4
+typedef unsigned int                    u_int32_t;  /* NA_LINT */
+#  else
+---->> Please define u_int32_t manually because sizeof(long) != 4. <<----
+#  endif
+# endif
+#endif /* HAVE_U_INT32_T */
+
+typedef struct { float r,i; }  scomplex;
+typedef struct { double r,i; } dcomplex;
+
+enum NArray_Types {
+  NA_NONE,
+  NA_BYTE,	/* 1 */
+  NA_SINT,	/* 2 */
+  NA_LINT,	/* 3 */
+  NA_SFLOAT,	/* 4 */
+  NA_DFLOAT,	/* 5 */
+  NA_SCOMPLEX,	/* 6 */
+  NA_DCOMPLEX,	/* 7 */
+  NA_ROBJ,	/* 8 */
+  NA_NTYPES	/* 9 */
+};
+
+/* struct for Numerical Array */
+struct NARRAY {
+  int    rank;	  /* # of dimension */
+  int    total;	  /* # of total element */
+  int    type;	  /* data type */
+  int   *shape;
+  char  *ptr;	  /* pointer to data */
+  VALUE  ref;	  /* NArray object wrapping this structure */
+};
+
+#ifndef NARRAY_C
+extern VALUE cNArray;
+
+extern const int na_sizeof[NA_NTYPES+1];
+#endif
+
+#define NA_MAX_RANK 15
+
+#define GetNArray(obj,var)  Data_Get_Struct(obj, struct NARRAY, var)
+#define IsNArray(obj) (rb_obj_is_kind_of(obj,cNArray)==Qtrue)
+
+#define NA_PTR(a,p)    ((a)->ptr+(p)*na_sizeof[(a)->type])
+#define NA_STRUCT(val) ((struct NARRAY*)DATA_PTR(val))
+#define NA_PTR_TYPE(val,type) (type)(((struct NARRAY*)DATA_PTR(val))->ptr)
+#define NA_RANK(val)   (((struct NARRAY*)DATA_PTR(val))->rank)
+#define NA_TYPE(val)   (((struct NARRAY*)DATA_PTR(val))->type)
+#define NA_TOTAL(val)  (((struct NARRAY*)DATA_PTR(val))->total)
+#define NA_SHAPE0(val) (((struct NARRAY*)DATA_PTR(val))->shape[0])
+#define NA_SHAPE1(val) (((struct NARRAY*)DATA_PTR(val))->shape[1])
+
+#define NA_IsNArray(obj) \
+  (rb_obj_is_kind_of(obj,cNArray)==Qtrue)
+#define NA_IsArray(obj) \
+  (TYPE(obj)==T_ARRAY || rb_obj_is_kind_of(obj,cNArray)==Qtrue)
+#define NA_IsROBJ(d) ((d)->type==NA_ROBJ)
+#define NA_IsINTEGER(a) \
+  ((a)->type==NA_BYTE || (a)->type==NA_SINT || (a)->type==NA_LINT )
+#define NA_IsCOMPLEX(a) \
+  ((a)->type==NA_SCOMPLEX || (a)->type==NA_DCOMPLEX)
+#define NA_MAX(a,b) (((a)>(b))?(a):(b))
+#define NA_SWAP(a,b,tmp) {(tmp)=(a);(a)=(b);(b)=(tmp);}
+
+#define na_class_dim(klass) NUM2INT(rb_const_get(klass, na_id_class_dim))
+
+#define NUM2REAL(v)  NUM2DBL( rb_funcall((v),na_id_real,0) )
+#define NUM2IMAG(v)  NUM2DBL( rb_funcall((v),na_id_imag,0) )
+
+#define NA_ALLOC_SLICE(slc,nc,shp,np) \
+{ slc = (struct slice*)xmalloc( sizeof(struct slice)*(nc) + \
+				sizeof(int)*(np) );\
+  shp = (int*)&( (slc)[nc] ); }
+
+
+/* Function Prototypes */
+
+/* narray.c */
+VALUE na_make_object(int type, int rank, int *shape, VALUE klass);
+VALUE na_make_scalar(VALUE obj, int type);
+VALUE na_make_empty(int type, VALUE klass);
+int   na_get_typecode(VALUE v);
+void  na_clear_data(struct NARRAY *ary);
+VALUE na_clone(VALUE self);
+VALUE na_fill(VALUE self, volatile VALUE obj);
+void  na_copy_nary(struct NARRAY *dst, struct NARRAY *src);
+
+/* na_array.c */
+VALUE na_to_array(VALUE obj);
+VALUE na_make_inspect(VALUE self);
+VALUE na_ary_to_nary(VALUE ary, VALUE klass);
+int   na_object_type(VALUE v);
+
+VALUE na_cast_object(VALUE obj, int type);
+VALUE na_cast_unless_narray(VALUE obj, int type);
+VALUE na_cast_unless_array(VALUE obj, int type);
+VALUE na_upcast_object(VALUE obj, int type);
+VALUE na_dup_w_type(VALUE obj, int type);
+VALUE na_change_type(VALUE obj, int type);
+VALUE na_upcast_type(VALUE obj, int type);
+VALUE na_to_narray(VALUE obj);
+
+/* na_index.c */
+VALUE na_aset(int argc, VALUE *argv, VALUE self);
+VALUE na_aref(int argc, VALUE *argv, VALUE self);
+VALUE na_slice(int argc, VALUE *argv, VALUE self);
+VALUE na_count_true(VALUE self);
+VALUE na_count_false(VALUE self);
+VALUE na_aref_mask(VALUE self, VALUE mask);
+void  na_aset_mask(VALUE self, VALUE mask, VALUE v);
+
+#endif /* ifndef NARRAY_H */

data/src/narray_local.h

@@ -0,0 +1,210 @@
+/*
+  narray_local.h
+  Numerical Array Extention for Ruby
+    (C) Copyright 1999-2003 by Masahiro TANAKA
+
+  This program is free software.
+  You can distribute/modify this program
+  under the same terms as Ruby itself.
+  NO WARRANTY.
+*/
+
+typedef int32_t na_index_t;
+
+struct slice {
+  char *p;   	/* pointer to data		--- used in loop */
+  int n;       	/* n of indices of this rank */
+  int pstep;   	/* = step * stride * elmsz	--- set in na_init_slice */ 
+  int pbeg;    	/* = beg * stride * elmsz	--- set in na_init_slice */
+  int stride;  	/* = shape[0]*shape[1]*...*shape[r-1]
+						--- set in na_init_slice */
+  int step;
+  int beg;
+  na_index_t *idx;    	/* NULL if normal step */
+};
+
+typedef void (*na_setfunc_t[NA_NTYPES][NA_NTYPES]) ();
+typedef void (*na_func_t[NA_NTYPES]) ();
+typedef void (*na_ufunc_t[NA_NTYPES]) ();
+typedef void (*na_bifunc_t[NA_NTYPES]) ();
+typedef void (*na_mathfunc_t[NA_NTYPES]) ();
+typedef int  (*na_sortfunc_t[NA_NTYPES]) (const void *, const void *);
+
+/* function arrays */
+extern na_setfunc_t SetFuncs;
+extern na_ufunc_t  SwpFuncs;
+extern na_ufunc_t  H2NFuncs;
+extern na_ufunc_t  H2VFuncs;
+extern na_ufunc_t  NegFuncs;
+extern na_ufunc_t  RcpFuncs;
+extern na_ufunc_t  AbsFuncs;
+extern na_ufunc_t  RealFuncs;
+extern na_ufunc_t  ImagFuncs;
+extern na_ufunc_t  AnglFuncs;
+extern na_ufunc_t  ImagMulFuncs;
+extern na_ufunc_t  ConjFuncs;
+extern na_ufunc_t  FloorFuncs;
+extern na_ufunc_t  CeilFuncs;
+extern na_ufunc_t  RoundFuncs;
+extern na_ufunc_t  ToStrFuncs;
+extern na_ufunc_t  InspFuncs;
+extern na_ufunc_t  IndGenFuncs;
+extern na_ufunc_t  AddUFuncs;
+extern na_ufunc_t  SbtUFuncs;
+extern na_ufunc_t  MulUFuncs;
+extern na_ufunc_t  DivUFuncs;
+extern na_bifunc_t AddBFuncs;
+extern na_bifunc_t SbtBFuncs;
+extern na_bifunc_t MulBFuncs;
+extern na_bifunc_t DivBFuncs;
+extern na_bifunc_t MulAddFuncs;
+extern na_bifunc_t MulSbtFuncs;
+extern na_bifunc_t ModBFuncs;
+extern na_bifunc_t BAnFuncs;
+extern na_bifunc_t BOrFuncs;
+extern na_bifunc_t BXoFuncs;
+extern na_ufunc_t  BRvFuncs;
+extern na_bifunc_t ImgSetFuncs;
+extern na_setfunc_t PowFuncs;
+extern na_bifunc_t atan2Funcs;
+extern na_bifunc_t CmpFuncs;
+extern na_bifunc_t EqlFuncs;
+extern na_ufunc_t  AndFuncs;
+extern na_ufunc_t  Or_Funcs;
+extern na_ufunc_t  XorFuncs;
+extern na_ufunc_t  NotFuncs;
+extern na_ufunc_t  MinFuncs;
+extern na_ufunc_t  MaxFuncs;
+extern na_sortfunc_t SortFuncs;
+extern na_sortfunc_t SortIdxFuncs;
+extern na_bifunc_t RefMaskFuncs;
+extern na_bifunc_t SetMaskFuncs;
+
+/* variables */
+
+extern VALUE rb_mNMath;
+extern ID na_id_beg, na_id_end, na_id_exclude_end;
+extern ID na_id_minus, na_id_abs, na_id_power;
+extern ID na_id_compare, na_id_and, na_id_or;
+extern ID na_id_equal;
+extern ID na_id_class_dim;
+extern ID na_id_add, na_id_sbt, na_id_mul, na_id_div, na_id_mod;
+extern ID na_id_real, na_id_imag;
+extern ID na_id_coerce_rev;
+extern ID na_id_new;
+
+extern const int na_upcast[NA_NTYPES][NA_NTYPES];
+extern const int na_no_cast[NA_NTYPES];
+extern const int na_cast_real[NA_NTYPES];
+extern const int na_cast_comp[NA_NTYPES];
+extern const int na_cast_round[NA_NTYPES];
+extern const int na_cast_byte[NA_NTYPES];
+
+extern const char *na_typestring[];
+
+extern VALUE cNArrayScalar, cComplex;
+
+/* narray.c */
+VALUE na_newdim_ref(int argc, VALUE *argv, VALUE self);
+
+/* na_func.c */
+int  na_max3(int a, int b, int c);
+void na_shape_max3(int ndim, int *max_shp, int *shp1, int *shp2, int *shp3);
+void na_shape_copy( int ndim, int *shape, struct NARRAY *a );
+
+void na_init_slice(struct slice *s, int rank, int *shape, int elmsz);
+void na_set_slice_1obj(int ndim, struct slice *slc, int *shape);
+int  na_set_slice_3obj( int ndim,
+			struct slice *s1, struct slice *s2, struct slice *s3,
+			int *shp1, int *shp2, int *shp3, int *shape );
+void na_loop_general(struct NARRAY *a1, struct NARRAY *a2,
+		     struct slice *s1, struct slice *s2, void (*func)());
+void na_loop_index_ref(struct NARRAY *a1, struct NARRAY *a2,
+		       struct slice *s1, struct slice *s2, void (*func)());
+
+/* na_index.c */
+void  na_aset_slice(struct NARRAY *dst, struct NARRAY *src, struct slice *s1);
+int   na_shrink_class(int class_dim, int *shrink);
+VALUE na_shrink_rank(VALUE obj, int class_dim, int *shrink);
+
+#define rb_complex_new(r,i) \
+  rb_funcall(cComplex, na_id_new, 2, rb_float_new(r), rb_float_new(i))
+
+
+typedef union {
+  u_int8_t b[2];
+  int16_t s;
+} na_size16_t;
+
+typedef union {
+  u_int8_t b[4];
+  int32_t  i;
+  float    f;
+} na_size32_t;
+
+typedef union {
+  u_int8_t b[8];
+  float    f[2];
+  double   d;
+} na_size64_t;
+
+typedef union {
+  u_int8_t b[16];
+  double   d[2];
+} na_size128_t;
+
+
+#define swap16(d,s) \
+(d).b[0]=(s).b[1];\
+(d).b[1]=(s).b[0];
+
+#define swap32(d,s) \
+(d).b[0]=(s).b[3];\
+(d).b[1]=(s).b[2];\
+(d).b[2]=(s).b[1];\
+(d).b[3]=(s).b[0];
+
+#define swap64(d,s) \
+(d).b[0]=(s).b[7];\
+(d).b[1]=(s).b[6];\
+(d).b[2]=(s).b[5];\
+(d).b[3]=(s).b[4];\
+(d).b[4]=(s).b[3];\
+(d).b[5]=(s).b[2];\
+(d).b[6]=(s).b[1];\
+(d).b[7]=(s).b[0];
+
+#define swap64c(d,s) \
+(d).b[0]=(s).b[3];\
+(d).b[1]=(s).b[2];\
+(d).b[2]=(s).b[1];\
+(d).b[3]=(s).b[0];\
+(d).b[4]=(s).b[7];\
+(d).b[5]=(s).b[6];\
+(d).b[6]=(s).b[5];\
+(d).b[7]=(s).b[4];
+
+#define swap128c(d,s) \
+(d).b[0]=(s).b[7];\
+(d).b[1]=(s).b[6];\
+(d).b[2]=(s).b[5];\
+(d).b[3]=(s).b[4];\
+(d).b[4]=(s).b[3];\
+(d).b[5]=(s).b[2];\
+(d).b[6]=(s).b[1];\
+(d).b[7]=(s).b[0];\
+(d).b[8]=(s).b[15];\
+(d).b[9]=(s).b[14];\
+(d).b[10]=(s).b[13];\
+(d).b[11]=(s).b[12];\
+(d).b[12]=(s).b[11];\
+(d).b[13]=(s).b[10];\
+(d).b[14]=(s).b[9];\
+(d).b[15]=(s).b[8];
+
+#if !defined RSTRING_LEN
+#define RSTRING_LEN(a) RSTRING(a)->len
+#endif
+#if !defined RSTRING_PTR
+#define RSTRING_PTR(a) RSTRING(a)->ptr
+#endif

data/src/nimage/README.en

@@ -0,0 +1,38 @@
+
+NAME
+
+   NImage --- A Ruby Extension Library for displaying Images on X11
+	      by Masahiro Tanaka 2000/07/05
+
+DESCRIPTION
+
+  NImage is a simple Ruby class for displaying 2-D Data as images
+  on X11 display.
+
+REQUIREMENT
+
+  Ruby (ver 1.4.4 or later)
+  NArray (ver 0.3.1 or later)
+
+INSTALLATION
+
+  ruby extconf.rb
+  make
+  make install
+
+USAGE
+
+  require "nimage"
+  image = NArray.float(100,100) # some 2-D array
+  win = NImage.show image
+  win.close
+
+ACKNOWLEDGMENT
+
+  moriq-san for Ruby/X11 which is useful for prototyping
+
+PS
+
+  FITS image file is not included. Sorry.
+
+END

data/src/nimage/demo/fits.rb

@@ -0,0 +1,97 @@
+# A simple class for handling FITS images
+#	by Masahiro TANAKA 1999/12/19
+#    No document, sorry.
+#
+# Require:  Ruby/NArray
+#    http://koala.astro.isas.ac.jp/~masa/ruby/
+#
+# Example:
+#    f = Fits.read('somthing.fits')
+#    f.data # => 2-dimentional NArray data
+
+require 'narray'
+
+class Fits
+  attr_accessor :data
+  attr_accessor :header
+
+  def initialize
+    @data   = ""
+    @header = []
+  end
+
+  def data_to_narray(data,type,shape)
+    NArray.to_na( data, type, *shape ).ntoh
+  end
+
+
+  def read(fname)
+    f = File.open(fname, "r")
+    @header = []
+    nbytes = 0
+    foo = {}
+
+    while 
+      line = f.read(80)
+      nbytes += 80;
+
+      @header.push line
+
+      name = line[0,8].strip!
+      break if name=="END"
+
+      rest = line[8..-1]
+      if rest =~ /^= +('[^']*')/ #'
+	foo[name] = $1
+      elsif rest =~ /^= +([^\s\/]+)/
+	foo[name] = $1
+      end
+    end
+
+    # skip extra space
+    nbytes %= 2880
+    f.read(2880-nbytes) if nbytes > 0
+
+    naxis = foo["NAXIS"].to_i
+
+    case foo["BITPIX"]
+    when "8";	elm_size = 1; type = NArray::BYTE
+    when "16";	elm_size = 2; type = NArray::SINT
+    when "32";	elm_size = 4; type = NArray::LINT
+    when "-32";	elm_size = 4; type = NArray::SFLOAT
+    when "-64";	elm_size = 8; type = NArray::DFLOAT
+    end
+
+    size = 1
+    dims = []
+    for i in 1..naxis
+      key = "NAXIS#{i}"
+      if foo.key? key
+	n = foo[key].to_i
+	size = size * n
+	dims.push n
+	#printf "%s=%i\n", key,n
+      end
+    end
+
+    @data = data_to_narray( f.read(size*elm_size), type, dims )
+    f.close
+
+    if foo.key? "BSCALE"
+      s = foo["BSCALE"].to_f
+      @data = @data.to_f.mul!(s) if s != 1
+    end
+
+    if foo.key? "BZERO"
+      s = foo["BZERO"].to_f
+      @data = @data.to_f.add!(s) if s != 0
+    end
+
+    self
+  end
+
+end
+
+def Fits.read(*a)
+  Fits.new.read(*a)
+end

data/src/nimage/demo/fits_convol.rb

@@ -0,0 +1,28 @@
+# FITS-FFT demo 
+require 'fits'
+require 'nimage'
+
+f = Fits.new
+f.read( $*.shift || 'dss_m51.fits' )
+nx,ny = f.data.shape
+
+NImage.show f.data #, 'M51'
+
+# FFT low-pass filtering
+z = 50.0/nx
+x = NArray.float(nx).indgen! * z
+y = NArray.float(ny).indgen! * z
+x[-(nx/2)..-1] = x[nx/2..1]
+y[-(ny/2)..-1] = y[ny/2..1]
+y.reshape!(1,ny)
+# Operation between [nx,1] and [1,ny] arrays makes [nx,ny].
+filt = NMath::exp(-(x**2)-(y**2))
+filt /= filt.sum
+
+print "Now executing FFT...\n"
+lowpass = FFTW::convol(f.data,filt)
+
+NImage.show lowpass #, 'M51 (FFT low-pass)'
+
+print "Hit return key..."
+STDIN.getc

data/src/nimage/demo/fits_fftdemo.rb

@@ -0,0 +1,27 @@
+# FITS-FFT demo 
+require 'fits'
+require 'nimage'
+
+f = Fits.new
+f.read( $*.shift || 'dss_m51.fits' )
+nx,ny = f.data.shape
+
+NImage.show f.data #, 'M51'
+
+# FFT low-pass filtering
+x = NArray.float(nx).indgen! / (nx*0.1)
+y = NArray.float(ny).indgen! / (nx*0.1)
+x[-nx/2] = x[nx/2-1..0]
+y[-ny/2] = y[ny/2-1..0]
+y.reshape!(1,ny)
+# Operation between [nx,1] and [1,ny] arrays makes [nx,ny].
+filt = 1 / (x**2 + y**2 + 1)
+
+print "Now executing FFT...\n"
+spec = FFTW.fftw(f.data,-1)
+lowpass = FFTW.fftw(spec*filt,1).real / (nx*ny)
+
+NImage.show  lowpass #, 'M51 (FFT low-pass)'
+
+print "Hit return key..."
+STDIN.getc

data/src/nimage/demo/fitsdemo1.rb

@@ -0,0 +1,13 @@
+# FITS demo 
+require 'fits'
+require 'nimage'
+
+f = Fits.new
+f.read( $*.shift || 'dss_m51.fits' )
+p f.data
+
+v = NImage.show f.data
+
+print "Hit return key..."
+STDIN.getc
+v.close

data/src/nimage/demo/fitsdemo2.rb

@@ -0,0 +1,30 @@
+# FITS demo 
+require 'fits'
+require 'nimage'
+
+f = Fits.new
+f.read( $*.shift || 'dss_m51.fits' )
+
+NImage.show f.data #, 'M51'
+
+nx = f.data.shape[0]
+ny = f.data.shape[1]
+
+x = NArray.int(nx/2).indgen!*2
+y = NArray.int(ny/2).indgen!*2
+NImage.show f.data[x,y] #, 'M51 (x0.5)'
+
+x = NArray.float(nx*1.5).indgen!/1.5
+y = NArray.float(ny*1.5).indgen!/1.5
+NImage.show f.data[x,y] #, 'M51 (x1.5)'
+
+x = NArray.float(nx).indgen!
+y = NArray.float(ny).indgen!.newdim!(0)
+i = y / (ny/2) - 1
+i = (x-nx/2) * NMath.sqrt(i.abs) + nx/2 + y*nx
+d = f.data.clone.fill!(0)
+d[i] = f.data
+NImage.show d #, 'M51 (x1.5)'
+
+print "Hit return key..."
+STDIN.getc

data/src/nimage/demo/fitsdemo3.rb

@@ -0,0 +1,26 @@
+# FITS demo 
+require 'fits'
+require 'nimage'
+
+f = Fits.new
+f.read( $*.shift || 'dss_m51.fits' )
+image = f.data
+
+NImage.show image
+
+nx = image.shape[0]
+ny = image.shape[1]
+
+# re-sampling
+x = NArray.int(nx/2).indgen!*2
+y = NArray.int(ny/2).indgen!*2
+NImage.show image[x,y]
+# 'M51 (x0.5, resample)'
+
+# averaging
+NImage.show image[0...nx/2*2,0...ny/2*2].to_f.
+  reshape!(2,nx/2,2,ny/2).sum(0,2).div!(4).reshape!
+# 'M51 (x0.5, average)'
+
+print "Hit return key..."
+STDIN.getc

data/src/nimage/demo/fitsmorph.rb

@@ -0,0 +1,39 @@
+# FITS demo 
+require 'fits'
+require 'nimage'
+
+def triang x, px
+  y = NArray.float(*x.shape)
+  i1,i2  = (x>px).where2
+  y[i1] = NMath.sin((1-x[i1]) * (Math::PI/2/(1-px)) )
+  y[i2] = NMath.sin((1+x[i2]) * (Math::PI/2/(1+px)) )
+  p y.min
+  y
+end
+
+# Read-in Image
+f = Fits.new
+f.read( $*.shift || 'dss_m51.fits' )
+
+NImage.show f.data
+
+nx,ny = f.data.shape
+
+# Morphing parameters
+px,py = [ 0.3, -0.6]
+dx,dy = [-0.3,  0.7]
+
+indx = NArray.float(nx,1).indgen!
+indy = NArray.float(1,ny).indgen!
+
+ix = triang indx/(nx-1)*2-1, px
+iy = triang indy/(ny-1)*2-1, py
+
+ii = ix * iy
+ix = (indx + ii*(dx*(nx-1)/2)).round
+iy = (indy + ii*(dy*(ny-1)/2)).round
+
+NImage.show f.data[ix+iy*nx]
+
+print "Hit return key..."
+STDIN.getc