ProvisionSection.sml

  Download

More scripts: Pipeline

Syntax Highlighing:

comments, key words, predefined symbols, class members & methods, functions & classes
            
# ProvisionSection_test.sml
# Image provisioning script for extracting Nebraska orthoimage for Township, Range, and Section.
# Version 7 October 2013 for TNTmips 2014
#		- omits setting printable width/height of section layout;
#		 these class members are now read-only. 
# Version 6 June 2011
#		- fixes error trying to parse RVC path to set caption text.
# Version 5 June 2009 incorporating:
#		- User chooses T-R-Dir-Section, year of the orthoimagery, provides a title, and chooses whether
#		- to overlay the section boundary on the image.
# 	- Output is a zipped PDF file with otional section image / overlay, title above the image, and
#		- a caption with the section location and year of imagery.
#		- Script reprojects section to custom NED83 / Orthographic CRS centered on section
#		  to provide a section image with section boundary as parallel to extents as possible.
#		- Use Finish method to close the PDF file to allow it to be zipped.
#		- taskID appended to readme filename
#		- error notification procedure added to e-mail staff on specific errors  5 June 09 
#############################################################
# uncomment the following preprocessor command to run in test mode
# with hard-coded job parameters outside of the Job Control environment
$define TEST
############   Variables to be provided by the job file   #################
#string taskID$;
#string userEmail$;
string rvcPath$;		# string with filepath to source RVC file
string rvcObject$;	# string with name of RVC raster (not the object path)
string outFormat$;	# output file format
string limit$;				# size limit: possible values "tntlite" or "max"
numeric lossyComp;		# compression ratio for JP2 lossy compression, 0 for lossless
numeric boundary;		# flag indicating whether to draw section boundary
string township$;	# township number
string range$;			# range number
string direction$;	# range direction, E or W
string section$;		# section number
string title$;				# title for the image
################################################################
################  Job parameters for test mode  ###################
$ifdef TEST
#		string rvcPath$ =  _context.ScriptDir + "/provision/ProvisionNE.rvc";
#		string taskID$ = "50020";
#		string rvcObject$ = "NE 2006 NC UTM14 1m 15to1";
#		string outFormat$ = "PDF";
#		string userEmail$ = "rsmith@microimages.com";
		string limit$ = "max";
		numeric lossyComp = 15;
		numeric boundary = 1;
		string township$ = "32";
		string range$ = "47";
		string direction$	= "W";
		string section$ = "21";
		string title$ = "Kimball Farm";
