processfeatures.h

A tutorial and open source code for finding edges and corners based on the filters used in primary v

// ProcessFeatures.h

/*
** Copyright (C) 1994, 2003 Tyler C. Folsom
**
** Permission to use, copy, modify, and distribute this software and its
** documentation for any purpose and without fee is hereby granted, provided
** that the above copyright notice appear in all copies and that both that
** copyright notice and this permission notice appear in supporting
** documentation.  This software is provided "as is" without express or
** implied warranty.
*/
#ifndef PROCESS_FEATURES_H
#define PROCESS_FEATURES_H

#ifndef IFFEATURE_H
#include "IFFeature.h"
#endif

#ifndef IFLOCATION_H
#include "IFLocation.h"
#endif

#ifndef IFFILTER_H
#include "IFFilter.h"
#endif

enum grid_type
{
	eReadGrid,   // get the grid by reading a file
	eMakeGrid,	 // construct a grid based on the options.
	eTest1D,	 // construct a grid for a 1-D test
	eTest2D 	 // construct a grid for a 2-D test
};

// This ties the other classes together.     
class CProcessFeatures
{
	friend class COptions; 
    friend class CImageFeaturesDoc;

public:

    CProcessFeatures( );  // constructor

    // If m_locs is empty, fill it by reading from m_gridFileName.
    // Return "true" if succesful.
    bool ReadGrid();
    bool MakeGrid();  // Return true on constructing a grid
    bool Make1DGrid();  // Return true on constructing a 1D test grid
    bool Make2DGrid();  // Return true on constructing a 2D test grid

    // Set the grid file name to the new value.
    // If this is the same as before, do nothing.
    // Otherwise, read and validate the new grid file.
    // If the new grid is not valid, retain the old one 
    // and return "false".  Otherwise return "true".
    bool SetGrid( CString gridFileName );

    // Associate an image with this process.
    void SetImage( CDefaultImage *pImage )
    { m_pImage = pImage; }

    // Set the bounding rectangle for the image
    void SetBounds( RECT bounds )
    { m_bounds = bounds; }

    // Return the current grid file name.
    CString GetGrid() const
    { return m_gridFileName; }

    // Detect features using the selected image and sampling grid.
    // Create text and graphical output.
    bool Process(grid_type grid);

    // Filter the image at a particular location
    bool Filter( CLocation& location );

    // Correlate the image at the given location with the filters.
	// returned value is the squared sum of magnitudes at all orientations.
    float correlate( CLocation& location, CFilter& filters, int band = 1);

    // Find the features at a particular location
    bool Interpret( CLocation& location );

	// Fill in CFeature::m_pNbr with pointers to adjacent features
	void FindNeighbors();


    // Write text of features.  Return "true" if succesful.
    bool WriteFeatureList
    (   int verbosity = 0,  // 0 for terse, 1 or 2 for more verbose 
        int mode = ios::out,// ios::app to append to file; ios::out for new file
        char* title = "",   // put this on first line
        float noise = 0     // noise level of test image
    );

    // Overlay graphics on the image
    void MakeFeatureImage(CVisRGBAByteImage& featureImage);

    // Plot the kernels for debugging.
    void plotKernels(CVisRGBAByteImage& featureImage ); 

    // Overlay graphics on the image
    void drawLines(CVisRGBAByteImage& image);
    
    // Set the correct answer for test images
    void SetAnswer
    (   feature_type type = eNOT_AVAILABE,
        float x = 0,
        float y = 0,
        float degrees = 90,
        float strength = 0,
        float width = 0
    );

	// True to supress display of bars.
	bool m_viewEdgesOnly;


private:
//    CString m_imageFileName;
    CString m_gridFileName;
    // determines whether grid circles are displayed.
    bool m_viewGrid;
    // Ignore features whose intensity is less than this.
    // Intensity ranges from 0 to 2.0
    float m_threshold;
	// The threshold used also includes lateral inhibition or facilitation,
	// which is weighted by the following factor.  Should be 0 to 1.0.
	float m_lateralFactor;
	// If m_fixedDirection == true, do not steer; use only 0 degree orientation.
	// This is intended for use with stereo correlation, where features
	// in an image pair only differ in one direction.
	bool m_fixedDirection;
	// Extent to which small filters should overlap
	// Used for grid construction.  Should be 1.0 to 3.0
	float m_overlap;
	// Diameter of small filter
	// Used for grid construction
	int m_filterDiam;
    //  Any filters with a radius bigger than subSampleDiam are subsampled.	
	int m_subSampleDiam;
	// true if test images should be displayed.
	bool m_displayTestImages;
	// Contrast for test images: 0 to 256
	int m_testImageContrast;
	// Standard deviation for test image noise level: 0 to 256
	float m_testImageNoise;

    RECT m_bounds;  // limits of the image to be processed.
    // The image to be processed
    CDefaultImage *m_pImage;

    // A list of filters that have been created, indexed by diameter.
    // Use positive diameters for even filters,
    // negative diameters for odd.
    static CMap<int, int&, CFilter, CFilter&> m_filters;

    // A list of locations
    CArray< CLocation, CLocation&> m_locs;

    // A list of features
    CArray< CFeature, CFeature&> m_features;

    // For test images, the correct answer
    Data_1D m_answer;

};
#endif // PROCESS_FEATURES_H