Namespaces
	config

	mapperUtils

	skyTileUtils

Classes
class	Arena

class	CsvReader

class	CsvWriter

struct	CsvControl
	Parameters that define a Character-Separated-Value dialect. More...

struct	CsvConversionControl
	Catalog to CSV conversion parameters. More...

class	PT1SkyTile

class	SmallPtrVector

Functions
void	writeCsv (BaseCatalog const &catalog, CsvConversionControl const &cnvControl, CsvControl const &csvControl, std::string const &csvFile, bool truncate, bool append)

Eigen::Vector3d const	earthPosition (double const epoch)

void	makeSourceHistogram (lsst::afw::image::Image< unsigned short >::Ptr histogram, lsst::afw::table::SourceCatalog const &sources, lsst::afw::image::Wcs::Ptr wcs, bool ignoreOffImage)

void	rasterizePolygon (std::vector< Point2D > const &verts, lsst::afw::image::Image< float >::Ptr img)

void	updateCoverageMap (lsst::afw::image::Image< float >::Ptr covMap, lsst::afw::image::Wcs::Ptr covMapWcs, lsst::afw::image::Wcs::Ptr wcs, int width, int height, int step)

void	thetaRangeReduce (Angle &min, Angle &max)

Angle const	maxAlpha (Angle radius, Angle centerPhi)

void	positionAndVelocity (Eigen::Vector3d &p, Eigen::Vector3d &v, Angle ra, Angle decl, double muRa, double muDecl, double vRadial, Angle parallax)

Eigen::Vector2d const	cartesianToSpherical (Eigen::Vector3d const &v)

template<>
std::string	CsvReader::_null< std::string > ()

template<>
std::string	CsvReader::_get< std::string > (char const *field) const

template<typename T >
CsvWriter &	operator<< (CsvWriter &w, T const &v)

CsvWriter &	endr (CsvWriter &w)

CsvWriter &	flush (CsvWriter &w)

CsvWriter &	nullf (CsvWriter &w)

template<typename T >
CsvWriter &	operator<< (CsvWriter &w, CsvWriter &(*manip)(CsvWriter &))

template<typename T >
CsvWriter &	operator<< (CsvWriter &, CsvWriter &(*)(CsvWriter &))

void	writeCsv (lsst::afw::table::BaseCatalog const &catalog, CsvConversionControl const &cnvControl, CsvControl const &csvControl, std::string const &csvFile, bool truncate, bool append)
	Convert an afw Catalog to a CSV file. More...

void	rasterizePolygon (std::vector< lsst::afw::geom::Point2D > const &verts, lsst::afw::image::Image< float >::Ptr img)

lsst::afw::geom::Angle const	clampPhi (lsst::afw::geom::Angle const a)

lsst::afw::coord::IcrsCoord const	cartesianToIcrs (Eigen::Vector3d const &v)

lsst::afw::geom::Angle const	angularSeparation (Eigen::Vector3d const &v1, Eigen::Vector3d const &v2)

Function Documentation

lsst::afw::geom::Angle const lsst::ap::utils::angularSeparation	(	Eigen::Vector3d const &	v1,
		Eigen::Vector3d const &	v2
	)

inline

Returns the angular separation between two 3-vectors of arbitrary magnitude.

Definition at line 83 of file SpatialUtils.h.

 {
     using lsst::afw::geom::Angle;
     using lsst::afw::geom::radians;
 
     double ss = v1.cross(v2).norm();
     double cs = v1.dot(v2);
     if (ss != 0.0 || cs != 0.0) {
         return Angle(std::atan2(ss, cs), radians);
     }
     return Angle(0.0, radians);
 }

lsst::afw::coord::IcrsCoord const lsst::ap::utils::cartesianToIcrs ( Eigen::Vector3d const & v )

inline

Definition at line 74 of file SpatialUtils.h.

                                                                            {
     Eigen::Vector2d sc = cartesianToSpherical(v);
     return lsst::afw::coord::IcrsCoord(sc.x() * lsst::afw::geom::radians,
                                        sc.y() * lsst::afw::geom::radians);
 }

Eigen::Vector2d const lsst::ap::utils::cartesianToSpherical ( Eigen::Vector3d const & v )

Converts the input position vector, which need not have unit magnitude, to spherical coordinates (rad).