$endif
##############################################################
############  Output format constrained to PDF  #####################
string outFormat$ = "PDF";
#############  VARIABLES FOR AUTOMATED TESTING  ####################
# read from control file
string correctfilepath$;						# path to file with correct output
string correctobjectpath$;					# object path to correct object
string vecFilename$;
#--------------------------------------
#string outfilepath$ = CreateTempFileName();		# temporary output file for non-rvc target
string rvcfilepath$ = CreateTempFileName();		# temporary project file for rvc target
#class FILEPATH outFilepath = outfilepath$;
class FILEPATH correctfile = correctfilepath$; 		# path to file with correct output
class RVC_OBJITEM outobjitem;
CreateProjectFile(rvcfilepath$, "Provision Section Test");
outobjitem.SetFilePath(rvcfilepath$);
outobjitem.SetObjectPath(correctobjectpath$);
class RVC_DESCRIPTOR desc;
desc.SetName(correctobjectpath$);
desc.SetDescription("Provision Section Test");
outobjitem.CreateNew(desc, "RASTER");
class RVC_RASTER RDest;
##################   Other variables   ###################
class RVC_RASTER RastIn;		# the source image raster
class REGION2D exRegion;		# region to use for extraction
class DATETIME currentDT;		# the current local date/time
class EMAIL_MESSAGE email;
class STRING logfileName$;
class STRING readmeFilename$;
class FILE logfile;
class FILE readme;
class STRING outpath$;			# path string for output www jobs directory
class STRING outDirPath$;		# path string for output directory created in www jobs directory
class FILEPATH outFilepath;	# filepath for output directory
class STRING outputFileExtension$;
numeric err;		# error value from defined functions
string error$;		# string with error text
class STRING tr$;				# Township-range identifier as direction$+township$+range$
class STRING year$;		# year of the selected orthoimage mosaic, for caption
class STRING caption$;		# text for caption below the section image
class ZIPFILE zip;
class FILEPATH zipFilepath;
string start$,  finish$;
class TIMER timer;
######  Variables for resampling to new cell size to meet image size limit #############
numeric numLins, numCols;		# number of lines and columns in extraction area
numeric totalCells;						# number of cells in extracted image
numeric limitCells;							# maximum allowed number of cells in output
class POINT2D rastScale;			# source raster x and y scales computed from georeference
numeric rescale;								# scale factor for rescaling line and column scales for output
string inCRS$;											# EPSG code for CRS of source image
string outCRS$;										# EPSG code for output, read from section table
class SR_COORDREFSYS inCRS;		# CRS of source image
class SR_COORDREFSYS outCRS;	# output CRS
# error notification procedure
proc notifyError(string err$) {
#	string php$ = "php c:/wamp/www/error.php " +  taskID$;
#	fprint(logfile, err$);
#	fclose(logfile);
#	fprint(readme, err$);
#	fclose(readme); 
#	email.SetSubject(sprintf("Error with provisioning job %s", taskID$) );
#	email.SetBody(err$);
#	email.SetRecipient("rsmith@microimages.com");
#	email.SendMail();
#	email.SetRecipient("rsmith943@windstream.net");
#	email.SendMail();
#	ExecuteProcess(php$);
#	Exit();
	}
# error checking procedure
proc ReportError(numeric linenum, numeric err) {
	print("FAILED -line: %d, error: %d\n", linenum - 1, err);
	Exit();  
	}
############################################################
########################  Program  ###########################
clear();
#timer.Running = 1;
### set up to run php scripts to write info to MySQL database
#start$ = "php c:/wamp/www/start.php " +  taskID$;
#finish$ = "php c:/wamp/www/finish.php " +  taskID$;
#ExecuteProcess(start$);
########################  Set up Log File  ######################
# open log file to append status information
#logfileName$ = _context.ScriptDir + "/Provisioning.log";
#logfile = fopen(logfileName$, "a");
#print("Logfile opened.");
#currentDT.SetCurrent();
#fprintf(logfile, "\nJob initiated %s Central Standard Time\n", currentDT);
#$ifdef TEST
		# print job info to console
