head	1.5;
access;
symbols
	bobbase:1.5
	bob:1.5.1
	r2_1:1.5
	r2_0:1.5
	r1_1_beta:1.4
	r1_1_alpha:1.3
	r1_0:1.3
	r0_11:1.3
	r0_10:1.3
	r0_9:1.1;
locks
	thoth:1.5.1.2
	thoth:1.5; strict;
comment	@// @;


1.5
date	94.08.22.15.20.29;	author thoth;	state Exp;
branches
	1.5.1.1;
next	1.4;

1.4
date	94.07.25.17.24.13;	author thoth;	state Exp;
branches;
next	1.3;

1.3
date	94.01.07.15.10.00;	author thoth;	state Exp;
branches;
next	1.2;

1.2
date	93.12.29.16.53.35;	author thoth;	state Exp;
branches;
next	1.1;

1.1
date	93.11.29.22.20.39;	author thoth;	state Exp;
branches;
next	;

1.5.1.1
date	94.12.28.17.09.34;	author thoth;	state Exp;
branches;
next	1.5.1.2;

1.5.1.2
date	95.01.13.19.45.29;	author thoth;	state Exp;
branches;
next	;


desc
@Complex Discrete Image declaration
@


1.5
log
@DOS-inspired name rework.
@
text
@// Emacs: -*- C++ -*-

//
//	Copyright 1993, Center for Computer Vision and Visualization,
//	University of Florida.  All rights reserved.
//


//
// $Log: ComplexDI.h,v $
// Revision 1.4  1994/07/25  17:24:13  thoth
// Name sanitization
//
// Revision 1.3  1994/01/07  15:10:00  thoth
// Image class is now CoreImage and named image types are
// Image<P,T>.
//
// Revision 1.2  1993/12/29  16:53:35  thoth
// removed PGM cruft.
//
// Revision 1.1  1993/11/29  22:20:39  thoth
// Initial revision
//
// 


#ifndef ComplexDI_h_
#define ComplexDI_h_
#include <complex.h>
#include "CoreImage.h"

#define SUPPRESS_INCLUDE
#include "Image.h"
#undef SUPPRESS_INCLUDE
#include "IntDI.h"		// for chi relations

class IA_Image<IA_Point<int>,complex>: public IA_CoreImage<IA_Point<int>, complex>
{
  public:
    IA_Image():IA_CoreImage<IA_Point<int>, complex>() {}

    IA_Image(const IA_CoreImage<IA_Point<int>, float> &real,
                            const IA_CoreImage<IA_Point<int>, float> &imag);


    IA_Image(const IA_Image& im)
    :IA_CoreImage<IA_Point<int>, complex>(im) {}

    IA_Image(IA_Set<IA_Point<int> > ps, complex value)
    :IA_CoreImage<IA_Point<int>, complex>(ps,(complex)value) {}

    IA_Image(IA_Set<IA_Point<int> > ps, complex *vp, unsigned sz,
			  int giveaway=0)
    :IA_CoreImage<IA_Point<int>, complex>(ps, vp, sz, giveaway) {}

    IA_Image(IA_Set<IA_Point<int> > ps, const complex *vp, unsigned sz)
    :IA_CoreImage<IA_Point<int>, complex>(ps, vp, sz) {}

    IA_Image(const IA_ClosureI<IA_Point<int>, complex> &img)
    :IA_CoreImage<IA_Point<int>, complex>(img) {}

    IA_Image(IA_Set<IA_Point<int> > ps, complex (*f)(const IA_Point<int>&))
    :IA_CoreImage<IA_Point<int>, complex>(ps,f) {}

    IA_Image( const IA_CoreImage<IA_Point<int>, complex> &d)
    :IA_CoreImage<IA_Point<int>, complex>(d) {}



    virtual ~IA_Image(){ }

#include	"CplxIOps.h"
};

inline int operator!=(const IA_CoreImage<IA_Point<int>,complex> &lhs,
		      const IA_CoreImage<IA_Point<int>,complex> &rhs) {
    return ! (lhs == rhs);
}
inline int operator!=(const IA_CoreImage<IA_Point<int>,complex> &lhs,
		      complex rhs) {
    return ! (lhs == rhs);
}
inline int operator!=(complex lhs,
		      const IA_CoreImage<IA_Point<int>,complex> &rhs) {
    return ! (rhs == lhs);
}