Definition at line 161 of file SpatialUtils.cc.

                                                                  {
     double d2 = v.x()*v.x() + v.y()*v.y();
     double theta = (d2 == 0.0) ? 0.0 : std::atan2(v.y(), v.x());
     double phi = (v.z() == 0.0) ? 0.0 : std::atan2(v.z(), std::sqrt(d2));
     return Eigen::Vector2d(theta, phi);
 }

lsst::afw::geom::Angle const lsst::ap::utils::clampPhi ( lsst::afw::geom::Angle const a )

inline

Clamps the given latitude/declination to [-PI/2, PI/2] radians.

Definition at line 45 of file SpatialUtils.h.

                                                                  {
     using lsst::afw::geom::Angle;
     using lsst::afw::geom::radians;
     using lsst::afw::geom::HALFPI;
 
     if (a.asRadians() < -HALFPI) {
         return Angle(-HALFPI, radians);
     } else if (a.asRadians() > HALFPI) {
         return Angle(HALFPI, radians);
     }
     return a;
 }

template<>

std::string lsst::ap::utils::CsvReader::_get< std::string > ( char const * field ) const

inline

Definition at line 243 of file Csv.cc.

                                                                    {
     return std::string(field);
 }

template<>

std::string lsst::ap::utils::CsvReader::_null< std::string > ( )

inline

Definition at line 193 of file Csv.cc.

                                                          {
     return std::string();
 }

Eigen::Vector3d const lsst::ap::utils::earthPosition ( double const epoch )

Returns the barycentric coordinates (in AU) of the earth at the specified epoch. Note that this is a relatively expensive function - one invocation will result in the evaluation of several thousand cosines. The cost is independent of the input epoch, but the accuracy of the method deteriorates for epochs not in the 1900-2100 timespan.

This function is nearly identical to the IAU SOFA iauEpv00 C astronomy library routine, available at: http://www.iausofa.org/2009_1231_C/sofa/epv00.c

It differs from the IAU reference function in the following ways:

Only the barycentric coordinates of the earth are computed. The IAU function computes both barycentric and heliocentric earth positions and velocities.

The computation is organized into easily vectorizable loops, at the cost of a small amount of stack space.

The input epoch is expected to be in MJD rather than JD.

Rather than being layed out in AOS form as (amplitude, phase, frequency) triplets, the internal model coefficients are arranged in SOA form, i.e. as arrays of amplitudes, phases, and frequencies.

Comparisons of the IAU iauEpv00() function with the JPL DE405 ephemeris over the 1900-2100 time span yields a maximum deviation of 13.4 km with an RMS of 4.6 km. Comparisons with the JPL DE406 ephemeris show that by 1800 and 2200 the position errors are approximately double their 1900-2100 size. By 1500 and 2500 the deterioration is a factor of 10 and by 1000 and 3000 a factor of 60.

Parameters

epoch epoch, MJD TDB. Using TT is acceptable for most applications.