#		printf("TaskID: %s\n", taskID$);
#		printf("User Email: %s\n", userEmail$);
#		printf("RVCpath: %s\n", rvcPath$);
#		printf("RVCobject: %s\n", rvcObject$);
#		printf("Selected output format: %s\n", outFormat$);
#		printf("Limit = %s\n", limit$);
#$endif
# print job info to log file
#fprintf(logfile, "TaskID: %s\n", taskID$);
#fprintf(logfile, "User Email: %s\n", userEmail$);
#fprintf(logfile, "RVCpath: %s\n", rvcPath$);
#fprintf(logfile, "RVCobject: %s\n", rvcObject$);
#fprintf(logfile, "Selected output format: %s\n", outFormat$);
#fprintf(logfile, "Limit = %s\n", limit$);
#####################  Other  File Handling  ######################
# set up output directory
#$ ifdef TEST
#			outpath$ = _context.ScriptDir + "/";
#$ else
#			outpath$ = "C:/wamp/www/jobs/"; 
#$ endif
#outDirPath$ = outpath$ + taskID$;		# new directory to be created for this job
#CreateDir(outDirPath$);						# create new directory
#outFilepath = outDirPath$ + "/" + taskID$;						# filepath for output file (minus extension)
# set filepath for zipfile in output directory
#if (outFormat$ == "KMZ") then
#	zipFilepath = outDirPath$ + "/" + taskID$ + ".kmz";
#else
#	zipFilepath = outDirPath$ + "/" + taskID$ + ".zip";
#readmeFilename$ = outDirPath$ + "/readme" + taskID$ + ".txt";
#$ifdef TEST											# delete previously existing zip file with same path/name
#	if ( fexists(zipFilepath) ) then
#		DeleteFile(zipFilepath);
#$endif
# open readme file
#readme = fopen(readmeFilename$, "a");
#fprintf(logfile, "New directory path: %s\n", outDirPath$);
#fprintf(logfile, "outFilepath = %s\n", outFilepath.GetPath() );
#fprintf(logfile, "Zip file path = %s\n", zipFilepath.GetPath() );
#fprintf(logfile, "readmeFilename$ = %s\n", readmeFilename$);
#$ifdef TEST
#		printf("New directory path: %s\n", outDirPath$);
#		printf("Zip file path = %s\n", zipFilepath.GetPath() + "/" +  zipFilepath.GetName() );
#		printf("readmeFilename$ = %s\n", readmeFilename$);
#$endif
# set up e-mail source
#email.SetSourceAddress("geoprovisioning@microimages.com");
#email.SetSourceName("GeoProvisioning at MicroImages.com");
#######################################################################
#####################  Make S-T-R caption for image  ########################
# year$ = GetToken(rvcPath$, "/\\", 2);
caption$ = sprintf("Township %s, Range %s %s, Section %s", township$, range$, direction$, section$); 
# caption$ = sprintf("%s\nNebraska %s", caption$, year$);
caption$ = sprintf("%s\nNebraska SML test", caption$);
#fprintf(logfile, "Caption: %s \n\n", caption$);
#######################################################################
######################  Modify strings for section search  ####################
if (strlen(township$) == 1) then township$ = "0" + township$;
if(strlen(range$) == 1) then range$ = "0" + range$; 
if(strlen(section$) == 1) then section$ = "0" + section$;
tr$ = direction$ + township$ + range$;		# make township-range string for TR field check
#fprintf(logfile, "TR search string: %s\n", tr$);
#########################################################################
###################  Find section polygon in section vector  ####################
class RVC_VECTOR sections;				# vector object with Nebraska sections in NAD83 / UTM zone 14N
#class STRING vecFilename$ = _context.ScriptDir + "/provision/NE_TRS_UTM14.rvc";
class STRING vecObjname$ = "NE_Sections_UTM14";
numeric numRecords;			# number of records
array numeric townshipList[1];		# array to hold list of records matching selected township-range
numeric i;					# counter to loop through list of records matching selected township-range
numeric recNum;		# current record number in the list
numeric numPolys;				# number of polygons attached to the matching section record (should be 1)
array numeric polyArray[1];		# array to hold the element numbers of polygons attached to the section record
numeric polyNum;				# the element number of the matching polygon
# open the vector object containing the sections
OpenVector(sections, vecFilename$, vecObjname$);
class GEOREF vectGeoref;
vectGeoref = GetLastUsedGeorefObject(sections);
#####  Find all records in section_poly table matching the selected township-range
numRecords = TableKeyFieldLookupList(sections.Poly.section_poly, "TR", tr$, townshipList, "Equals");
####  Search through the returned set of records for the one matching the requested section
for i = 1 to numRecords
	{
	recNum = townshipList[i];
	if (sections.Poly.section_poly[@recNum].SECTION_$ == section$)
		{ 
		numPolys = TableGetRecordElementList(sections.Poly.section_poly, recNum, polyArray);
		polyNum = polyArray[1];
		}
	}
