head	1.8;
access;
symbols
	bobbase:1.8
	bob:1.8.1
	r2_1:1.7
	r2_0:1.7
	r1_1_beta:1.6
	r1_1_alpha:1.5
	r1_0:1.5
	r0_11:1.5
	r0_10:1.4
	r0_9:1.1;
locks
	thoth:1.8.1.3; strict;
comment	@// @;


1.8
date	94.09.15.19.36.59;	author jnw;	state Exp;
branches
	1.8.1.1;
next	1.7;

1.7
date	94.08.22.15.20.29;	author thoth;	state Exp;
branches;
next	1.6;

1.6
date	94.07.25.17.30.14;	author thoth;	state Exp;
branches;
next	1.5;

1.5
date	94.03.30.13.51.17;	author thoth;	state Exp;
branches;
next	1.4;

1.4
date	94.01.31.15.39.11;	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.13;	author thoth;	state Exp;
branches;
next	1.1;

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

1.8.1.1
date	94.12.28.15.44.03;	author thoth;	state Exp;
branches;
next	1.8.1.2;

1.8.1.2
date	95.01.09.17.52.46;	author thoth;	state Exp;
branches;
next	1.8.1.3;

1.8.1.3
date	95.01.13.19.37.42;	author thoth;	state Exp;
branches;
next	;


desc
@Bit Discrete Image declaration
@


1.8
log
@Added display function for IA_Image<IA_Point<int>, IA_Bit>
@
text
@// Emacs: -*- C++ -*-

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


//
// $Log: BitDI.h,v $
// Revision 1.7  1994/08/22  15:20:29  thoth
// DOS-inspired name rework.
//
// Revision 1.6  1994/07/25  17:30:14  thoth
// Name sanitization
//
// Revision 1.5  1994/03/30  13:51:17  thoth
// inline non-member functions to do image input.
//
// Revision 1.4  1994/01/31  15:39:11  thoth
// read and write PBM is now available.
// attempt to have I(bit) I(T) operations failed.
//
// 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:13  thoth
// Bit Discrete Image now uses separate Bit type.
//
// Revision 1.1  1993/11/29  22:20:39  thoth
// Initial revision
//
//

#ifndef BitDI_h_
#define BitDI_h_

#include "Bit.h"
#include "CoreImage.h"

#define SUPPRESS_INCLUDE
#include "Image.h"
#undef SUPPRESS_INCLUDE

#include	<complex.h>	// for the complex conversion

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

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

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

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

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

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

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

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

    virtual ~IA_Image(){ }

#include        "BitIOps.h"

#if 0