Definition at line 1794 of file EarthPosition.cc.

   {
     // maximum number of coeffs is 501, pad to the next power of 2.
     double angle[512];
     double tmp[512];
     double earth[3];
 
     // Compute time delta t from reference epoch (J2000) in Julian years
     double const t = (epoch - J2000_MJD) / DAYS_PER_JY;
     double const t2 = t*t;
 
     for (int i = 0; i < 3; i++) {
         // Obtain component of Sun to Earth ecliptic vector
         // t^0 terms
         size_t n = NTERMS_SUN_TO_EARTH_T0[i];
         double const *amp = COEFFS_SUN_TO_EARTH_T0[i][0];
         double const *phase = COEFFS_SUN_TO_EARTH_T0[i][1];
         double const *freq = COEFFS_SUN_TO_EARTH_T0[i][2];
         double coord = 0.0;
         for (size_t j = 0; j < n; ++j) {
             angle[j] = phase[j] + t*freq[j];
         }
         for (size_t j = 0; j < n; ++j) {
             tmp[j] = std::cos(angle[j]);
         }
         for (size_t j = 0; j < n; ++j) {
             coord += amp[j]*tmp[j];
         }
         // t^1 terms
         n = NTERMS_SUN_TO_EARTH_T1[i];
         amp = COEFFS_SUN_TO_EARTH_T1[i][0];
         phase = COEFFS_SUN_TO_EARTH_T1[i][1];
         freq = COEFFS_SUN_TO_EARTH_T1[i][2];
         for (size_t j = 0; j < n; ++j) {
             angle[j] = phase[j] + t*freq[j];
         }
         for (size_t j = 0; j < n; ++j) {
             tmp[j] = std::cos(angle[j]);
         }
         for (size_t j = 0; j < n; ++j) {
             coord += amp[j]*t*tmp[j];
         }
         // t^2 terms
         n = NTERMS_SUN_TO_EARTH_T2[i];
         amp = COEFFS_SUN_TO_EARTH_T2[i][0];
         phase = COEFFS_SUN_TO_EARTH_T2[i][1];
         freq = COEFFS_SUN_TO_EARTH_T2[i][2];
         for (size_t j = 0; j < n; ++j) {
             angle[j] = phase[j] + t*freq[j];
         }
         for (size_t j = 0; j < n; ++j) {
             tmp[j] = std::cos(angle[j]);
         }
         for (size_t j = 0; j < n; ++j) {
             coord += amp[j]*t2*tmp[j];
         }
         // Add component of SSB to Sun ecliptic vector
         // t^0 terms
         n = NTERMS_SSB_TO_SUN_T0[i];
         amp = COEFFS_SSB_TO_SUN_T0[i][0];
         phase = COEFFS_SSB_TO_SUN_T0[i][1];
         freq = COEFFS_SSB_TO_SUN_T0[i][2];
         for (size_t j = 0; j < n; ++j) {
             angle[j] = phase[j] + t*freq[j];
         }
         for (size_t j = 0; j < n; ++j) {
             tmp[j] = std::cos(angle[j]);
         }
         for (size_t j = 0; j < n; ++j) {
             coord += amp[j]*tmp[j];
         }
         // t^1 terms
         n = NTERMS_SSB_TO_SUN_T1[i];
         amp = COEFFS_SSB_TO_SUN_T1[i][0];
         phase = COEFFS_SSB_TO_SUN_T1[i][1];
         freq = COEFFS_SSB_TO_SUN_T1[i][2];
         for (size_t j = 0; j < n; ++j) {
             angle[j] = phase[j] + t*freq[j];
         }
         for (size_t j = 0; j < n; ++j) {
             tmp[j] = std::cos(angle[j]);
         }
         for (size_t j = 0; j < n; ++j) {
             coord += amp[j]*t*tmp[j];
         }
         // t^2 terms
         n = NTERMS_SSB_TO_SUN_T2[i];
         amp = COEFFS_SSB_TO_SUN_T2[i][0];
         phase = COEFFS_SSB_TO_SUN_T2[i][1];
         freq = COEFFS_SSB_TO_SUN_T2[i][2];
         for (size_t j = 0; j < n; ++j) {
             angle[j] = phase[j] + t*freq[j];
         }
         for (size_t j = 0; j < n; ++j) {
             tmp[j] = std::cos(angle[j]);
         }
         for (size_t j = 0; j < n; ++j) {
             coord += amp[j]*t2*tmp[j];
         }
         earth[i] = coord;
     }
 
     // Rotate from ecliptic to BCRS coordinates
     return Eigen::Vector3d(
              earth[0] + AM12*earth[1] + AM13*earth[2],
         AM21*earth[0] + AM22*earth[1] + AM23*earth[2],
                         AM32*earth[1] + AM33*earth[2]
     );
 }

CsvWriter & lsst::ap::utils::endr ( CsvWriter & w )

inline

Manipulator to end a CSV record.

Definition at line 330 of file Csv.cc.

                                       {
     w.endRecord();
     return w;
 }

CsvWriter & lsst::ap::utils::flush ( CsvWriter & w )

inline

Manipulator to flush a CSV writer.

Definition at line 337 of file Csv.cc.

                                        {
     w.flush();
     return w;
 }

void lsst::ap::utils::makeSourceHistogram	(	lsst::afw::image::Image< unsigned short >::Ptr	histogram,
		lsst::afw::table::SourceCatalog const &	sources,
		lsst::afw::image::Wcs::Ptr	wcs,
		bool	ignoreOffImage
	)

Fills in a histogram of positions for the given sources. The value of each histogram pixel is set to the number of sources falling within that pixel. Sources falling outside the histogram image are either ignored or cause an exception to be raised.

Parameters

[in,out]	histogram	Histogram image to update.
[in]	sources	Sources to generate a position histogram from.
[in]	wcs	WCS of histogram image.
[in]	ignoreOffImage	If true ignore off image sources, otherwise raise an exception.