# read latitude and longitude of center point of section from the table  
numeric centerLong = sections.Poly.section_poly[polyNum].LONG;
numeric centerLat = sections.Poly.section_poly[polyNum].LAT;
#fprintf(logfile, "Township-Range = %s, Section = %s\n", tr$, section$);
#fprintf(logfile, "%d records match the selected township-range\n", numRecords);
#fprintf(logfile, "%d polygons are attached to the section record\n", numPolys);
#fprintf(logfile, "The output CRS ID is %s\n", outCRS$); 
#$ifdef TEST
#		printf("Township-Range = %s, Section = %s\n", tr$, section$);
#		printf("%d records match the selected township-range\n", numRecords);
#		printf("%d polygons are attached to the section record\n", numPolys);
#		printf("Section center coordinates Lat = %.8f, Long = %.8f\n", centerLat, centerLong); 
#$endif
##########################################################################
##############  Create region from selected section polygon  #####################
class REGION2D sectionRegion;
sectionRegion = ConvertVectorPolyToRegion(sections, polyNum, vectGeoref); 
sections.Close();
#fprint(logfile, "Extents of area to extract in the source CRS: ");
#fprintf(logfile, "min x: %.6f, min y: %.6f, max x: %.6f, max y: %.6f\n", sectionRegion.Extents.x1, sectionRegion.Extents.y1, sectionRegion.Extents.x2, sectionRegion.Extents.y2);
#$ifdef TEST
#		print("Extents of area to extract in the source CRS: ");
#		printf("min x: %.6f, min y: %.6f, max x: %.6f, max y: %.6f\n", sectionRegion.Extents.x1, sectionRegion.Extents.y1, sectionRegion.Extents.x2, sectionRegion.Extents.y2);
#$endif
# get center point of section in map coordinates
class POINT2D centerPt;
centerPt = sectionRegion.GetCentroid();
####################################################################
#######################  Source Image  #################################
# open the input raster to get an RVC_OBJITEM to use to set up a pipeline source
OpenRaster(RastIn, rvcPath$, rvcObject$);
class RVC_OBJITEM sourceObjItem;
sourceObjItem = RastIn.GetObjItem();
RastIn.Close();
if (!sourceObjItem.IsExisting() ) {
	error$ = "Source raster cannot be found.";
	print("FAILED - source raster cannot be found.");
	Exit();
	}
##########################################################
##########  set up pipeline source for source image  #############
class IMAGE_PIPELINE_SOURCE_RVC sourceRVC(sourceObjItem);
err = sourceRVC.Initialize();
if (err < 0) 	{ 
	ReportError(_context.CurrentLineNum, err);
#	notifyError(error$);
	}
# get pipeline georeference from the source image
class IMAGE_PIPELINE_GEOREFERENCE georefSource;		# georeference from source
georefSource = sourceRVC.GetGeoreference();
inCRS = georefSource.GetCRS();
inCRS$ = "EPSG:" + inCRS.GetID("EPSG");
# get coordinate transformation from source image to its defined CRS
class TRANS2D_MAPGEN transImgToCRS = georefSource.GetTransGen();
# compute center point of extraction area in image coordinates
class POINT2D centerPtImg;
centerPtImg = transImgToCRS.ConvertPoint2DInv(centerPt);
# compute cell sizes (scales) at center of extraction area of source image from its georeference
georefSource.ComputeScale(centerPtImg, rastScale, 0);
#fprint(logfile, "\nSource raster info:");
#fprintf(logfile, "RastIn object name: %s\n\n", RastIn.$Info.Name);
#fprintf(logfile, "Raster cols: %d, lines: %d\n", sourceRVC.GetTotalColumns(), sourceRVC.GetTotalRows() );
#fprintf(logfile, "Source CRS: %s, %s\n", inCRS$, inCRS.Name);
#fprintf(logfile, "Native cell size of source image: x = %.3f, y = %.3f\n", rastScale.x, rastScale.y);
#fprint(readme, "Details of your provisioning order:");
#fprintf(readme, "You requested a %s image for Section %s, Township %s N, Range %s %s", year$, section$, township$, range$, direction$);
#fprintf(readme, "\nCoordinate Reference System of the source image: %s\n", inCRS.Name);
#fprintf(readme, "Native cell size of source image: x = %.3f, y = %.3f\n", rastScale.x, rastScale.y);
#$ifdef TEST
#		print("\nSource raster info:");
#		printf("RastIn object name: %s\n\n", RastIn.$Info.Name);
#		printf("Raster cols: %d, lines: %d\n", sourceRVC.GetTotalColumns(), sourceRVC.GetTotalRows() );
#		printf("Source CRS: %s, %s\n", inCRS$, inCRS.Name);
#		printf("Native cell size of source image: x = %.3f, y = %.3f\n", rastScale.x, rastScale.y);
#$endif
##############################################################
###############  check extraction area  ###########################
# get extents of the image source as a region
class REGION2D sourceRegion;
err = sourceRVC.ComputeGeoreferenceRegion(sourceRegion);
if (err < 0)  {
	ReportError(_context.CurrentLineNum, err);
	#notifyError(error$);
	}