//binary pointwise commutative operator* I(u_char) I(IA_Bit) I(u_char)
friend IA_Image<IA_Point<int>, u_char> operator*(const IA_CoreImage<IA_Point<int>,u_char> &,const IA_CoreImage<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, u_char> operator*(const IA_CoreImage<IA_Point<int>,IA_Bit> & lhs,const IA_CoreImage<IA_Point<int>,u_char> & rhs) {
    return rhs*lhs;
}

//binary pointwise commutative operator* u_char I(IA_Bit) I(u_char)
friend IA_Image<IA_Point<int>, u_char> operator*(u_char,const IA_CoreImage<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, u_char> operator*(const IA_CoreImage<IA_Point<int>,IA_Bit> & lhs,u_char rhs) {
    return rhs*lhs;
}

//binary pointwise commutative operator* I(int) I(IA_Bit) I(int)
friend IA_Image<IA_Point<int>, int> operator*(const IA_CoreImage<IA_Point<int>,int> &,const IA_CoreImage<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, int> operator*(const IA_CoreImage<IA_Point<int>,IA_Bit> & lhs,const IA_CoreImage<IA_Point<int>,int> & rhs) {
    return rhs*lhs;
}

//binary pointwise commutative operator* int I(IA_Bit) I(int)
friend IA_Image<IA_Point<int>, int> operator*(int,const IA_CoreImage<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, int> operator*(const IA_CoreImage<IA_Point<int>,IA_Bit> & lhs,int rhs) {
    return rhs*lhs;
}

//binary pointwise commutative operator* I(float) I(IA_Bit) I(float)
friend IA_Image<IA_Point<int>, float> operator*(const IA_CoreImage<IA_Point<int>,float> &,const IA_CoreImage<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, float> operator*(const IA_CoreImage<IA_Point<int>,IA_Bit> & lhs,const IA_CoreImage<IA_Point<int>,float> & rhs) {
    return rhs*lhs;
}

//binary pointwise commutative operator* float I(IA_Bit) I(float)
friend IA_Image<IA_Point<int>, float> operator*(float,const IA_CoreImage<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, float> operator*(const IA_CoreImage<IA_Point<int>,IA_Bit> & lhs,float rhs) {
    return rhs*lhs;
}

//binary pointwise commutative operator* I(complex) I(IA_Bit) I(complex)
friend IA_Image<IA_Point<int>, complex> operator*(const IA_CoreImage<IA_Point<int>,complex> &,const IA_CoreImage<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, complex> operator*(const IA_CoreImage<IA_Point<int>,IA_Bit> & lhs,const IA_CoreImage<IA_Point<int>,complex> & rhs) {
    return rhs*lhs;
}

//binary pointwise commutative operator* complex I(IA_Bit) I(complex)
friend IA_Image<IA_Point<int>, complex> operator*(complex,const IA_CoreImage<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, complex> operator*(const IA_CoreImage<IA_Point<int>,IA_Bit> & lhs,complex rhs) {
    return rhs*lhs;
}
#endif

    static IA_Image read_PBM(istream &);
    static IA_Image read_PBM(const char *fname);

    ostream& write_PBM(ostream &) const;
    void write_PBM(const char *fname) const;
};

//
//

inline IA_Image<IA_Point<int>,IA_Bit> read_PBM(istream &i) {
    return IA_Image<IA_Point<int>,IA_Bit>::read_PBM(i);
}
inline IA_Image<IA_Point<int>,IA_Bit> read_PBM(const char *fname) {
    return IA_Image<IA_Point<int>,IA_Bit>::read_PBM(fname);
}

//
//

inline void write_PBM(const IA_CoreImage<IA_Point<int>,IA_Bit> &img,
		      const char *fname)
{
    IA_Image<IA_Point<int>,IA_Bit>(img).write_PBM(fname);
}

inline ostream & write_PBM(const IA_CoreImage<IA_Point<int>,IA_Bit> &img, ostream &o)
{
    return IA_Image<IA_Point<int>,IA_Bit>(img).write_PBM(o);
}

//
//

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

//
//

inline IA_Image<IA_Point<int>, IA_Bit>
operator&&(const IA_CoreImage<IA_Point<int>, IA_Bit> &lhs,
	   const IA_CoreImage<IA_Point<int>, IA_Bit> &rhs) {
    return lhs & rhs;
}

inline IA_Image<IA_Point<int>, IA_Bit>
operator&&(IA_Bit lhs,
	   const IA_CoreImage<IA_Point<int>, IA_Bit> &rhs) {
    return lhs & rhs;
}

inline IA_Image<IA_Point<int>, IA_Bit>
operator&&(const IA_CoreImage<IA_Point<int>, IA_Bit> &lhs,
	   IA_Bit rhs) {
    return lhs & rhs;
}

//
//

inline IA_Image<IA_Point<int>, IA_Bit>
operator||(const IA_CoreImage<IA_Point<int>, IA_Bit> &lhs,
	   const IA_CoreImage<IA_Point<int>, IA_Bit> &rhs) {
    return lhs | rhs;
}

inline IA_Image<IA_Point<int>, IA_Bit>
operator||(IA_Bit lhs,
	   const IA_CoreImage<IA_Point<int>, IA_Bit> &rhs) {
    return lhs | rhs;
}

inline IA_Image<IA_Point<int>, IA_Bit>
operator||(const IA_CoreImage<IA_Point<int>, IA_Bit> &lhs,
	   IA_Bit rhs) {
    return lhs | rhs;
}

//
//

pid_t display(IA_Image<IA_Point<int>,IA_Bit> img);

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

#endif
@


1.8.1.1
log
@image I/O is now ROF.
@
text
@a10 3
// Revision 1.8  1994/09/15  19:36:59  jnw
// Added display function for IA_Image<IA_Point<int>, IA_Bit>
//
d77 2
d129 1
a129 1
#if 0
a134 1
#endif
a136 3

#include        "BitIOps.h"

d140 6
a145 2
inline IA_Image<IA_Point<int>,IA_Bit> read_PBM(istream &i);
inline IA_Image<IA_Point<int>,IA_Bit> read_PBM(const char *fname);
d151 4
a154 1
		      const char *fname);
d156 4
a159 1
inline ostream & write_PBM(const IA_CoreImage<IA_Point<int>,IA_Bit> &img, ostream &o);
@


1.8.1.2
log
@Outline functions shouldn't have inline qualifier.
@
text
@a10 3
// Revision 1.8.1.1  1994/12/28  15:44:03  thoth
// image I/O is now ROF.
//
d145 2
a146 2
IA_Image<IA_Point<int>,IA_Bit> read_PBM(istream &i);
IA_Image<IA_Point<int>,IA_Bit> read_PBM(const char *fname);
d151 1
a151 1
void write_PBM(const IA_CoreImage<IA_Point<int>,IA_Bit> &img,
d154 1
a154 1
ostream & write_PBM(const IA_CoreImage<IA_Point<int>,IA_Bit> &img, ostream &o);
@


1.8.1.3
log
@CoreImage has been re-merged with Image.  All special stuff should be
friends of FBI now.
@
text
@a10 3
// Revision 1.8.1.2  1995/01/09  17:52:46  thoth
// Outline functions shouldn't have inline qualifier.
//
d46 1
a46 1
//#include "Image.h"
d54 1
a54 2
#if 0
class IA_Image<IA_Point<int>,IA_Bit>: public IA_Image<IA_Point<int>, IA_Bit>
d57 1
a57 1
    IA_Image():IA_Image<IA_Point<int>, IA_Bit>() {}
d60 1
a60 1
    :IA_Image<IA_Point<int>, IA_Bit>(im) {}
d63 1
a63 1
    :IA_Image<IA_Point<int>, IA_Bit>(ps,(IA_Bit)value) {}
d67 1
a67 1
    :IA_Image<IA_Point<int>, IA_Bit>(ps, vp, sz, giveaway) {}
d70 1
a70 1
    :IA_Image<IA_Point<int>, IA_Bit>(ps, vp, sz) {}
d73 1
a73 1
    :IA_Image<IA_Point<int>, IA_Bit>(img) {}
d76 1
a76 1
    :IA_Image<IA_Point<int>, IA_Bit>(ps,f) {}
d78 2
a79 2
    IA_Image( const IA_Image<IA_Point<int>, IA_Bit> &d)
    :IA_Image<IA_Point<int>, IA_Bit>(d) {}
d86 2
a87 2
friend IA_Image<IA_Point<int>, u_char> operator*(const IA_Image<IA_Point<int>,u_char> &,const IA_Image<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, u_char> operator*(const IA_Image<IA_Point<int>,IA_Bit> & lhs,const IA_Image<IA_Point<int>,u_char> & rhs) {
d92 2
a93 2
friend IA_Image<IA_Point<int>, u_char> operator*(u_char,const IA_Image<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, u_char> operator*(const IA_Image<IA_Point<int>,IA_Bit> & lhs,u_char rhs) {
d98 2
a99 2
friend IA_Image<IA_Point<int>, int> operator*(const IA_Image<IA_Point<int>,int> &,const IA_Image<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, int> operator*(const IA_Image<IA_Point<int>,IA_Bit> & lhs,const IA_Image<IA_Point<int>,int> & rhs) {
d104 2
a105 2
friend IA_Image<IA_Point<int>, int> operator*(int,const IA_Image<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, int> operator*(const IA_Image<IA_Point<int>,IA_Bit> & lhs,int rhs) {
d110 2
a111 2
friend IA_Image<IA_Point<int>, float> operator*(const IA_Image<IA_Point<int>,float> &,const IA_Image<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, float> operator*(const IA_Image<IA_Point<int>,IA_Bit> & lhs,const IA_Image<IA_Point<int>,float> & rhs) {
d116 2
a117 2
friend IA_Image<IA_Point<int>, float> operator*(float,const IA_Image<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, float> operator*(const IA_Image<IA_Point<int>,IA_Bit> & lhs,float rhs) {
d122 2
a123 2
friend IA_Image<IA_Point<int>, complex> operator*(const IA_Image<IA_Point<int>,complex> &,const IA_Image<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, complex> operator*(const IA_Image<IA_Point<int>,IA_Bit> & lhs,const IA_Image<IA_Point<int>,complex> & rhs) {
d128 2
a129 2
friend IA_Image<IA_Point<int>, complex> operator*(complex,const IA_Image<IA_Point<int>,IA_Bit> &);
friend IA_Image<IA_Point<int>, complex> operator*(const IA_Image<IA_Point<int>,IA_Bit> & lhs,complex rhs) {
a140 1
#endif
d154 1
a154 1
void write_PBM(const IA_Image<IA_Point<int>,IA_Bit> &img,
d157 1
a157 1
ostream & write_PBM(const IA_Image<IA_Point<int>,IA_Bit> &img, ostream &o);
d162 2
a163 2
inline int operator!=(const IA_Image<IA_Point<int>,IA_Bit> &lhs,
	       const IA_Image<IA_Point<int>,IA_Bit> &rhs) {
d166 1
a166 1
inline int operator!=(const IA_Image<IA_Point<int>,IA_Bit> &lhs,
d171 1
a171 1
		      const IA_Image<IA_Point<int>,IA_Bit> &rhs) {
d179 2
a180 2
operator&&(const IA_Image<IA_Point<int>, IA_Bit> &lhs,
	   const IA_Image<IA_Point<int>, IA_Bit> &rhs) {
d186 1
a186 1
	   const IA_Image<IA_Point<int>, IA_Bit> &rhs) {
d191 1
a191 1
operator&&(const IA_Image<IA_Point<int>, IA_Bit> &lhs,
d200 2
a201 2
operator||(const IA_Image<IA_Point<int>, IA_Bit> &lhs,
	   const IA_Image<IA_Point<int>, IA_Bit> &rhs) {
d207 1
a207 1
	   const IA_Image<IA_Point<int>, IA_Bit> &rhs) {
d212 1
a212 1
operator||(const IA_Image<IA_Point<int>, IA_Bit> &lhs,
d223 1
a223 1
ostream& operator <<(ostream&, const IA_Image<IA_Point<int>, IA_Bit>&);
@


1.7
log
@DOS-inspired name rework.
@
text
@d11 3
d221 2
@


1.6
log
@Name sanitization
@
text
@d11 3
d74 1
a74 1
#include        "BitImageOps.h"
@


1.5
log
@inline non-member functions to do image input.
@
text
@d11 3
d42 1
a42 1
class IA_Image<IA_IntPoint,IA_Bit>: public IA_CoreImage<IA_IntPoint, IA_Bit>
d45 1
a45 1
    IA_Image():IA_CoreImage<IA_IntPoint, IA_Bit>() {}
d48 1
a48 1
    :IA_CoreImage<IA_IntPoint, IA_Bit>(im) {}
d50 2
a51 2
    IA_Image(IA_IntPointSet ps, int value)
    :IA_CoreImage<IA_IntPoint, IA_Bit>(ps,(IA_Bit)value) {}
d53 1
a53 1
    IA_Image(IA_IntPointSet ps, IA_Bit *vp, unsigned sz,
d55 1
a55 1
    :IA_CoreImage<IA_IntPoint, IA_Bit>(ps, vp, sz, giveaway) {}
d57 2
a58 2
    IA_Image(IA_IntPointSet ps, const IA_Bit *vp, unsigned sz)
    :IA_CoreImage<IA_IntPoint, IA_Bit>(ps, vp, sz) {}
d60 2
a61 2
    IA_Image(const IA_ClosureI<IA_IntPoint,IA_Bit> &img)
    :IA_CoreImage<IA_IntPoint, IA_Bit>(img) {}
d63 2
a64 2
    IA_Image(IA_IntPointSet ps, IA_Bit (*f)(const IA_IntPoint&))
    :IA_CoreImage<IA_IntPoint, IA_Bit>(ps,f) {}
d66 2
a67 2
    IA_Image( const IA_CoreImage<IA_IntPoint, IA_Bit> &d)
    :IA_CoreImage<IA_IntPoint, IA_Bit>(d) {}
d76 2
a77 2
friend IA_Image<IA_IntPoint, u_char> operator*(const IA_CoreImage<IA_IntPoint,u_char> &,const IA_CoreImage<IA_IntPoint,IA_Bit> &);
friend IA_Image<IA_IntPoint, u_char> operator*(const IA_CoreImage<IA_IntPoint,IA_Bit> & lhs,const IA_CoreImage<IA_IntPoint,u_char> & rhs) {
d82 2
a83 2
friend IA_Image<IA_IntPoint, u_char> operator*(u_char,const IA_CoreImage<IA_IntPoint,IA_Bit> &);
friend IA_Image<IA_IntPoint, u_char> operator*(const IA_CoreImage<IA_IntPoint,IA_Bit> & lhs,u_char rhs) {
d88 2
a89 2
friend IA_Image<IA_IntPoint, int> operator*(const IA_CoreImage<IA_IntPoint,int> &,const IA_CoreImage<IA_IntPoint,IA_Bit> &);
friend IA_Image<IA_IntPoint, int> operator*(const IA_CoreImage<IA_IntPoint,IA_Bit> & lhs,const IA_CoreImage<IA_IntPoint,int> & rhs) {
d94 2
a95 2
friend IA_Image<IA_IntPoint, int> operator*(int,const IA_CoreImage<IA_IntPoint,IA_Bit> &);
friend IA_Image<IA_IntPoint, int> operator*(const IA_CoreImage<IA_IntPoint,IA_Bit> & lhs,int rhs) {
d100 2
a101 2
friend IA_Image<IA_IntPoint, float> operator*(const IA_CoreImage<IA_IntPoint,float> &,const IA_CoreImage<IA_IntPoint,IA_Bit> &);
friend IA_Image<IA_IntPoint, float> operator*(const IA_CoreImage<IA_IntPoint,IA_Bit> & lhs,const IA_CoreImage<IA_IntPoint,float> & rhs) {
d106 2
a107 2
friend IA_Image<IA_IntPoint, float> operator*(float,const IA_CoreImage<IA_IntPoint,IA_Bit> &);
friend IA_Image<IA_IntPoint, float> operator*(const IA_CoreImage<IA_IntPoint,IA_Bit> & lhs,float rhs) {
d112 2
a113 2
friend IA_Image<IA_IntPoint, complex> operator*(const IA_CoreImage<IA_IntPoint,complex> &,const IA_CoreImage<IA_IntPoint,IA_Bit> &);
friend IA_Image<IA_IntPoint, complex> operator*(const IA_CoreImage<IA_IntPoint,IA_Bit> & lhs,const IA_CoreImage<IA_IntPoint,complex> & rhs) {
d118 2
a119 2
friend IA_Image<IA_IntPoint, complex> operator*(complex,const IA_CoreImage<IA_IntPoint,IA_Bit> &);
friend IA_Image<IA_IntPoint, complex> operator*(const IA_CoreImage<IA_IntPoint,IA_Bit> & lhs,complex rhs) {
d134 2
a135 2
inline IA_Image<IA_IntPoint,IA_Bit> read_PBM(istream &i) {
    return IA_Image<IA_IntPoint,IA_Bit>::read_PBM(i);
d137 2
a138 2
inline IA_Image<IA_IntPoint,IA_Bit> read_PBM(const char *fname) {
    return IA_Image<IA_IntPoint,IA_Bit>::read_PBM(fname);
d144 1
a144 1
inline void write_PBM(const IA_CoreImage<IA_IntPoint,IA_Bit> &img,
d147 1
a147 1
    IA_Image<IA_IntPoint,IA_Bit>(img).write_PBM(fname);
d150 1
a150 1
inline ostream & write_PBM(const IA_CoreImage<IA_IntPoint,IA_Bit> &img, ostream &o)
d152 1
a152 1
    return IA_Image<IA_IntPoint,IA_Bit>(img).write_PBM(o);
d158 2
a159 2
inline int operator!=(const IA_CoreImage<IA_IntPoint,IA_Bit> &lhs,
	       const IA_CoreImage<IA_IntPoint,IA_Bit> &rhs) {
d162 1
a162 1
inline int operator!=(const IA_CoreImage<IA_IntPoint,IA_Bit> &lhs,
d167 1
a167 1
		      const IA_CoreImage<IA_IntPoint,IA_Bit> &rhs) {
d174 3
a176 3
inline IA_Image<IA_IntPoint, IA_Bit>
operator&&(const IA_CoreImage<IA_IntPoint, IA_Bit> &lhs,
	   const IA_CoreImage<IA_IntPoint, IA_Bit> &rhs) {
d180 1
a180 1
inline IA_Image<IA_IntPoint, IA_Bit>
d182 1
a182 1
	   const IA_CoreImage<IA_IntPoint, IA_Bit> &rhs) {
d186 2
a187 2
inline IA_Image<IA_IntPoint, IA_Bit>
operator&&(const IA_CoreImage<IA_IntPoint, IA_Bit> &lhs,
d195 3
a197 3
inline IA_Image<IA_IntPoint, IA_Bit>
operator||(const IA_CoreImage<IA_IntPoint, IA_Bit> &lhs,
	   const IA_CoreImage<IA_IntPoint, IA_Bit> &rhs) {
d201 1
a201 1
inline IA_Image<IA_IntPoint, IA_Bit>
d203 1
a203 1
	   const IA_CoreImage<IA_IntPoint, IA_Bit> &rhs) {
d207 2
a208 2
inline IA_Image<IA_IntPoint, IA_Bit>
operator||(const IA_CoreImage<IA_IntPoint, IA_Bit> &lhs,
d217 1
a217 1
ostream& operator <<(ostream&, const IA_CoreImage<IA_IntPoint, IA_Bit>&);
@


1.4
log
@read and write PBM is now available.
attempt to have I(bit) I(T) operations failed.
@
text
@d11 4
d127 13
@


1.3
log
@Image class is now CoreImage and named image types are
Image<P,T>.
@
text
@d11 4
d33 2
d65 1
d67 50
a119 1
    ostream& write_PBM(ostream &, unsigned) const;
d121 1
a121 3
    void write_PGM(const char *fname, unsigned) const;
    void write_PGM(const char *fname) const;
#endif
d124 14
d150 45
@


1.2
log
@Bit Discrete Image now uses separate Bit type.
@
text
@d11 3
d23 3
d27 1
d29 1
a29 1
class IA_BitDiscreteImage: public IA_Image<IA_IntPoint, IA_Bit>
d32 1
a32 1
    IA_BitDiscreteImage():IA_Image<IA_IntPoint, IA_Bit>() {}
d34 2
a35 2
    IA_BitDiscreteImage(const IA_BitDiscreteImage& im)
    :IA_Image<IA_IntPoint, IA_Bit>(im) {}
d37 2
a38 2
    IA_BitDiscreteImage(IA_IntPointSet ps, int value)
    :IA_Image<IA_IntPoint, IA_Bit>(ps,(IA_Bit)value) {}
d40 1
a40 1
    IA_BitDiscreteImage(IA_IntPointSet ps, IA_Bit *vp, unsigned sz,
d42 1
a42 1
    :IA_Image<IA_IntPoint, IA_Bit>(ps, vp, sz, giveaway) {}
d44 2
a45 2
    IA_BitDiscreteImage(IA_IntPointSet ps, const IA_Bit *vp, unsigned sz)
    :IA_Image<IA_IntPoint, IA_Bit>(ps, vp, sz) {}
d47 2
a48 2
    IA_BitDiscreteImage(const IA_ClosureI<IA_IntPoint,IA_Bit> &img)
    :IA_Image<IA_IntPoint, IA_Bit>(img) {}
d50 2
a51 2
    IA_BitDiscreteImage(IA_IntPointSet ps, IA_Bit (*f)(const IA_IntPoint&))
    :IA_Image<IA_IntPoint, IA_Bit>(ps,f) {}
d53 2
a54 2
    IA_BitDiscreteImage( const IA_Image<IA_IntPoint, IA_Bit> &d)
    :IA_Image<IA_IntPoint, IA_Bit>(d) {}
d56 1
a56 1
    virtual ~IA_BitDiscreteImage(){ }
d60 2
a61 2
    static IA_BitDiscreteImage read_PBM(istream &);
    static IA_BitDiscreteImage read_PBM(const char *fname);
d70 2
a71 2
inline int operator!=(const IA_BitDiscreteImage &lhs,
	       const IA_BitDiscreteImage &rhs) {
d74 2
a75 1
inline int operator!=(const IA_BitDiscreteImage &lhs, IA_Bit rhs) {
d78 2
a79 1
inline int operator!=(IA_Bit lhs, const IA_BitDiscreteImage &rhs) {
d84 1
a84 1
ostream& operator <<(ostream&, const IA_Image<IA_IntPoint, IA_Bit>&);
@


1.1
log
@Initial revision
@
text
@d10 3
a12 1
// $Log$
d14 1
d19 1
d22 1
a22 1
class IA_BitDiscreteImage: public IA_Image<IA_IntPoint, u_char>
d25 1
a25 1
    IA_BitDiscreteImage():IA_Image<IA_IntPoint, u_char>() {}
d28 1
a28 1
    :IA_Image<IA_IntPoint, u_char>(im) {}
d31 1
a31 1
    :IA_Image<IA_IntPoint, u_char>(ps,(u_char)value) {}
d33 1
a33 1
    IA_BitDiscreteImage(IA_IntPointSet ps, u_char *vp, unsigned sz,
d35 4
a38 1
    :IA_Image<IA_IntPoint, u_char>(ps, vp, sz, giveaway) {}
d40 2
a41 2
    IA_BitDiscreteImage(const IA_ClosureI<IA_IntPoint,u_char> &img)
    :IA_Image<IA_IntPoint, u_char>(img) {}
d43 2
a44 2
    IA_BitDiscreteImage(IA_IntPointSet ps, u_char (*f)(const IA_IntPoint&))
    :IA_Image<IA_IntPoint, u_char>(ps,f) {}
d46 2
a47 2
    IA_BitDiscreteImage( const IA_Image<IA_IntPoint, u_char> &d)
    :IA_Image<IA_IntPoint, u_char>(d) {}
d63 1
a63 1
inline u_char operator!=(const IA_BitDiscreteImage &lhs,
d67 1
a67 1
inline u_char operator!=(const IA_BitDiscreteImage &lhs, u_char rhs) {
d70 1
a70 1
inline u_char operator!=(u_char lhs, const IA_BitDiscreteImage &rhs) {
d75 1
a75 1
ostream& operator <<(ostream&, const IA_Image<IA_IntPoint, u_char>&);
@