Definition at line 412 of file ImageUtils.cc.

 {
     typedef table::SourceCatalog::const_iterator SourceIter;
     for (SourceIter i = sources.begin(), e = sources.end(); i != e; ++i) {
         Point2D xy = wcs->skyToPixel(i->getCoord());
         int x = histogram->positionToIndex(xy[0], image::X).first;
         int y = histogram->positionToIndex(xy[1], image::Y).first;
         if (x < 0 || x >= histogram->getWidth() ||
             y < 0 || y >= histogram->getHeight()) {
             if (!ignoreOffImage) {
                 throw LSST_EXCEPT(except::RuntimeError,
                                   "SourceCatalog contains sources lying "
                                   "outside the histogram image");
             }
             continue;
         }
         histogram->operator()(x, y) += 1;
     }
 }

lsst::afw::geom::Angle const lsst::ap::utils::maxAlpha	(	Angle	radius,
		Angle	centerPhi
	)

Computes the extent in longitude angle [-alpha, alpha] of the circle with radius radius and center at latitude angle centerPhi.

Precondition: radius >= 0.0 && radius <= PI/2

Note that centerPhi is clamped to lie in [-PI/2, PI/2].

Parameters

radius	circle radius
centerPhi	latitude angle of circle center

Definition at line 79 of file SpatialUtils.cc.

   {
     static const double POLE_EPSILON = 1e-7;
 
     if (radius < 0.0 || radius > HALFPI) {
         throw LSST_EXCEPT(InvalidParameterError,
                           "radius must be in range [0, PI/2] deg");
     }
     if (radius == 0.0) {
         return 0.0 * radians;
     }
     centerPhi = clampPhi(centerPhi);
     if (std::fabs(centerPhi.asRadians()) + radius.asRadians() > HALFPI - POLE_EPSILON) {
         return PI*(1 + 2.0*DBL_EPSILON) * radians;
     }
     double y = std::sin(radius.asRadians());
     double x = std::sqrt(std::fabs(std::cos(centerPhi.asRadians() - radius.asRadians()) *
                                    std::cos(centerPhi.asRadians() + radius.asRadians())));
     return std::fabs(std::atan(y / x)) * radians;
 }

CsvWriter & lsst::ap::utils::nullf ( CsvWriter & w )

inline

Manipulator to append a NULL field to a CSV writer.

Definition at line 344 of file Csv.cc.

                                        {
     w.appendNull();
     return w;
 }

template<typename T >

CsvWriter& lsst::ap::utils::operator<<	(	CsvWriter &	,
		CsvWriter &	*)(CsvWriter &
	)

inline

template<typename T >

CsvWriter & lsst::ap::utils::operator<<	(	CsvWriter &	w,
		T const &	v
	)

inline

Formatted output operator for CSV writers.

Definition at line 323 of file Csv.cc.

                                                         {
     w.appendField(v);
     return w;
 }

template<typename T >

CsvWriter& lsst::ap::utils::operator<<	(	CsvWriter &	w,
		CsvWriter &(*)(CsvWriter &)	manip
	)

inline

Output operator that applies a manipulator to a CSV writer.

Definition at line 352 of file Csv.cc.

                                                                             {
     return manip(w);
 }

void lsst::ap::utils::positionAndVelocity	(	Eigen::Vector3d &	p,
		Eigen::Vector3d &	v,
		Angle	ra,
		Angle	decl,
		double	muRa,
		double	muDecl,
		double	vRadial,
		Angle	parallax
	)

Converts from spherical coordinates, proper motions, parallax and radial velocity to position (AU) and velocity (AU/day) 3-vectors.

: See the following paper for details:

: Rigorous Computation of Proper Motions and their Effects on Star Positions Eichhorn, H. & Rust, A. Journal: Astronomische Nachrichten, volume 292, p.37 Bibliographic Code: 1970AN....292...37E

: A more accurate approach (including special-relativistic effects) is discussed in Stumpff, P., 1985, Astron.Astrophys. 144, 232-240 and implemented in the IAU SOFA astronomy library iauStarpv C routine available here: http://www.iausofa.org/2009_1231_C/sofa/starpv.c

: Note that the input and output data are for an observer situated at the solar system barycenter.

See Also: earthPosition(double)

Parameters