#$ifdef TEST 
#		print("Source raster extents:");
#		printf("Min x: %.4f, Min y: %.4f, Max x: %.4f, Max y: %.4f\n",
#			sourceRegion.Extents.x1, sourceRegion.Extents.y1, sourceRegion.Extents.x2, sourceRegion.Extents.y2);
#$endif
# check that extraction region is contained within the source image extents region
if (sourceRegion.TestRegion(exRegion, "FullInside") )
	{
#	fprint(logfile, "Source image contains extraction extents.");
#	fprint(readme, "The source image contains the provided extraction extents.");
#	$ifdef TEST
#			print("Source image contains extraction extents.");
#	$endif
	}
else
	{
#	error$ = "Extraction areas is outside the extents of the source image. No extracted image was created.";
#	fprint(logfile, error$); 
#	fprint(readme, "The desired extraction area is outside the extents of the source image.");
#	fprint(readme, "No extracted image could be created.");
	$ifdef TEST
			print("FAILED - Extraction areas is outside the extents of the source image. No extracted image was created.");
			Exit();
	$endif
#	notifyError(error$);
#	return;
	}
##########################################################################
### Set up custom output CRS centered on the section  so the section outline 
### appears upright in the PDF file.
class SR_DATUM datum;
datum = inCRS.Datum;		# use NAD83 datum from input raster
class SR_COORDSYS outCoordSys;
outCoordSys.Assign("1200");		# assign using MicroImages numeric ID for Projected E and N, meters
# set up orthographic projection centered on the center of the section
#class SR_COORDOPMETHOD method("Orthographic");
class SR_COORDOPMETHOD method;
method.Assign("Orthographic");
class SR_COORDOPDEF projection;
projection.Method = method;
projection.SetParmValueNum("LatitudeOfNaturalOrigin", centerLat);
projection.SetParmValueNum("LongitudeOfNaturalOrigin", centerLong);
projection.SetParmValueNum("FalseEasting", 0);
projection.SetParmValueNum("FalseNorthing", 0);
#caption$ = sprintf("%s\nNAD83 / %s", caption$, "Orthographic");
outCRS.Create(outCoordSys, datum, projection);
sectionRegion.ConvertTo(outCRS);
#$ifdef TEST
#			printf("The section extract will be reprojected to %s\n", outCRS.Name);
#$endif
##########################################################################
##################   Compute buffered extents of section  ######################
class RECT exRect;		# extents of the section image in output map coordinates
exRect = sectionRegion.Extents;
exRect.Expand(100, 100);
###########################################################################
##################  Compute output image dimensions  #########################
numLins = abs(round( (exRect.y2 - exRect.y1) / rastScale.y) );
numCols = round( (exRect.x2 - exRect.x1) / rastScale.x);
class IMAGE_PIPELINE_DIMENSIONS dimensions;			# set output image dimensions for pipeline
dimensions.SetTotalDimensions(numCols, numLins);
#fprint(logfile, "Extents of the extraction area in the output coordinate reference system:");
#fprintf(logfile, "Min x: %.4f, Min y: %.4f, Max x: %.4f, Max y: %.4f\n", exRect.x1, exRect.y1, exRect.x2, exRect.y2);
#fprintf(logfile, "Output image dimensions at native cell size: %d lines, %d columns\n", numLins, numCols); 
#$ifdef TEST
#		print("Extents of the extraction area in the output coordinate reference system:"); 
#		printf("Min x: %.4f, Min y: %.4f, Max x: %.4f, Max y: %.4f\n", exRect.x1, exRect.y1, exRect.x2, exRect.y2);
#		printf("Output image dimensions at native cell size: %d lines, %d columns\n", numLins, numCols);
#$endif
#################################################################
##############   Set up affine georeference for target image  ############# 
class TRANS2D_AFFINE transAffine;
transAffine.ApplyScale(rastScale.x, rastScale.y);
transAffine.ApplyOffset(exRect.x1, exRect.y2);
#fprint(logfile, "Affine transformation parameters:");
#fprintf(logfile, "Forward: x scale = %.6f, y scale = %.6f\n", transAffine.GetForwardScaleX(), transAffine.GetForwardScaleY() );
#fprintf(logfile, "Forward shear = %.6f\n", transAffine.GetForwardShear() );
#$ifdef TEST
#		print("Affine transformation parameters:");
#		printf("Forward: x scale = %.6f, y scale = %.6f\n", transAffine.GetForwardScaleX(), transAffine.GetForwardScaleY() );
#		printf("Forward shear = %.6f\n", transAffine.GetForwardShear() );
#$endif
class IMAGE_PIPELINE_GEOREFERENCE targetGeoref;
targetGeoref.SetTransAffine(outCRS, transAffine);
#fclose(logfile);
#logfile = fopen(logfileName$, "a");
###########################################################
#####   set up pipeline filter to resample the image    #######
class IMAGE_PIPELINE_FILTER_RESAMPLE filterResample(sourceRVC, dimensions, targetGeoref, "Nearest");
err = filterResample.Initialize();
if (err < 0)  {
	ReportError(_context.CurrentLineNum, err);
	#notifyError(error$);
	}
