\chapter{Conclusions and Future Work}\label{ch6}

	\section{Conclusions}\label{sec:Conclusions}

	The purpose of this project is to develop an interactive image analysis
	system for the detection of trees in geographic images that may not be
	well suited to tree detection.  The system relies on the judgment of
	the user to compensate for the lack of constraints on the factors that
	determine the suitability of any given automatic tree detection algorithm.
	All factors involved in the tree detection process are intended to be
	controlled by the user at runtime.  Consistent with this goal is the
	selection of a template matching algorithm in which the user is fully
	responsible for defining the templates used in the detection process
	and all other parameters are controlled by the user as well.

	Interactive tree detection using this system is a trial and
	error process.	Ideally, the user continues this process until
	an acceptable level of accuracy achieved, though there is no
	guarantee that such accuracy will be attainable for any given
	image.

	Using two templates, both referencing medium-sized trees in the
	panchromatic image of Kyle Canyon, tree detection accuracy was
	found to be good in about fifteen percent of the image, acceptable
	in about seventy percent of the image, and poor in the remaining
	fifteen percent of the image.  These results were accomplished in
	a few hours including the time required to manually delete trees
	incorrectly placed on top of houses and on roads.  Relatively few
	such manual corrections were necessary due to the great scarcity
	of houses and roads in the image.  However, manual correction
	would not be a practical solution for the overall problem of
	the many false positives occurring in less conspicuous areas.
	The total number of trees detected for the $8km \times 6km$ Kyle Canyon area
	is well in excess of 100,000.  Assuming even a small percentage
	of these to have been placed  incorrectly would likely require
	an inadvisable number of manual deletions.  Other methods of
	dealing with this problem are discussed later in this chapter.

	\section{Future Work}\label{sec:futureWork}

	This project currently provides the user with the ability to delete false
	positives one at a time, but there needs to be a way to delete large
	numbers of such errors all at once.  Such a tool would be less precise,
	but it would be useful in areas where the number false positives is much
	greater than the number of correctly identified trees.  Most likely,
	this would be accomplished by letting the user move the viewer to a
	particular region and then erasing all the tree markers within view.
	A better alternative to large-scale deletions would be to allow the user
	to change the tuning parameters from one region to the next.  This would
	require a restructuring of the data structures to allow multiple sets
	of tuning parameters to be associated with each template and to allow
	each set of templates to be associated with a particular subregion of
	the image.

	The {\em minimum item radius} tuning parameter appears to have little
	effect on the tree-detection results, and it is possible that
	this parameter should be removed.  It was intended to allow
	excessively small trees to be eliminated from consideration.
	Further investigation of the usefulness of this parameter is
	warranted.

	In the current implementation of this project, objects of the
	ItemRef class, the class that stores templates, are collected
	into groups and stored in objects of the ItemGroup class.
	The user selects one of the groups to be the active group.
	At any given time, only the templates in the active group
	will be visible, allowing the user to control which templates
	are simultaneously visible.  It might be more convenient to
	include a flag in the ItemRef class telling the display system
	whether or not to display it.	This would allow the elimination of the
	ItemGroup class.  Alternatively, some facility to allow the user
	to transfer templates from one group to another would make it
	easier to control which templates are visible at the same time.
	Currently, this can be done only by editing the project file.
	Although this is not a difficult process, a built-in facility
	would be helpful.

	Using the utility could be made easier by allowing the user
	to choose the highlighting color used to specify templates.
	As shown in Figure~\ref{fig:treeZoomedInHighlighted}, light green is currently used as the
	highlighting color, but this color could be difficult to see
	in images containing significant amounts of similar colors.
	In addition, it would be helpful to allow the user to cancel
	the filtering process.	There is currently an indicator to
	show the current level of progress but no way of aborting the
	process prematurely.

	The display subsystem is designed to allow the user to view
	very large image files without locking up.  Zooming in and
	out is accomplished using bilinear interpolation to copy a
	rescaled subregion of the image raster to a fixed-size buffer.
	Scrolling is accomplished by changing the position of the view
	window over the buffer.  When the view window reaches the edge
	of the buffer, a new portion of the image raster is copied to
	the buffer and the view window is restored to the center of
	the buffer.  This results in an undesirable momentary pause
	while the copying and bilinear interpolation are being done.
	On computers that lack abundant memory, this system appears less
	likely to lock up than many other viewers.  However, some means
	of eliminating these momentary pauses would be desirable if it
	could be done without greatly increasing memory consumption.

	Currently, this project is used mainly to detect trees and other
	vegetation.  Ideally, it could have been used in a more general
	capacity, to detect any type of item including but not limited
	to vegetation.	In particular, the ability to detect houses and
	buildings would be desirable.  Implementing such capability was
	investigated but not implemented because the algorithm would
	have to be very different from the one used for tree detection.
	All the houses in the image look very different from one another.
	In addition, the houses are often largely occluded by the
	surrounding vegetation.  For these reasons, template matching is
	not likely to be successful.  Instead, an edge-detection filter
	would need to be applied and an algorithm used to distinguish
	the smooth, straight edges associated with artificial structures
	from the rough irregular edges associated with vegetation.
	Finally, a clustering algorithm would need to be applied to try
	to determine which edges belong to the same structure.  Such an
	algorithm could be implemented in this project and could be
	useful when analyzing images containing large numbers of artificial
	structures, provided those structures are not located in very close
	proximity to one another.