[out]	p	position, AU
[out]	v	velocity, AU/day
	ra	right ascension
	decl	declination
	muRa	proper motion in RA, rad/day
	muDecl	proper motion in Dec, rad/day
	vRadial	radial velocity, AU/day
	parallax	parallax

Definition at line 126 of file SpatialUtils.cc.

   {
     // distance (AU)
     double r = 1.0 / parallax.asRadians();
 
     // convert to position and velocity vector (AU, AU/day)
     double sinRa = sin(ra.asRadians());
     double cosRa = cos(ra.asRadians());
     double sinDecl = sin(decl.asRadians());
     double cosDecl = cos(decl.asRadians());
     double s = r*cosDecl;
     double t = r*muDecl*sinDecl;
     double u = cosDecl*vRadial;
     p = Eigen::Vector3d(s*cosRa, s*sinRa, r*sinDecl);
     v = Eigen::Vector3d(cosRa*u - p.y()*muRa - cosRa*t,
                         sinRa*u + p.x()*muRa - sinRa*t,
                         sinDecl*vRadial + s*muDecl);
     if (v.squaredNorm() > 0.25*C_AU_PER_DAY*C_AU_PER_DAY) {
         throw LSST_EXCEPT(RuntimeError,
                           "star velocity vector magnitude exceeds half "
                           "the speed of light");
     }
 }

void lsst::ap::utils::rasterizePolygon	(	std::vector< lsst::afw::geom::Point2D > const &	verts,
		lsst::afw::image::Image< float >::Ptr	img
	)

void lsst::ap::utils::rasterizePolygon	(	std::vector< Point2D > const &	verts,
		lsst::afw::image::Image< float >::Ptr	img
	)

Rasterizes the (not necessarily convex) polygon obtained by connecting the the given vertices. For each pixel in the output image, the fraction of the pixel area overlapping the input polygon is stored.

Parameters

[in,out]	img	Image to rasterize to.
[in]	verts	Polygon vertices

Definition at line 443 of file ImageUtils.cc.

 {
     typedef std::vector<Point2D>::const_iterator VertexIter;
     typedef std::vector<Edge>::iterator EdgeIter;
 
     if (img->getWidth() <= 0 || img->getHeight() <= 0) {
         throw LSST_EXCEPT(except::InvalidParameterError,
                               "image width/height must be at least 1");
     }
     if (verts.size() < 3) {
         throw LSST_EXCEPT(except::InvalidParameterError,
                               "polygon must have at least 3 vertices");
     }
     std::vector<Edge> edges;
     edges.reserve(verts.size());
     double minY = image::indexToPosition(0) - 0.5;
     double maxY = image::indexToPosition(img->getHeight()) - 0.5;
     for (VertexIter v2 = verts.begin(), e = verts.end(), v1 = e - 1;
          v2 != e; ++v2) {
         VertexIter v = v1;
         v1 = v2;
         if (v->getY() == v2->getY()) {
             continue; // omit horizontal and degenerate edges
         } else if (v->getY() < v2->getY()) {
             if (v->getY() >= maxY || v2->getY() < minY) {
                 continue; // edge not in y-range
             }
         } else {
             if (v2->getY() >= maxY || v->getY() < minY) {
                 continue; // edge not in y-range
             }
         }
         edges.push_back(Edge(*v, *v2));
     }
     if (edges.size() > 0) {
         std::sort(edges.begin(), edges.end());
         SweepLine sweeper(img, edges.front().v1->getY());
         EdgeIter i = edges.begin(), e = edges.end();
         // add all edges intersecting minY to sweep line
         for (; i != e && i->v1->getY() <= minY; ++i) {
             sweeper.add(*i);
         }
         while (i != e) {
             double y = i->v1->getY();
             sweeper.advance(y);
             sweeper.add(*i);
             for (++i; i != e && i->v1->getY() == y; ++i) {
                 sweeper.add(*i);
             }
         }
         sweeper.finish();
     }
 }

void lsst::ap::utils::thetaRangeReduce	(	Angle &	min,
		Angle &	max
	)

Reduces a theta (longitude/right-ascension) range. The resulting range will have min > max if it wraps across the 0/2*PI radiandiscontinuity. Valid inputs are:

any min, max with min <= max
min > max so long as min <= 2*PI && max >= 0.0

