head	1.7;
access;
symbols
	bobbase:1.7
	bob:1.7.1
	r2_1:1.6
	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
	fjsoria:1.7; strict;
comment	@// @;


1.7
date	94.12.14.16.39.08;	author fjsoria;	state Exp;
branches
	1.7.1.1;
next	1.6;

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

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

1.4
date	94.07.25.17.26.39;	author thoth;	state Exp;
branches
	1.4.1.1;
next	1.3;

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

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

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

1.4.1.1
date	95.02.02.21.06.43;	author fjsoria;	state Exp;
branches;
next	;

1.7.1.1
date	95.01.13.19.58.04;	author thoth;	state Exp;
branches;
next	;


desc
@Declaration of the float continuous image.
@


1.7
log
@constructor in IA_Image<IA_Point<double>,float>
looked like IA_Image<IA_Point<double>,float>
() {...}; instead of IA_Image(){}; cfront did not
catch this
@
text
@// Emacs: -*- C++ -*-

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


//
// $Log: FloatCI.h,v $
// Revision 1.6  1994/09/22  16:58:30  thoth
// Added a 0-argument constructor.
//
// Revision 1.5  1994/08/22  15:20:29  thoth
// DOS-inspired name rework.
//
// Revision 1.4  1994/07/25  17:26:39  thoth
// Name sanitization
//
// Revision 1.3  1994/01/31  15:44:34  thoth
// added new constructor from float(*)(IA_Point<double>).
// added operator=(FCI).
//
// Revision 1.2  1994/01/07  15:10:00  thoth
// Image class is now CoreImage and named image types are
// Image<P,T>.
//
// Revision 1.1  1993/10/20  18:58:47  thoth
// Initial revision
//

#ifndef FloatCI_h_
#define FloatCI_h_

#include "CoreImage.h"
#include "DblPS.h"

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

class IA_Image<IA_Point<double>,float>
: public IA_CoreImage<IA_Point<double>,float> {
public:
    IA_Image()
	:IA_CoreImage<IA_Point<double>,float>() { }
    IA_Image(const IA_Image<IA_Point<double>,float> &fci)
	:IA_CoreImage<IA_Point<double>,float>(fci) { }
    IA_Image(const IA_CoreImage<IA_Point<double>,float> &fci)
	:IA_CoreImage<IA_Point<double>,float>(fci) { }
    IA_Image(IA_Set<IA_Point<double> > ps, float value)
	:IA_CoreImage<IA_Point<double>,float>(ps,(float)value) {}
    IA_Image(IA_Set<IA_Point<double> > ps, float *vp, unsigned sz,
	     int giveaway=0)
	:IA_CoreImage<IA_Point<double>,float>(ps, vp, sz, giveaway) {}

    IA_Image(const IA_ClosureI<IA_Point<double>,float>& i)
	:IA_CoreImage<IA_Point<double>,float>(i) { }

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

    IA_Image(IA_Set<IA_Point<double> > ps, float (*f)(IA_Point<double>))
	:IA_CoreImage<IA_Point<double>,float>(ps,f) {}

    virtual ~IA_Image(){ }

    IA_Image& operator =(const IA_CoreImage<IA_Point<double>,float> &arg) {
	(IA_CoreImage<IA_Point<double>,float>&)*this = arg;
	return *this;
    }
    
    IA_Image<IA_Point<double>,float>& operator=(float v) {
	float	temp=v;		// workaround CFront problem
	(IA_CoreImage<IA_Point<double>,float>&)*this = temp;
	return *this;
    }
};

#endif
@