#fprintf(logfile, "filterResample initialized, returned %d\n", err);
#fclose(logfile);
#logfile = fopen(logfileName$, "a");
#$ifdef TEST
#		printf("filterResample initialized, returned %d\n", err);
#$endif
############################################################
#####  set up pipeline filter target and process  ##########
class IMAGE_PIPELINE_TARGET target;			# generic pipeline target, to be assigned specific type
switch (outFormat$)
	{
	case "PDF":
		# create temporary Project File for temp raster
		class RVC_OBJECT outRVC;
		outFilepath.SetExtension(".rvc");
		printf("Filepath = %s\n", outFilepath);
	 	outRVC.MakeTempFile(1);		# delete on close 
		class RVC_OBJITEM outFileObjItem;			# ObjItem for the project file to serve as parent
		outFileObjItem = outRVC.GetObjItem();
		# RVC_OBJITEM for the new raster object
		class RVC_OBJITEM outRastObjItem;	# ObjItem for the output raster
		class RVC_DESCRIPTOR descriptor;
		descriptor.SetName("Rendered");
		descriptor.SetDescription("Provisioning result");
		outRastObjItem.CreateNew(outFileObjItem, "RASTER", descriptor);
		class IMAGE_PIPELINE_TARGET_RVC targetRVC(filterResample, 	outRastObjItem);
		target = targetRVC;
		break;
	}
err = target.Initialize();
if (err < 0)  {
	ReportError(_context.CurrentLineNum, err);
	#notifyError(error$);
	}
#fprintf(logfile, "target initialization returned: %d\n", err);
#$ifdef TEST
#		printf("target initialization returned: %d\n", err);
#$endif
err = target.Process();
if (err < 0)  { 
	ReportError(_context.CurrentLineNum, err);
	#notifyError(error$);
	}