Definition at line 56 of file SpatialUtils.cc.

                                               {
     if (min > max) {
         if (max < 0.0 || min >= TWOPI) {
             throw LSST_EXCEPT(InvalidParameterError,
                               "Invalid longitude angle interval");
         }
     } else if (max - min >= TWOPI) {
         min = 0.0 * radians;
         max = TWOPI * radians;
     } else if (min < 0.0 || max >= TWOPI) {
         // range reduce
         min.wrap();
         max.wrap();
     }
 }

void lsst::ap::utils::updateCoverageMap	(	lsst::afw::image::Image< float >::Ptr	covMap,
		lsst::afw::image::Wcs::Ptr	covMapWcs,
		lsst::afw::image::Wcs::Ptr	wcs,
		int	width,
		int	height,
		int	step
	)

Updates a coverage map to include contributions from the given image (specified by a WCS and a pair of dimensions).

Parameters

[in,out]	covMap	Coverage map to update.
[in]	covMapWcs	WCS of coverage map.
[in]	wcs	WCS of image to rasterize.
[in]	width	Width of image to rasterize.
[in]	height	Height of image to rasterize.
[in]	step	If <= 0, the input image is rasterized as a polygon formed by connecting the positions of the 4 image corners with straight lines in coverage-map pixel space. Otherwise, the boundary of the input image is rasterize by connecting step boundary pixels at a time (corners are always included).

Definition at line 515 of file ImageUtils.cc.

 {
     typedef std::vector<Point2D>::iterator VertexIter;
     if (width <= 0 || height <= 0) {
         throw LSST_EXCEPT(except::InvalidParameterError,
                               "Width/height of input image must be positive");
     }
     std::vector<Point2D> v;
     if (step <= 0) {
         v.reserve(4);
         v.push_back(Point2D(-0.5, -0.5));
         v.push_back(Point2D(width - 0.5, -0.5));
         v.push_back(Point2D(width - 0.5, height - 0.5));
         v.push_back(Point2D(-0.5, height - 0.5));
     } else {
         v.reserve(2 * width + 2 * height + 2);
         for (int i = 0; i < width; i += step) {
             v.push_back(Point2D(i - 0.5, -0.5));
         }
         for (int i = 0; i < height; i += step) {
             v.push_back(Point2D(width - 0.5, i - 0.5));
         }
         for (int i = width; i > 0; i -= step) {
             v.push_back(Point2D(i - 0.5, height - 0.5));
         }
         for (int i = height; i > 0; i -= step) {
             v.push_back(Point2D(-0.5, i - 0.5));
         }
     }
     // Convert from image pixel space to coverage map pixel space.
     for (VertexIter i = v.begin(), e = v.end(); i != e; ++i) {
         *i = covMapWcs->skyToPixel(*wcs->pixelToSky(*i));
     }
     // rasterize polygon
     rasterizePolygon(v, covMap);
 }

void lsst::ap::utils::writeCsv	(	lsst::afw::table::BaseCatalog const &	catalog,
		CsvConversionControl const &	cnvControl,
		CsvControl const &	csvControl,
		std::string const &	csvFile,
		bool	truncate,
		bool	append
	)

Convert an afw Catalog to a CSV file.

Parameters

	catalog
[in]	catalog	Catalog to convert.
	cnvControl
[in]	cnvControl	Conversion parameters.
	csvControl
[in]	csvControl	CSV dialect.
	csvFile
[in]	csvFile	Name of file to write to
	truncate
[in]	truncate	Truncate csvFile if it already exists?
	append
[in]	append	Append to csvFile if it exists and truncate is false?

void lsst::ap::utils::writeCsv	(	BaseCatalog const &	catalog,
		CsvConversionControl const &	cnvControl,
		CsvControl const &	csvControl,
		std::string const &	csvFile,
		bool	truncate,
		bool	append
	)

Definition at line 335 of file csvUtils.cc.

 {
     CsvWriter writer(csvFile, csvControl, truncate, append);
     Schema schema = catalog.getSchema();
     CsvConverter cnv(writer, schema, cnvControl);
     boost::reference_wrapper<CsvConverter> cnvRef = boost::ref(cnv);
     for (BaseCatalog::const_iterator i = catalog.begin(), e = catalog.end(); i != e; ++i) {
         cnv.startRecord(i);
         schema.forEach(cnvRef);
         cnv.endRecord();
     }
     writer.flush();
 }

Namespaces

Classes

Functions

Function Documentation