// compiler clue to allow inexact matches on a function template
ostream& operator <<(ostream&, const IA_CoreImage<IA_Point<int>, complex>&);


#endif
@


1.5.1.1
log
@Image ops are friendly with FBI instead.
@
text
@d10 1
a10 4
// $Log: CplxDI.h,v $
// Revision 1.5  1994/08/22  15:20:29  thoth
// DOS-inspired name rework.
//
d72 1
a73 2

#include	"CplxIOps.h"
@


1.5.1.2
log
@CoreImage has been re-merged with Image.  All special stuff should be
friends of FBI now.
@
text
@a10 3
// Revision 1.5.1.1  1994/12/28  17:09:34  thoth
// Image ops are friendly with FBI instead.
//
d33 1
a33 1
//#include "Image.h"
d40 1
a40 2
#if 0
class IA_Image<IA_Point<int>,complex>: public IA_Image<IA_Point<int>, complex>
d43 1
a43 1
    IA_Image():IA_Image<IA_Point<int>, complex>() {}
d45 2
a46 2
    IA_Image(const IA_Image<IA_Point<int>, float> &real,
                            const IA_Image<IA_Point<int>, float> &imag);
d50 1
a50 1
    :IA_Image<IA_Point<int>, complex>(im) {}
d53 1
a53 1
    :IA_Image<IA_Point<int>, complex>(ps,(complex)value) {}
d57 1
a57 1
    :IA_Image<IA_Point<int>, complex>(ps, vp, sz, giveaway) {}
d60 1
a60 1
    :IA_Image<IA_Point<int>, complex>(ps, vp, sz) {}
d63 1
a63 1
    :IA_Image<IA_Point<int>, complex>(img) {}
d66 1
a66 1
    :IA_Image<IA_Point<int>, complex>(ps,f) {}
d68 2
a69 2
    IA_Image( const IA_Image<IA_Point<int>, complex> &d)
    :IA_Image<IA_Point<int>, complex>(d) {}
a75 5
#else
IA_Image<IA_Point<int>, complex>
IA_CplxDI(const IA_Image<IA_Point<int>, float> &real,
	  const IA_Image<IA_Point<int>, float> &imag);