#fprintf(logfile, "target process returned: %d\n", err);
#$ifdef TEST
#		printf("target process returned: %d\n", err);
#$endif
#################   Make PDF File from RVC Target  #########################
if (outFormat$ == "PDF")
	{
	# set up a hardcopy layout with group containing the output raster and render to PDF
#	fprint(logfile, "Setting up layout to render to PDF.");
	class PRINTPARMS printparms;		# page size and scale settings for hardcopy layou	t
	numeric inTOm = GetUnitConvDist("in", "m");			# scale factor from inches to meters
	numeric imgSize, printSize;
	# set up 8.5 x 11 in page in portrait orientation (printable area 7.5 x 10 in, aspect ratio 1.333)
	printparms.FullWidth = 8.5; 					# width in inches including margins
	printparms.FullHeight = 11;					# height in inches including margins
	#printparms.PrintableWidth = 7.5;
	#printparms.PrintableHeight = 10;
	# set layout scale from image/page width
	imgSize = numCols * rastScale.x;					# image ground width in meters
	printSize = 7.0 * inTOm;										# allowed printed size in meters 
	printparms.MapScale = imgSize / printSize;
	# set up a virtual hardcopy layout
	class GRE_LAYOUT pdfLayout;
	pdfLayout.Create("pdfLayout", 1);
	pdfLayout.Hardcopy = printparms;
#	$ifdef TEST
#			printf("Layout %s width = %d, height = %d\n", pdfLayout.Name, printparms.FullWidth, printparms.FullHeight);
#			printf("Image ground size = %d, printSize = %.4f\n", imgSize, printSize);
#			printf("Printparms map scale = %d\n", printparms.MapScale);
#			printf("Layout map scale = %d\n", pdfLayout.MapScale);
#	$endif
	# set up group to contain the image
	class GRE_GROUP imgGroup;
	imgGroup = GroupCreate("ImageGroup", pdfLayout);
	imgGroup.AttachVertical("Center", -0.25, "Page", "Center");
#	$ifdef TEST
#			printf("Name of group to render image: %s\n", imgGroup.Name);
#			printf("Name of layout the group belongs to: %s\n", imgGroup.Layout.Name);
#	$endif
	# add output raster to the imgGroup
	class RVC_RASTER outRast;				# handle for the output RVC raster created by the pipeline
	outRastObjItem = targetRVC.GetObjItem();		# get the objItem for the raster from the temporary project file
	err = outRast.Open(outRastObjItem, "Read");
	if (err < 0)  { 
	ReportError(_context.CurrentLineNum, err);
	#notifyError(error$);
	}
	GroupQuickAddRasterVar(imgGroup, outRast);
	###################################################
	#### if user chose to include section boundary overlay in result
	if (boundary)
		{
		# convert section region to vector
		class VECTOR sectionVect;
		CreateTempVector(sectionVect);
		sectionVect = ConvertRegionToVect(sectionRegion);
		# add the section vector overlay to the imgGroup with appropriate styling
		class GRE_GROUP VectorGroup;
		VectorGroup = GroupCreate("VectorGroup", pdfLayout);
		VectorGroup.AttachVertical("Center", -0.25, "Page", "Center");
		class GRE_LAYER_VECTOR vectLayer;
		vectLayer = GroupQuickAddVectorVar(VectorGroup, sectionVect);		# add section vector to group
		# set display parameters for the section outline 
		vectLayer.Poly.Select.Mode = "None";
		vectLayer.Line.Select.Mode = "All";
		class COLOR lineColor("yellow");
		class LINESTYLE lineStyle;
		lineStyle.Color = lineColor;
		lineStyle.UseLayoutScale = 1;
		lineStyle.Width = 0.5;
		vectLayer.Line.StyleMode = "AllSame";
		vectLayer.Line.NormalStyle = lineStyle;
		}
#	$ifdef TEST
#			printf("outRast.Open() returned: %d\n", err);
#			printf("Group name = %s\n", imgGroup.Name);
#			printf("Group angle to north = %.1f\n", imgGroup.AngleToNorth);
#	$endif
	# add Township-Range-Section caption under the image group in the layout
	class TEXTSTYLE captionStyle;			# style parameters for the caption
	captionStyle.Font = "ARIAL.TTF";
	captionStyle.Height = 18;
	captionStyle.LineSpace = 0.25;
	captionStyle.HeightUnits = "Points";
	captionStyle.JustifyCenter = 1;
	class GRE_GROUP captionGroup;
	captionGroup = GroupCreate("Caption Group", pdfLayout);
	captionGroup.AttachHorizontal("Center", 0, "Page", "Center");
	captionGroup.AttachVertical("Top", 0.2, "Group", "Bottom", imgGroup);
	class GRE_LAYER_TEXT captionLayer(captionGroup, "None", "After"); 
	captionLayer.Style = captionStyle;
	captionLayer.Text = caption$;
#	fprintf(logfile, "Caption = %s\n\n", caption$);
	# add user-defined title above the image group in the layout
	class TEXTSTYLE titleStyle;
	titleStyle.Font = "ARIALBD.TTF";
	titleStyle.Height = 24;
	titleStyle.LineSpace = 30;
	titleStyle.HeightUnits = "Points";
	titleStyle.JustifyCenter = 1;
	class GRE_GROUP titleGroup;
	titleGroup = GroupCreate("Title Group", pdfLayout);
	titleGroup.AttachHorizontal("Center", 0, "Page", "Center");
	titleGroup.AttachVertical("Bottom", 0.25, "Group", "Top", imgGroup);
	class GRE_LAYER_TEXT titleLayer(titleGroup, "None", "After");
	titleLayer.Style = titleStyle;
	titleLayer.Text = title$;
#	fprintf(logfile, "Caption = %s\n\n", caption$);
  ##################################
	# render layout to raster in temporary project file
	pdfLayout.RenderToRaster(rvcfilepath$, correctobjectpath$, 1, 1);
	# compare test output
	class RVC_OBJITEM targetobjitem;
	targetobjitem.SetFilePath(correctfilepath$);
	targetobjitem.SetObjectPath(correctobjectpath$);
	if (!targetobjitem.IsExisting()) {#no known good exists
		print("FAILED - No correct image exists for ", outFormat$);
		CopyObject(rvcfilepath$, 1, correctfilepath$);
		}
	OpenRaster(RDest, rvcfilepath$, correctobjectpath$);
	# set up PDF file
#	class PDF pdf;
#	pdf.SetLayout(pdfLayout);
#	pdf.SetResolution(300);
#	outFilepath.SetExtension(".pdf");
#	pdf.SetPath(outFilepath);
#	pdf.Write();
#	pdf.Finish();
	} # end if PDF