1.7.1.1
log
@CoreImage has been re-merged with Image.  All special stuff should be
friends of FBI now.
@
text
@a10 6
// Revision 1.7  1994/12/14  16:39:08  fjsoria
// constructor in IA_Image<IA_Point<double>,float>
// looked like IA_Image<IA_Point<double>,float>
// () {...}; instead of IA_Image(){}; cfront did not
// catch this
//
d35 1
a35 1
//#include "Image.h"
d41 1
a41 1
#if 0
d43 1
a43 1
: public IA_Image<IA_Point<double>,float> {
d46 1
a46 3
	:IA_Image<IA_Point<double>,float>() { }
    IA_Image(const IA_Image<IA_Point<double>,float> &fci)
	:IA_Image<IA_Point<double>,float>(fci) { }
d48 3
a50 1
	:IA_Image<IA_Point<double>,float>(fci) { }
d52 1
a52 1
	:IA_Image<IA_Point<double>,float>(ps,(float)value) {}
d55 1
a55 1
	:IA_Image<IA_Point<double>,float>(ps, vp, sz, giveaway) {}
d58 1
a58 1
	:IA_Image<IA_Point<double>,float>(i) { }
d61 1
a61 1
	:IA_Image<IA_Point<double>,float>(ps,f) {}
d64 1
a64 1
	:IA_Image<IA_Point<double>,float>(ps,f) {}
d68 2
a69 2
    IA_Image& operator =(const IA_Image<IA_Point<double>,float> &arg) {
	(IA_Image<IA_Point<double>,float>&)*this = arg;
d75 1
a75 1
	(IA_Image<IA_Point<double>,float>&)*this = temp;
a78 1
#endif
@


1.6
log
@Added a 0-argument constructor.
@
text
@d11 3
d45 1
a45 1
    IA_Image<IA_Point<double>,float>()
@


1.5
log
@DOS-inspired name rework.
@
text
@d11 3
d39 5
a43 3
class IA_Image<IA_Point<double>,float>: public IA_CoreImage<IA_Point<double>,float> {
  public:
//    IA_Image<IA_Point<double>,float>() {}
d45 1
a45 1
    :IA_CoreImage<IA_Point<double>,float>(fci) { }
d47 1
a47 1
    :IA_CoreImage<IA_Point<double>,float>(fci) { }
d49 1
a49 1
    :IA_CoreImage<IA_Point<double>,float>(ps,(float)value) {}
d51 2
a52 2
			  int giveaway=0)
    :IA_CoreImage<IA_Point<double>,float>(ps, vp, sz, giveaway) {}
d55 1
a55 1
    :IA_CoreImage<IA_Point<double>,float>(i) { }
d58 1
a58 1
    :IA_CoreImage<IA_Point<double>,float>(ps,f) {}
d61 1
a61 1
    :IA_CoreImage<IA_Point<double>,float>(ps,f) {}
@


1.4
log
@Name sanitization
@
text
@d11 3
d30 1
a30 1
#include "DoublePointSet.h"
@


1.4.1.1
log
@*** empty log message ***
@
text
@a10 6
// Revision 1.4  1994/07/25  17:26:39  thoth
// Name sanitization
//
// Revision 1.4  1994/07/25  17:26:39  thoth
// Name sanitization
//
@


1.3
log
@added new constructor from float(*)(IA_FloatPoint).
added operator=(FCI).
@
text
@d11 4
d27 1
a27 1
#include "FloatPointSet.h"
d33 1
a33 1
class IA_Image<IA_FloatPoint,float>: public IA_CoreImage<IA_FloatPoint,float> {
d35 8
a42 8
//    IA_Image<IA_FloatPoint,float>() {}
    IA_Image(const IA_Image<IA_FloatPoint,float> &fci)
    :IA_CoreImage<IA_FloatPoint,float>(fci) { }
    IA_Image(const IA_CoreImage<IA_FloatPoint,float> &fci)
    :IA_CoreImage<IA_FloatPoint,float>(fci) { }
    IA_Image(IA_FloatPointSet ps, float value)
    :IA_CoreImage<IA_FloatPoint,float>(ps,(float)value) {}
    IA_Image(IA_FloatPointSet ps, float *vp, unsigned sz,
d44 1
a44 1
    :IA_CoreImage<IA_FloatPoint,float>(ps, vp, sz, giveaway) {}
d46 2
a47 2
    IA_Image(const IA_ClosureI<IA_FloatPoint,float>& i)
    :IA_CoreImage<IA_FloatPoint,float>(i) { }
d49 2
a50 2
    IA_Image(IA_FloatPointSet ps, float (*f)(const IA_FloatPoint&))
    :IA_CoreImage<IA_FloatPoint,float>(ps,f) {}
d52 2
a53 2
    IA_Image(IA_FloatPointSet ps, float (*f)(IA_FloatPoint))
    :IA_CoreImage<IA_FloatPoint,float>(ps,f) {}
d57 2
a58 2
    IA_Image& operator =(const IA_CoreImage<IA_FloatPoint,float> &arg) {
	(IA_CoreImage<IA_FloatPoint,float>&)*this = arg;
d62 1
a62 1
    IA_Image<IA_FloatPoint,float>& operator=(float v) {
d64 1
a64 1
	(IA_CoreImage<IA_FloatPoint,float>&)*this = temp;
@


1.2
log
@Image class is now CoreImage and named image types are
Image<P,T>.
@
text
@d11 4
d34 2
d48 2
a49 2
    IA_Image( const IA_CoreImage<IA_FloatPoint,float> &d)
    :IA_CoreImage<IA_FloatPoint,float>(d) {}
d53 5
@


1.1
log
@Initial revision
@
text
@d10 4
a13 1
// $Log:	FloatCI.h,v $
d18 4
d23 1
a23 1
#include "FloatPointSet.h"
d25 1
a25 1
class IA_FloatContinuousImage: public IA_Image<IA_FloatPoint,float> {
d27 6
a32 6
//    IA_FloatContinuousImage() {}
    IA_FloatContinuousImage(const IA_FloatContinuousImage &fci)
    :IA_Image<IA_FloatPoint,float>(fci) { }
    IA_FloatContinuousImage(IA_FloatPointSet ps, float value)
    :IA_Image<IA_FloatPoint,float>(ps,(float)value) {}
    IA_FloatContinuousImage(IA_FloatPointSet ps, float *vp, unsigned sz,
d34 1
a34 1
    :IA_Image<IA_FloatPoint,float>(ps, vp, sz, giveaway) {}
d36 2
a37 2
    IA_FloatContinuousImage(const IA_ClosureI<IA_FloatPoint,float>& i)
    :IA_Image<IA_FloatPoint,float>(i) { }
d39 2
a40 2
    IA_FloatContinuousImage(IA_FloatPointSet ps, float (*f)(const IA_FloatPoint&))
    :IA_Image<IA_FloatPoint,float>(ps,f) {}
d42 2
a43 2
    IA_FloatContinuousImage( const IA_Image<IA_FloatPoint,float> &d)
    :IA_Image<IA_FloatPoint,float>(d) {}
d45 1
a45 1
    virtual ~IA_FloatContinuousImage(){ }
d47 3
a49 2
    IA_FloatContinuousImage& operator=(float v) {
	(IA_Image<IA_FloatPoint,float>&)*this = v;
@