#endif
d79 2
a80 2
inline int operator!=(const IA_Image<IA_Point<int>,complex> &lhs,
		      const IA_Image<IA_Point<int>,complex> &rhs) {
d83 1
a83 1
inline int operator!=(const IA_Image<IA_Point<int>,complex> &lhs,
d88 1
a88 1
		      const IA_Image<IA_Point<int>,complex> &rhs) {
d93 1
a93 1
ostream& operator <<(ostream&, const IA_Image<IA_Point<int>, complex>&);
@


1.4
log
@Name sanitization
@
text
@d11 3
d72 1
a72 1
#include	"ComplexImageOps.h"
@


1.3
log
@Image class is now CoreImage and named image types are
Image<P,T>.
@
text
@d11 4
d34 1
a34 1
class IA_Image<IA_IntPoint,complex>: public IA_CoreImage<IA_IntPoint, complex>
d37 1
a37 1
    IA_Image():IA_CoreImage<IA_IntPoint, complex>() {}
d39 2
a40 2
    IA_Image(const IA_CoreImage<IA_IntPoint, float> &real,
                            const IA_CoreImage<IA_IntPoint, float> &imag);
d44 1
a44 1
    :IA_CoreImage<IA_IntPoint, complex>(im) {}
d46 2
a47 2
    IA_Image(IA_IntPointSet ps, complex value)
    :IA_CoreImage<IA_IntPoint, complex>(ps,(complex)value) {}
d49 1
a49 1
    IA_Image(IA_IntPointSet ps, complex *vp, unsigned sz,
d51 1
d53 2
a54 1
    :IA_CoreImage<IA_IntPoint, complex>(ps, vp, sz, giveaway) {}
d56 2
a57 2
    IA_Image(const IA_ClosureI<IA_IntPoint, complex> &img)
    :IA_CoreImage<IA_IntPoint, complex>(img) {}
d59 2
a60 2
    IA_Image(IA_IntPointSet ps, complex (*f)(const IA_IntPoint&))
    :IA_CoreImage<IA_IntPoint, complex>(ps,f) {}
d62 2
a63 2
    IA_Image( const IA_CoreImage<IA_IntPoint, complex> &d)
    :IA_CoreImage<IA_IntPoint, complex>(d) {}
d72 2
a73 2
inline int operator!=(const IA_CoreImage<IA_IntPoint,complex> &lhs,
		      const IA_CoreImage<IA_IntPoint,complex> &rhs) {
d76 1
a76 1
inline int operator!=(const IA_CoreImage<IA_IntPoint,complex> &lhs,
d81 1
a81 1
		      const IA_CoreImage<IA_IntPoint,complex> &rhs) {
d86 1
a86 1
ostream& operator <<(ostream&, const IA_CoreImage<IA_IntPoint, complex>&);
@


1.2
log
@removed PGM cruft.
@
text
@d11 3
d23 3
d27 2
d30 1
a30 1
class IA_ComplexDiscreteImage: public IA_Image<IA_IntPoint, complex>
d33 1
a33 1
    IA_ComplexDiscreteImage():IA_Image<IA_IntPoint, complex>() {}
d35 2
a36 2
    IA_ComplexDiscreteImage(const IA_Image<IA_IntPoint, float> &real,
                            const IA_Image<IA_IntPoint, float> &imag);
d39 2
a40 2
    IA_ComplexDiscreteImage(const IA_ComplexDiscreteImage& im)
    :IA_Image<IA_IntPoint, complex>(im) {}
d42 2
a43 2
    IA_ComplexDiscreteImage(IA_IntPointSet ps, complex value)
    :IA_Image<IA_IntPoint, complex>(ps,(complex)value) {}
d45 1
a45 1
    IA_ComplexDiscreteImage(IA_IntPointSet ps, complex *vp, unsigned sz,
d48 1
a48 1
    :IA_Image<IA_IntPoint, complex>(ps, vp, sz, giveaway) {}
d50 2
a51 2
    IA_ComplexDiscreteImage(const IA_ClosureI<IA_IntPoint, complex> &img)
    :IA_Image<IA_IntPoint, complex>(img) {}
d53 2
a54 2
    IA_ComplexDiscreteImage(IA_IntPointSet ps, complex (*f)(const IA_IntPoint&))
    :IA_Image<IA_IntPoint, complex>(ps,f) {}
d56 2
a57 2
    IA_ComplexDiscreteImage( const IA_Image<IA_IntPoint, complex> &d)
    :IA_Image<IA_IntPoint, complex>(d) {}
d61 1
a61 1
    virtual ~IA_ComplexDiscreteImage(){ }
d66 2
a67 2
inline int operator!=(const IA_ComplexDiscreteImage &lhs,
	       const IA_ComplexDiscreteImage &rhs) {
d70 2
a71 1
inline int operator!=(const IA_ComplexDiscreteImage &lhs, complex rhs) {
d74 2
a75 1
inline int operator!=(complex lhs, const IA_ComplexDiscreteImage &rhs) {
d80 1
a80 2
ostream& operator <<(ostream&, const IA_Image<IA_IntPoint, complex>&);

a81 9
//inline IA_ComplexDiscreteImage compose(complex (*f)(complex),
//			     const IA_Image<IA_IntPoint, complex>& fi) {
//    return compose(f, fi, (complex*)0, (double*)0, (double*)0);
//}

//inline IA_ComplexDiscreteImage compose(double (*f)(double),
//				     const IA_ComplexDiscreteImage& fi) {
//    return compose(f, fi, (complex*)0, (double*)0, (double*)0);
//}
@


1.1
log
@Initial revision
@
text
@d10 4
a13 1
// $Log$
a55 9
#if 0
    static IA_ComplexDiscreteImage read_PGM(istream &);
    static IA_ComplexDiscreteImage read_PGM(const char *fname);

    ostream& write_PGM(ostream &, unsigned) const;
    ostream& write_PGM(ostream &) const;
    void write_PGM(const char *fname, unsigned) const;
    void write_PGM(const char *fname) const;
#endif
@