##############################  Make ZIP File  ##########################
#fclose(readme);
# Add output image file and delete raw file
#class STRING imageName$ = outFilepath.GetName();
#zip.AddFile(zipFilepath, outFilepath,  imageName$);
#DeleteFile(outFilepath);
# Add readme file
#class Filepath readmeFilepath(readmeFilename$);
#fprintf(logfile, "readmeFilepath = %s + %s\n", readmeFilepath.GetPath(),  readmeFilepath.GetName() );
#zip.AddFile(zipFilepath, readmeFilepath, readmeFilepath.GetName() );
#DeleteFile(readmeFilename$);
######################################################################
#currentDT.SetCurrent();
#$ifdef TEST
#		printf("Job completed %s Central Standard Time\n\n", currentDT);
#$endif
#fprintf(logfile, "Job completed %s Central Standard Time\n", currentDT);
#fprintf(logfile, "##########################################################\n\n");
#fclose(logfile);
#################################################################
#########  SEND EMAIL NOTIFICATION  ############################
#class STRING mailFilename$;
#class STRING emailbody1$, emailbody2$, emailbody3$;
#class STRING emailbody$;
#email.SetSubject(sprintf("Data Provisioning for Job %s Complete", taskID$) );
#mailFilename$ = _context.ScriptDir + "/" + "emailbody1.txt";
#emailbody1$ = TextFileReadFull(mailFilename$);
#emailbody2$ = sprintf("Please download your sample geodata file now from http://www.geoprovisioning.com/jobs/%s/%s%s\n\n", taskID$, taskID$, ".zip");
#mailFilename$ = _context.ScriptDir + "/" + "emailbody3.txt";
#emailbody3$ = TextFileReadFull(mailFilename$);
#emailbody$ = sprintf("%s%s%s", emailbody1$, emailbody2$, emailbody3$);
#email.SetBody(emailbody$);
#email.SetRecipient(userEmail$);
#email.SendMail();
#ExecuteProcess(finish$);
print("Process Completed");